JNIEXPORT void JNICALL Java_org_gnome_gtk_GtkCheckMenuItem_gtk_1check_1menu_1item_1set_1draw_1as_1radio ( JNIEnv* env, jclass cls, jlong _self, jboolean _drawAsRadio ) { GtkCheckMenuItem* self; gboolean drawAsRadio; // convert parameter self self = (GtkCheckMenuItem*) _self; // convert parameter drawAsRadio drawAsRadio = (gboolean) _drawAsRadio; // call function gtk_check_menu_item_set_draw_as_radio(self, drawAsRadio); // cleanup parameter self // cleanup parameter drawAsRadio }
static void gtk_check_menu_item_update (GtkActivatable *activatable, GtkAction *action, const gchar *property_name) { GtkCheckMenuItem *check_menu_item; gboolean use_action_appearance; check_menu_item = GTK_CHECK_MENU_ITEM (activatable); parent_activatable_iface->update (activatable, action, property_name); G_GNUC_BEGIN_IGNORE_DEPRECATIONS; if (strcmp (property_name, "active") == 0) { gtk_action_block_activate (action); gtk_check_menu_item_set_active (check_menu_item, gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action))); gtk_action_unblock_activate (action); } use_action_appearance = gtk_activatable_get_use_action_appearance (activatable); G_GNUC_END_IGNORE_DEPRECATIONS; if (!use_action_appearance) return; if (strcmp (property_name, "draw-as-radio") == 0) { G_GNUC_BEGIN_IGNORE_DEPRECATIONS; gtk_check_menu_item_set_draw_as_radio (check_menu_item, gtk_toggle_action_get_draw_as_radio (GTK_TOGGLE_ACTION (action))); G_GNUC_END_IGNORE_DEPRECATIONS; } }
static void gtk_check_menu_item_sync_action_properties (GtkActivatable *activatable, GtkAction *action) { GtkCheckMenuItem *check_menu_item; gboolean use_action_appearance; gboolean is_toggle_action; check_menu_item = GTK_CHECK_MENU_ITEM (activatable); parent_activatable_iface->sync_action_properties (activatable, action); G_GNUC_BEGIN_IGNORE_DEPRECATIONS; is_toggle_action = GTK_IS_TOGGLE_ACTION (action); G_GNUC_END_IGNORE_DEPRECATIONS; if (!is_toggle_action) return; G_GNUC_BEGIN_IGNORE_DEPRECATIONS; gtk_action_block_activate (action); gtk_check_menu_item_set_active (check_menu_item, gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action))); gtk_action_unblock_activate (action); use_action_appearance = gtk_activatable_get_use_action_appearance (activatable); G_GNUC_END_IGNORE_DEPRECATIONS; if (!use_action_appearance) return; G_GNUC_BEGIN_IGNORE_DEPRECATIONS; gtk_check_menu_item_set_draw_as_radio (check_menu_item, gtk_toggle_action_get_draw_as_radio (GTK_TOGGLE_ACTION (action))); G_GNUC_END_IGNORE_DEPRECATIONS; }
void MainWindowToolbarMenu::addToolbarMenuEntry(ToolbarData* d, GtkMenuShell* menubar, int& menuPos) { XOJ_CHECK_TYPE(MainWindowToolbarMenu); GtkWidget* item = gtk_check_menu_item_new_with_label(d->getName().c_str()); gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM(item), true); gtk_widget_show(item); gtk_menu_shell_insert(menubar, item, menuPos); menuitems.push_back(item); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), d == selectedToolbar); MenuSelectToolbarData* data = new MenuSelectToolbarData(this, item, d, toolbarMenuData.size()); toolbarMenuData.push_back(data); g_signal_connect(item, "toggled", G_CALLBACK(tbSelectMenuitemActivated), data); if (inPredefinedSection && !d->isPredefined()) { GtkWidget* separator = gtk_separator_menu_item_new(); gtk_widget_show(separator); gtk_menu_shell_insert(menubar, separator, menuPos++); inPredefinedSection = false; menuitems.push_back(separator); } }
static void gtk_check_menu_item_update (GtkActivatable *activatable, GtkAction *action, const gchar *property_name) { GtkCheckMenuItem *check_menu_item; check_menu_item = GTK_CHECK_MENU_ITEM (activatable); parent_activatable_iface->update (activatable, action, property_name); if (strcmp (property_name, "active") == 0) { gtk_action_block_activate (action); gtk_check_menu_item_set_active (check_menu_item, gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action))); gtk_action_unblock_activate (action); } if (!gtk_activatable_get_use_action_appearance (activatable)) return; if (strcmp (property_name, "draw-as-radio") == 0) gtk_check_menu_item_set_draw_as_radio (check_menu_item, gtk_toggle_action_get_draw_as_radio (GTK_TOGGLE_ACTION (action))); }
static void on_show_history_menu(GtkMenuToolButton* btn, FmMainWin* win) { GtkMenuShell* menu = (GtkMenuShell*)gtk_menu_tool_button_get_menu(btn); GList* l; GList* cur = fm_nav_history_get_cur_link(win->nav_history); /* delete old items */ gtk_container_foreach(GTK_CONTAINER(menu), (GtkCallback)gtk_widget_destroy, NULL); for(l = fm_nav_history_list(win->nav_history); l; l=l->next) { const FmNavHistoryItem* item = (FmNavHistoryItem*)l->data; FmPath* path = item->path; char* str = fm_path_display_name(path, TRUE); GtkMenuItem* mi; if( l == cur ) { mi = gtk_check_menu_item_new_with_label(str); gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM(mi), TRUE); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mi), TRUE); } else mi = gtk_menu_item_new_with_label(str); g_free(str); g_object_set_qdata_full(G_OBJECT(mi), fm_qdata_id, l, NULL); g_signal_connect(mi, "activate", G_CALLBACK(on_history_item), win); gtk_menu_shell_append(menu, mi); } gtk_widget_show_all( GTK_WIDGET(menu) ); }
static GtkWidget * menu_item_new (MenuItem *menuitem, int workspace_id) { unsigned int key; MetaVirtualModifier mods; const char *i18n_label; GtkWidget *mi; GtkWidget *accel_label; if (menuitem->type == MENU_ITEM_NORMAL) { mi = gtk_menu_item_new (); } else if (menuitem->type == MENU_ITEM_IMAGE) { GtkWidget *image; image = gtk_image_new_from_stock (menuitem->stock_id, GTK_ICON_SIZE_MENU); mi = gtk_image_menu_item_new (); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (mi), image); gtk_widget_show (image); } else if (menuitem->type == MENU_ITEM_CHECKBOX) { mi = gtk_check_menu_item_new (); gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi), menuitem->checked); } else if (menuitem->type == MENU_ITEM_RADIOBUTTON) { mi = gtk_check_menu_item_new (); gtk_check_menu_item_set_draw_as_radio (GTK_CHECK_MENU_ITEM (mi), TRUE); gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi), menuitem->checked); } else if (menuitem->type == MENU_ITEM_WORKSPACE_LIST) return NULL; else return gtk_separator_menu_item_new (); i18n_label = _(menuitem->label); meta_core_get_menu_accelerator (menuitem->op, workspace_id, &key, &mods); accel_label = meta_accel_label_new_with_mnemonic (i18n_label); gtk_misc_set_alignment (GTK_MISC (accel_label), 0.0, 0.5); gtk_container_add (GTK_CONTAINER (mi), accel_label); gtk_widget_show (accel_label); meta_accel_label_set_accelerator (META_ACCEL_LABEL (accel_label), key, mods); return mi; }
static void gtk_radio_menu_item_init (GtkRadioMenuItem *radio_menu_item) { GtkRadioMenuItemPrivate *priv; radio_menu_item->priv = gtk_radio_menu_item_get_instance_private (radio_menu_item); priv = radio_menu_item->priv; priv->group = g_slist_prepend (NULL, radio_menu_item); gtk_check_menu_item_set_draw_as_radio (GTK_CHECK_MENU_ITEM (radio_menu_item), TRUE); }
static GtkWidget *build_roll_menu(void) { GtkWidget *menu; gint i; gchar buffer[128]; MapTheme *theme = theme_get_current(); THEME_COLOR tcolor; GdkColor *color; GtkWidget *item; GtkWidget *label; menu = gtk_menu_new(); for (i = 2; i <= 12; i++) { if (i == 7) continue; tcolor = (i == 6 || i == 8) ? TC_CHIP_H_FG : TC_CHIP_FG; color = &theme->colors[tcolor].color; sprintf(buffer, "<span foreground=\"#%04x%04x%04x\">%d</span>", color->red, color->green, color->blue, i); item = gtk_check_menu_item_new(); label = gtk_label_new(""); gtk_label_set_markup(GTK_LABEL(label), buffer); gtk_container_add(GTK_CONTAINER(item), label); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); g_signal_connect(G_OBJECT(item), "toggled", G_CALLBACK(select_roll_cb), GINT_TO_POINTER(i)); gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM (item), TRUE); roll_numbers[i] = item; } gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new()); /* Menu item */ item = gtk_check_menu_item_new_with_label(_("Shuffle")); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); g_signal_connect(G_OBJECT(item), "toggled", G_CALLBACK(select_shuffle_cb), NULL); shuffle_tile = GTK_CHECK_MENU_ITEM(item); gtk_widget_show_all(menu); return menu; }
static GtkWidget *build_port_menu(void) { gint i; GtkWidget *item; GdkPixmap *pixmap; GtkWidget *image; GtkWidget *menu; MapTheme *theme = theme_get_current(); menu = gtk_menu_new(); for (i = 0; i <= ANY_RESOURCE; i++) { item = gtk_image_menu_item_new_with_mnemonic(gettext (port_names[i])); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(select_port_resource_cb), GINT_TO_POINTER(i)); pixmap = theme->port_tiles[i]; if (i >= NO_RESOURCE || pixmap == NULL) continue; image = gtk_image_new_from_pixmap(pixmap, NULL); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image); } gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new()); for (i = 0; i < 6; i++) { item = gtk_check_menu_item_new_with_label(Q_ (port_direction_names [i])); gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM (item), TRUE); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); g_signal_connect(G_OBJECT(item), "toggled", G_CALLBACK(select_port_direction_cb), GINT_TO_POINTER(i)); port_directions[i] = item; } gtk_widget_show_all(menu); return menu; }
static void gtk_check_menu_item_sync_action_properties (GtkActivatable *activatable, GtkAction *action) { GtkCheckMenuItem *check_menu_item; check_menu_item = GTK_CHECK_MENU_ITEM (activatable); parent_activatable_iface->sync_action_properties (activatable, action); if (!GTK_IS_TOGGLE_ACTION (action)) return; gtk_action_block_activate (action); gtk_check_menu_item_set_active (check_menu_item, gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action))); gtk_action_unblock_activate (action); if (!gtk_activatable_get_use_action_appearance (activatable)) return; gtk_check_menu_item_set_draw_as_radio (check_menu_item, gtk_toggle_action_get_draw_as_radio (GTK_TOGGLE_ACTION (action))); }
static GtkWidget * panel_menu_item_presence_new (TpAccountManager *account_manager, PanelSessionManagerPresenceType presence_type, const char *name, const char *icon, gboolean use_icon) { GtkWidget *item; if (!account_manager) return NULL; item = gtk_check_menu_item_new (); setup_menuitem (item, GTK_ICON_SIZE_INVALID, NULL, name); gtk_check_menu_item_set_draw_as_radio (GTK_CHECK_MENU_ITEM (item), TRUE); /* TODO: we need to add an icon at the right of this CheckMenuItem */ #if 0 if (use_icon) { GtkWidget *image; image = gtk_image_new_from_icon_name (icon, panel_menu_icon_get_size ()); gtk_container_add (GTK_CONTAINER (item), image); } #endif g_object_set_data (G_OBJECT (item), "panel-menu-presence", GINT_TO_POINTER (presence_type)); g_signal_connect (item, "activate", G_CALLBACK (panel_menu_item_activate_presence), account_manager); g_signal_connect (G_OBJECT (item), "button_press_event", G_CALLBACK (menu_dummy_button_press_event), NULL); return item; }
static void gtk_check_menu_item_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { GtkCheckMenuItem *checkitem = GTK_CHECK_MENU_ITEM (object); switch (prop_id) { case PROP_ACTIVE: gtk_check_menu_item_set_active (checkitem, g_value_get_boolean (value)); break; case PROP_INCONSISTENT: gtk_check_menu_item_set_inconsistent (checkitem, g_value_get_boolean (value)); break; case PROP_DRAW_AS_RADIO: gtk_check_menu_item_set_draw_as_radio (checkitem, g_value_get_boolean (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
void pocketvox_indicator_add_module_item(PocketvoxIndicator *indicator,gchar *id) { g_return_if_fail(NULL != indicator); g_return_if_fail(NULL != id); indicator->priv = G_TYPE_INSTANCE_GET_PRIVATE (indicator, TYPE_POCKETVOX_INDICATOR, PocketvoxIndicatorPrivate); PocketvoxIndicatorPrivate *priv = indicator->priv; GtkWidget* item = gtk_check_menu_item_new_with_label(id); gtk_check_menu_item_set_draw_as_radio((GtkCheckMenuItem *)item, TRUE); gtk_check_menu_item_set_active((GtkCheckMenuItem *)item, TRUE); g_signal_connect_swapped((GtkCheckMenuItem *)item, "toggled", G_CALLBACK(pocketvox_indicator_module_toggled), indicator); g_hash_table_insert(priv->table, g_strdup(id), item); gtk_menu_shell_append((GtkMenuShell *)priv->modulesMenu, item); gtk_widget_queue_draw(priv->modulesMenu); gtk_widget_show(item); gtk_widget_show(priv->modulesMenu); gtk_widget_show(priv->modulesItem); }
static gboolean gtk_toggle_tool_button_create_menu_proxy (GtkToolItem *item) { GtkToolButton *tool_button = GTK_TOOL_BUTTON (item); GtkToggleToolButton *toggle_tool_button = GTK_TOGGLE_TOOL_BUTTON (item); GtkWidget *menu_item = NULL; GtkStockItem stock_item; gboolean use_mnemonic = TRUE; const char *label; GtkWidget *label_widget; const gchar *label_text; const gchar *stock_id; if (_gtk_tool_item_create_menu_proxy (item)) return TRUE; label_widget = gtk_tool_button_get_label_widget (tool_button); label_text = gtk_tool_button_get_label (tool_button); stock_id = gtk_tool_button_get_stock_id (tool_button); if (GTK_IS_LABEL (label_widget)) { label = gtk_label_get_label (GTK_LABEL (label_widget)); use_mnemonic = gtk_label_get_use_underline (GTK_LABEL (label_widget)); } else if (label_text) { label = label_text; use_mnemonic = gtk_tool_button_get_use_underline (tool_button); } else if (stock_id && gtk_stock_lookup (stock_id, &stock_item)) { label = stock_item.label; } else { label = ""; } if (use_mnemonic) menu_item = gtk_check_menu_item_new_with_mnemonic (label); else menu_item = gtk_check_menu_item_new_with_label (label); gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item), toggle_tool_button->priv->active); if (GTK_IS_RADIO_TOOL_BUTTON (toggle_tool_button)) { gtk_check_menu_item_set_draw_as_radio (GTK_CHECK_MENU_ITEM (menu_item), TRUE); } g_signal_connect_closure_by_id (menu_item, g_signal_lookup ("activate", G_OBJECT_TYPE (menu_item)), 0, g_cclosure_new_object (G_CALLBACK (menu_item_activated), G_OBJECT (toggle_tool_button)), FALSE); gtk_tool_item_set_proxy_menu_item (item, MENU_ID, menu_item); return TRUE; }
static void ls_build_menu (GOLocaleSel *ls) { GtkWidget *item; GtkMenu *menu; LGroupInfo const *lgroup = lgroups; gint lg_cnt = 0; menu = GTK_MENU (gtk_menu_new ()); while (lgroup->group_name) { LocaleInfo const *locale_trans; GtkMenu *submenu = NULL; locale_trans = locale_trans_array; while (locale_trans->lgroup != LG_LAST) { if (locale_trans->lgroup == lgroup->lgroup && locale_trans->available) { GtkWidget *subitem= gtk_check_menu_item_new_with_label (_(locale_trans->locale_title)); if (!submenu) submenu = GTK_MENU (gtk_menu_new ()); gtk_check_menu_item_set_draw_as_radio (GTK_CHECK_MENU_ITEM (subitem), TRUE); gtk_widget_show (subitem); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), subitem); g_object_set_data (G_OBJECT (subitem), LOCALE_NAME_KEY, (locale_trans->actual_locale)); } locale_trans++; } if (submenu) { GtkWidget *item = gtk_menu_item_new_with_label (_(lgroup->group_name)); gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), GTK_WIDGET (submenu)); gtk_widget_show (item); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); lg_cnt++; } lgroup++; } item = gtk_separator_menu_item_new (); gtk_widget_show (item); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); lg_cnt++; { char *locale_name = get_locale_name (ls); char *locale_menu_title = g_strconcat (_("Current Locale: "), locale_name, NULL); g_free (locale_name); item = gtk_check_menu_item_new_with_label (locale_menu_title); gtk_check_menu_item_set_draw_as_radio (GTK_CHECK_MENU_ITEM (item), TRUE); g_free (locale_menu_title); gtk_widget_show (item); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); lg_cnt++; } go_option_menu_set_menu (ls->locales, GTK_WIDGET (menu)); ls->locales_menu = menu; set_menu_to_default (ls, lg_cnt); }
void vx_gtk_display_show_context_menu(vx_display_t * disp, vx_mouse_event_t * event) { state_t * state = disp->impl; vx_camera_pos_t layer_cam_pos; pthread_mutex_lock(&state->mutex); state->popup_layer_id = pick_layer(state->last_render_info, event->x, event->y); vx_camera_pos_t * pos = NULL; zhash_get(state->last_render_info->camera_positions, &state->popup_layer_id, &pos); if (pos != NULL) memcpy(&layer_cam_pos, pos, sizeof(vx_camera_pos_t)); pthread_mutex_unlock(&state->mutex); if (state->popup_layer_id == 0) return; layer_info_t * linfo = NULL; zhash_get(state->layer_info_map, &state->popup_layer_id, &linfo); GtkWidget * menu = gtk_menu_new(); // Camera buttons { GtkWidget * labelwrapper = gtk_menu_item_new(); GtkWidget * label = gtk_label_new("Foo"); gtk_label_set_markup(GTK_LABEL(label), "<b>Camera options</b>"); gtk_container_add(GTK_CONTAINER(labelwrapper), label); // Auto centers? I guess that's fine gtk_menu_shell_append(GTK_MENU_SHELL(menu), labelwrapper); GtkWidget * resetCam = gtk_menu_item_new_with_label("Reset Camera"); g_signal_connect(resetCam, "activate", (GCallback) menu_action_reset_camera, state); gtk_menu_shell_append(GTK_MENU_SHELL(menu), resetCam); GtkWidget * button1 = gtk_check_menu_item_new_with_label ("Perspective projection"); gtk_menu_shell_append(GTK_MENU_SHELL(menu), button1); gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM(button1), 1); GtkWidget * button2 = gtk_check_menu_item_new_with_label ("Orthographic projection"); gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM(button2), 1); gtk_menu_shell_append(GTK_MENU_SHELL(menu), button2); gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (layer_cam_pos.perspectiveness == 1.0 ? button1 : button2), TRUE); g_signal_connect(button1, "activate", (GCallback) menu_action_perspective, state); g_signal_connect(button2, "activate", (GCallback) menu_action_ortho, state); // Interface modes GtkWidget * iface_wrapper = gtk_menu_item_new_with_label("Interface mode"); gtk_menu_shell_append(GTK_MENU_SHELL(menu), iface_wrapper); { GtkWidget * iface_menu = gtk_menu_new(); gtk_menu_item_set_submenu(GTK_MENU_ITEM(iface_wrapper), iface_menu); GtkWidget * iface_20d = gtk_check_menu_item_new_with_label("2.0D"); gtk_menu_shell_append(GTK_MENU_SHELL(iface_menu), iface_20d); gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM(iface_20d), 1); GtkWidget * iface_25d = gtk_check_menu_item_new_with_label("2.5D"); gtk_menu_shell_append(GTK_MENU_SHELL(iface_menu), iface_25d); gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM(iface_25d), 1); GtkWidget * iface_30d = gtk_check_menu_item_new_with_label("3.0D"); gtk_menu_shell_append(GTK_MENU_SHELL(iface_menu), iface_30d); gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM(iface_30d), 1); float iface = default_cam_mgr_get_interface_mode(linfo->cam_mgr); GtkWidget * active = NULL; if (iface == 2.0f) { active = iface_20d; } else if (iface == 2.5f) { active = iface_25d; } else if (iface == 3.0f) { active = iface_30d; } else { printf("WRN: iface mode %f not supported by menu!\n", iface); active = iface_25d; } gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (active), TRUE); g_signal_connect(iface_20d, "activate", (GCallback) menu_action_iface_20d, state); g_signal_connect(iface_25d, "activate", (GCallback) menu_action_iface_25d, state); g_signal_connect(iface_30d, "activate", (GCallback) menu_action_iface_30d, state); } } { GtkWidget * labelwrapper = gtk_menu_item_new(); GtkWidget * label = gtk_label_new("Foo"); gtk_label_set_markup(GTK_LABEL(label), "<b>Display Options</b>"); gtk_container_add(GTK_CONTAINER(labelwrapper), label); // Auto centers? I guess that's fine gtk_menu_shell_append(GTK_MENU_SHELL(menu), labelwrapper); GtkWidget * showBM = gtk_menu_item_new_with_label("Show Buffer/Layer Manager"); g_signal_connect(showBM, "activate",(GCallback) menu_action_buffer_manager, state); gtk_menu_shell_append(GTK_MENU_SHELL(menu), showBM); GtkWidget * scene = gtk_menu_item_new_with_label("Save Vx Scene"); g_signal_connect(scene, "activate",(GCallback) menu_action_scene, state); gtk_menu_shell_append(GTK_MENU_SHELL(menu), scene); GtkWidget * shot = gtk_menu_item_new_with_label("Save Screenshot"); g_signal_connect(shot, "activate",(GCallback) menu_action_screen_shot, state); gtk_menu_shell_append(GTK_MENU_SHELL(menu), shot); if (state->movie_file == NULL) { GtkWidget * movie = gtk_menu_item_new_with_label("Record movie"); g_signal_connect(movie, "activate",(GCallback) menu_action_record_movie, state); gtk_menu_shell_append(GTK_MENU_SHELL(menu), movie); } else { GtkWidget * movie = gtk_menu_item_new_with_label("Stop movie"); g_signal_connect(movie, "activate",(GCallback) menu_action_stop_movie, state); gtk_menu_shell_append(GTK_MENU_SHELL(menu), movie); } } gtk_widget_show_all(menu); gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, /* (event != NULL) ? event->button : 0, */ 0, gtk_get_current_event_time()); //gdk_event_get_time((GdkEvent*)event)); }
static void sensor_enabled(IsManager *manager, IsSensor *sensor, gint position, IsIndicator *self) { IsIndicatorPrivate *priv = self->priv; /* make sure we haven't seen this sensor before - if sensor has a * menu-item then ignore it */ if (!g_object_get_data(G_OBJECT(sensor), "menu-item")) { GtkMenu *menu; GtkWidget *menu_item; is_debug("indicator", "Creating menu item for newly enabled sensor %s", is_sensor_get_path(sensor)); g_signal_connect(sensor, "notify::value", G_CALLBACK(sensor_notify), self); g_signal_connect(sensor, "notify::label", G_CALLBACK(sensor_notify), self); g_signal_connect(sensor, "notify::alarmed", G_CALLBACK(sensor_notify), self); g_signal_connect(sensor, "notify::low-value", G_CALLBACK(sensor_notify), self); g_signal_connect(sensor, "notify::high-value", G_CALLBACK(sensor_notify), self); /* add a menu entry for this sensor */ menu = is_indicator_get_menu(self); menu_item = gtk_check_menu_item_new(); gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM(menu_item), TRUE); g_object_set_data(G_OBJECT(sensor), "menu-item", menu_item); g_object_set_data(G_OBJECT(menu_item), "sensor", sensor); priv->menu_items = g_slist_insert(priv->menu_items, menu_item, position); /* if we haven't seen our primary sensor yet or if this is the * primary sensor, display this as primary anyway */ if (!priv->primary || g_strcmp0(is_sensor_get_path(sensor), priv->primary_sensor_path) == 0) { is_debug("indicator", "Using sensor with path %s as primary", is_sensor_get_path(sensor)); if (priv->primary) { GtkCheckMenuItem *item; /* uncheck menu item if exists for this * existing primary sensor */ item = (GtkCheckMenuItem *)(g_object_get_data(G_OBJECT(priv->primary), "menu-item")); if (item) { is_debug("indicator", "Unchecking current primary sensor item"); gtk_check_menu_item_set_active(item, FALSE); } g_object_unref(priv->primary); } priv->primary = g_object_ref(sensor); is_debug("indicator", "Checking new primary sensor item"); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_item), TRUE); update_sensor_menu_item_label(self, sensor, GTK_MENU_ITEM(menu_item)); } /* connect to toggled signal now - if we connect to it earlier * we may interpret the above menu_item_set_active as a user * initiated setting of the primary sensor rather than us just * picking the first available sensor */ g_signal_connect(menu_item, "toggled", G_CALLBACK(sensor_menu_item_toggled), self); gtk_widget_show_all(menu_item); update_sensor_menu_item_label(self, sensor, GTK_MENU_ITEM(menu_item)); gtk_menu_shell_insert(GTK_MENU_SHELL(menu), menu_item, position); } else { is_debug("indicator", "Newly enabled sensor %s already has a menu-item, ignoring...", is_sensor_get_path(sensor)); } }
static void popup_prop_menu(GtkButton *prop_button, GdkEventButton *event, GtkWidget *widget) { GtkWidget *menu_item, *hbox, *label, *img; GList *menu_item_list, *icon_list, *label_list, *tooltip_list, *action_list, *state_list, *list; int i, selected = -1; uim_toolbar_check_helper_connection(widget); menu_item_list = gtk_container_get_children(GTK_CONTAINER(prop_menu)); icon_list = g_object_get_data(G_OBJECT(prop_button), "prop_icon"); label_list = g_object_get_data(G_OBJECT(prop_button), "prop_label"); tooltip_list = g_object_get_data(G_OBJECT(prop_button), "prop_tooltip"); action_list = g_object_get_data(G_OBJECT(prop_button), "prop_action"); state_list = g_object_get_data(G_OBJECT(prop_button), "prop_state"); list = menu_item_list; while (list) { gtk_widget_destroy(list->data); list = list->next; } g_list_free(menu_item_list); gtk_widget_destroy(prop_menu); prop_menu = gtk_menu_new(); /* check selected item */ i = 0; while (state_list) { if (!strcmp("*", state_list->data)) { selected = i; break; } state_list = state_list->next; i++; } i = 0; while (label_list) { if (selected != -1) { menu_item = gtk_check_menu_item_new(); label = gtk_label_new(label_list->data); #if GTK_CHECK_VERSION(3, 2, 0) hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); #else hbox = gtk_hbox_new(FALSE, 0); #endif #if GTK_CHECK_VERSION(2, 4, 0) gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM(menu_item), TRUE); #endif if (register_icon(icon_list->data)) img = gtk_image_new_from_stock(icon_list->data, GTK_ICON_SIZE_MENU); else img = gtk_image_new_from_stock("null", GTK_ICON_SIZE_MENU); if (img) { gtk_box_pack_start(GTK_BOX(hbox), img, FALSE, FALSE, 3); gtk_widget_show(img); } gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 3); gtk_container_add(GTK_CONTAINER(menu_item), hbox); gtk_widget_show(label); gtk_widget_show(hbox); if (i == selected) gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_item), TRUE); } else { menu_item = gtk_image_menu_item_new_with_label(label_list->data); if (register_icon(icon_list->data)) { img = gtk_image_new_from_stock(icon_list->data, GTK_ICON_SIZE_MENU); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_item), img); #if GTK_CHECK_VERSION(2, 16, 0) gtk_image_menu_item_set_always_show_image(GTK_IMAGE_MENU_ITEM(menu_item), TRUE); #endif } } /* tooltips */ gtk_widget_set_tooltip_text(menu_item, tooltip_list ? tooltip_list->data : NULL); /* add to the menu */ gtk_menu_shell_append(GTK_MENU_SHELL(prop_menu), menu_item); gtk_widget_show(menu_item); g_signal_connect(G_OBJECT(menu_item), "activate", G_CALLBACK(prop_menu_activate), prop_menu); g_object_set_data(G_OBJECT(menu_item), "prop_action", action_list? action_list->data : NULL); label_list = label_list->next; if (icon_list) icon_list = icon_list->next; if (action_list) action_list = action_list->next; if (tooltip_list) tooltip_list = tooltip_list->next; i++; } g_signal_connect(G_OBJECT(GTK_MENU_SHELL(prop_menu)), "deactivate", G_CALLBACK(prop_menu_shell_deactivate), NULL); gtk_menu_popup(GTK_MENU(prop_menu), NULL, NULL, (GtkMenuPositionFunc)calc_menu_position, (gpointer)prop_button, event->button, gtk_get_current_event_time()); prop_menu_showing = TRUE; }
static void cs_build_menu(GOCharmapSel *cs) { GtkWidget *item; GtkMenu *menu; LGroupInfo const *lgroup = lgroups; gint lg_cnt = 0; menu = GTK_MENU(gtk_menu_new()); while (lgroup->group_name) { CharsetInfo const *charset_trans; GtkMenu *submenu = NULL; charset_trans = charset_trans_array; while (charset_trans->lgroup != LG_LAST) { GtkWidget *subitem; if (charset_trans->lgroup == lgroup->lgroup) { const char *name = (cs->test == GO_CHARMAP_SEL_TO_UTF8) ? charset_trans->to_utf8_iconv_name : charset_trans->from_utf8_iconv_name; if (name) { if (!submenu) submenu = GTK_MENU(gtk_menu_new()); subitem = gtk_check_menu_item_new_with_label( _(charset_trans->charset_title)); gtk_check_menu_item_set_draw_as_radio( GTK_CHECK_MENU_ITEM(subitem), TRUE); gtk_widget_show(subitem); gtk_menu_shell_append(GTK_MENU_SHELL(submenu), subitem); if (charset_trans->imp == CI_MAJOR) cs_emphasize_label( GTK_LABEL(gtk_bin_get_child(GTK_BIN(subitem)))); g_object_set_data(G_OBJECT(subitem), CHARMAP_NAME_KEY, (gpointer) name); } else if (0) { g_print("Unsupported: %s\n", charset_trans->aliases); } } charset_trans++; } if (submenu) { GtkWidget *item = gtk_menu_item_new_with_label( _(lgroup->group_name)); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), GTK_WIDGET(submenu)); gtk_widget_show(item); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); lg_cnt++; } lgroup++; } item = gtk_separator_menu_item_new(); gtk_widget_show(item); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); lg_cnt++; { char *locale_encoding_menu_title = g_strconcat(_("Locale: "), get_locale_encoding_name(cs), NULL); item = gtk_check_menu_item_new_with_label(locale_encoding_menu_title); gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM(item), TRUE); g_free(locale_encoding_menu_title); gtk_widget_show(item); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); lg_cnt++; cs_emphasize_label(GTK_LABEL(gtk_bin_get_child(GTK_BIN(item)))); } go_option_menu_set_menu(cs->encodings, GTK_WIDGET(menu)); cs->encodings_menu = menu; set_menu_to_default(cs, lg_cnt); }
static void gtk_radio_menu_item_init (GtkRadioMenuItem *radio_menu_item) { radio_menu_item->group = g_slist_prepend (NULL, radio_menu_item); gtk_check_menu_item_set_draw_as_radio (GTK_CHECK_MENU_ITEM (radio_menu_item), TRUE); }
static GtkWidget * create_menuitem_from_model (GMenuModel *model, gint item, GActionGroup *group) { GtkWidget *w; gchar *label; gchar *action; gchar *target; gchar *s; ActionData *a; const GVariantType *type; GVariant *v; label = NULL; g_menu_model_get_item_attribute (model, item, G_MENU_ATTRIBUTE_LABEL, "s", &label); action = NULL; g_menu_model_get_item_attribute (model, item, G_MENU_ATTRIBUTE_ACTION, "s", &action); if (action != NULL) type = g_action_group_get_action_state_type (group, action); else type = NULL; if (type == NULL) w = gtk_menu_item_new_with_mnemonic (label); else if (g_variant_type_equal (type, G_VARIANT_TYPE_BOOLEAN)) w = gtk_check_menu_item_new_with_label (label); else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING)) { w = gtk_check_menu_item_new_with_label (label); gtk_check_menu_item_set_draw_as_radio (GTK_CHECK_MENU_ITEM (w), TRUE); } else g_assert_not_reached (); if (action != NULL) { a = g_new0 (ActionData, 1); a->group = g_object_ref (group); a->name = g_strdup (action); g_object_set_data_full (G_OBJECT (w), "action", a, action_data_free); if (!g_action_group_get_action_enabled (group, action)) gtk_widget_set_sensitive (w, FALSE); s = g_strconcat ("action-enabled-changed::", action, NULL); a->enabled_changed_id = g_signal_connect (group, s, G_CALLBACK (enabled_changed), w); g_free (s); a->activate_handler = g_signal_connect (w, "activate", G_CALLBACK (item_activated), NULL); if (type == NULL) { /* all set */ } else if (g_variant_type_equal (type, G_VARIANT_TYPE_BOOLEAN)) { s = g_strconcat ("action-state-changed::", action, NULL); a->state_changed_id = g_signal_connect (group, s, G_CALLBACK (toggle_state_changed), w); g_free (s); v = g_action_group_get_action_state (group, action); gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w), g_variant_get_boolean (v)); g_variant_unref (v); } else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING)) { s = g_strconcat ("action-state-changed::", action, NULL); a->state_changed_id = g_signal_connect (group, s, G_CALLBACK (radio_state_changed), w); g_free (s); g_menu_model_get_item_attribute (model, item, G_MENU_ATTRIBUTE_TARGET, "s", &target); a->target = g_strdup (target); v = g_action_group_get_action_state (group, action); gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w), g_strcmp0 (g_variant_get_string (v, NULL), target) == 0); g_variant_unref (v); g_free (target); } else g_assert_not_reached (); } g_free (label); g_free (action); return w; }