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; }
/* colorlabel_create_color_menu() - creates a color menu without * checkitems, probably for use in combo items */ GtkWidget *colorlabel_create_color_menu(void) { GtkWidget *label; GtkWidget *item; GtkWidget *menu; gint i; colorlabel_recreate_all(); /* create the menu items. each item has its color code attached */ menu = gtk_menu_new(); g_object_set_data(G_OBJECT(menu), "label_color_menu", menu); item = gtk_menu_item_new_with_label(_("None")); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); g_object_set_data(G_OBJECT(item), "color", GUINT_TO_POINTER(0)); gtk_widget_show(item); item = gtk_separator_menu_item_new(); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); gtk_widget_show(item); /* and the color items */ for (i = 0; i < LABEL_COLORS_ELEMS; i++) { GtkWidget *hbox; GtkWidget *vbox; GtkWidget *widget; item = gtk_menu_item_new(); g_object_set_data(G_OBJECT(item), "color", GUINT_TO_POINTER(i + 1)); label = gtk_label_new(label_colors[0][i].label); gtk_widget_show(label); hbox = gtk_hbox_new(FALSE, 0); gtk_widget_show(hbox); gtk_container_add(GTK_CONTAINER(item), hbox); vbox = gtk_vbox_new(TRUE, 0); gtk_widget_show(vbox); gtk_container_set_border_width(GTK_CONTAINER(vbox), 1); widget = colorlabel_create_color_widget(label_colors[0][i].color); gtk_widget_show(widget); gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 4); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); gtk_widget_show(item); } gtk_widget_show(menu); return menu; }
GtkWidget* new_menu_sep (GtkWidget *parent) { GtkWidget *mni_sep = gtk_menu_item_new (); gtk_widget_show (mni_sep); gtk_container_add (GTK_CONTAINER (parent), mni_sep); gtk_widget_set_name (mni_sep, "-x-"); gtk_widget_set_sensitive (mni_sep, FALSE); return mni_sep; }
GtkWidget * glade_gtk_widget_action_submenu (GladeWidgetAdaptor * adaptor, GObject * object, const gchar * action_path) { GladeWidget *gwidget = glade_widget_get_from_gobject (object); GList *groups, *list; if (strcmp (action_path, "sizegroup_add") == 0) { GtkWidget *menu = gtk_menu_new (); GtkWidget *separator, *item; GladeWidget *group; const gchar *size_group_name; if ((groups = list_sizegroups (gwidget)) != NULL) { for (list = groups; list; list = list->next) { group = list->data; size_group_name = glade_widget_get_name (group); if (g_str_has_prefix (size_group_name, GLADE_UNNAMED_PREFIX)) size_group_name = _("(unnamed)"); item = gtk_menu_item_new_with_label (size_group_name); g_object_set_data (G_OBJECT (item), "glade-group-widget", group); g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (glade_gtk_widget_add2group_cb), gwidget); gtk_widget_show (item); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); } g_list_free (groups); separator = gtk_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (menu), separator); gtk_widget_show (separator); } /* Add trailing new... item */ item = gtk_menu_item_new_with_label (_("New Size Group")); g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (glade_gtk_widget_add2group_cb), gwidget); gtk_widget_show (item); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); return menu; } else if (GWA_GET_CLASS (G_TYPE_OBJECT)->action_submenu) return GWA_GET_CLASS (G_TYPE_OBJECT)->action_submenu (adaptor, object, action_path); return NULL; }
static void do_popup_menu (G_GNUC_UNUSED GtkWidget *widget, GdkEventButton *event, QueryFavoriteSelector *tsel) { int button, event_time; if (! tsel->priv->popup_menu) { GtkWidget *menu, *mitem; menu = gtk_menu_new (); g_signal_connect (menu, "deactivate", G_CALLBACK (gtk_widget_hide), NULL); GtkWidget *img; img = gtk_image_new_from_icon_name ("document-properties", GTK_ICON_SIZE_MENU); mitem = gtk_menu_item_new (); gtk_container_add (GTK_CONTAINER (mitem), img); gtk_menu_shell_append (GTK_MENU_SHELL (menu), mitem); gtk_widget_show (mitem); g_signal_connect (mitem, "activate", G_CALLBACK (properties_activated_cb), tsel); img = gtk_image_new_from_icon_name ("edit-delete", GTK_ICON_SIZE_MENU); mitem = gtk_menu_item_new (); gtk_container_add (GTK_CONTAINER (mitem), img); gtk_menu_shell_append (GTK_MENU_SHELL (menu), mitem); gtk_widget_show (mitem); g_signal_connect (mitem, "activate", G_CALLBACK (delete_activated_cb), tsel); tsel->priv->popup_menu = menu; } if (event) { button = event->button; event_time = event->time; } else { button = 0; event_time = gtk_get_current_event_time (); } gtk_menu_popup (GTK_MENU (tsel->priv->popup_menu), NULL, NULL, NULL, NULL, button, event_time); }
static GtkWidget * menu_quick_item (char *cmd, char *label, GtkWidget * menu, int flags, gpointer userdata, char *icon) { GtkWidget *img, *item; if (!label) item = gtk_menu_item_new (); else { if (icon) { /*if (flags & XCMENU_MARKUP) item = gtk_image_menu_item_new_with_markup (label); else*/ item = gtk_image_menu_item_new_with_mnemonic (label); img = gtk_image_new_from_file (icon); if (img) gtk_image_menu_item_set_image ((GtkImageMenuItem *)item, img); else { img = gtk_image_new_from_stock (icon, GTK_ICON_SIZE_MENU); if (img) gtk_image_menu_item_set_image ((GtkImageMenuItem *)item, img); } } else { if (flags & XCMENU_MARKUP) { item = gtk_menu_item_new_with_label (""); if (flags & XCMENU_MNEMONIC) gtk_label_set_markup_with_mnemonic (GTK_LABEL (GTK_BIN (item)->child), label); else gtk_label_set_markup (GTK_LABEL (GTK_BIN (item)->child), label); } else { if (flags & XCMENU_MNEMONIC) item = gtk_menu_item_new_with_mnemonic (label); else item = gtk_menu_item_new_with_label (label); } } } gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); g_object_set_data (G_OBJECT (item), "u", userdata); if (cmd) g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (popup_menu_cb), cmd); if (flags & XCMENU_SHADED) gtk_widget_set_sensitive (GTK_WIDGET (item), FALSE); gtk_widget_show_all (item); return item; }
void plugin_init(G_GNUC_UNUSED GeanyData * data) { gchar *kb_label1; gchar *kb_label2; main_locale_init(LOCALEDIR, GETTEXT_PACKAGE); kb_label1 = _("Document current word"); kb_label2 = _("Document interactive"); config_init(); keyb1 = gtk_menu_item_new(); keyb2 = gtk_menu_item_new(); keybindings_set_item(plugin_key_group, KB_DOCUMENT_WORD, kb_doc, 0, 0, kb_label1, kb_label1, keyb1); keybindings_set_item(plugin_key_group, KB_DOCUMENT_WORD_ASK, kb_doc_ask, 0, 0, kb_label2, kb_label2, keyb2); }
bool GtkToolkitUiSettings::Init(GtkWidget* layout) { m_layout = layout; m_menu_item = gtk_menu_item_new(); gtk_container_add(GTK_CONTAINER(m_layout), m_menu_item); m_settings = gtk_settings_get_default(); return m_settings; }
static GtkWidget* MenuItemWidget() { static GtkWidget* s_widget; if (s_widget == NULL) { s_widget = gtk_menu_item_new(); gtk_container_add(ContainerWidget(), s_widget); gtk_widget_ensure_style(s_widget); } return s_widget; }
/* * Creates a new GtkWidget of class GtkMenuItem, performing any specialized * initialization needed for the widget to work correctly in this environment. * If a dialog box is used to initialize the widget, return NULL from this * function, and call data->callback with your new widget when it is done. * If the widget needs a special destroy handler, add a signal here. */ GtkWidget * gb_menu_item_new (GbWidgetNewData * data) { GtkWidget *new_widget; if (data->action == GB_CREATING) new_widget = gtk_menu_item_new_with_label (data->name); else new_widget = gtk_menu_item_new (); return new_widget; }
GtkWidget * AddSeparator( GtkWidget * Menu ) { GtkWidget * Item = NULL; Item=gtk_menu_item_new (); gtk_widget_show( Item ); gtk_container_add( GTK_CONTAINER( Menu ),Item ); gtk_widget_set_sensitive( Item,FALSE ); return Item; }
static GtkWidget* create_simple_calendar_item(GtkWidget** calendar_out) { GtkWidget* menu_item = gtk_menu_item_new(); GtkWidget* calendar = *calendar_out = gtk_calendar_new(); gtk_calendar_set_display_options(GTK_CALENDAR(calendar), GTK_CALENDAR_SHOW_HEADING | GTK_CALENDAR_NO_MONTH_CHANGE | GTK_CALENDAR_SHOW_DAY_NAMES | GTK_CALENDAR_SHOW_DETAILS); gtk_widget_set_sensitive(menu_item, FALSE); gtk_container_add(GTK_CONTAINER(menu_item), calendar); return menu_item; }
GtkWidget * add_menu_separator (GtkWidget * menu) { GtkWidget *menu_item; menu_item = gtk_menu_item_new (); gtk_menu_append (GTK_MENU (menu), menu_item); gtk_widget_show (menu_item); gtk_widget_set_sensitive (GTK_WIDGET (menu_item), FALSE); return menu_item; }
GtkWidget * gul_gui_append_separator (GtkWidget *menu) { GtkWidget *menu_item; menu_item = gtk_menu_item_new (); gtk_widget_show (menu_item); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item); return menu_item; }
void plugin_init(G_GNUC_UNUSED GeanyData * data) { GeanyKeyGroup *key_group; gchar *kb_label1; gchar *kb_label2; kb_label1 = _("Document current word"); kb_label2 = _("Document interactive"); config_init(); keyb1 = gtk_menu_item_new(); keyb2 = gtk_menu_item_new(); key_group = plugin_set_key_group(geany_plugin, "doc_chars", KB_COUNT, NULL); keybindings_set_item(key_group, KB_DOCUMENT_WORD, kb_doc, 0, 0, kb_label1, kb_label1, keyb1); keybindings_set_item(key_group, KB_DOCUMENT_WORD_ASK, kb_doc_ask, 0, 0, kb_label2, kb_label2, keyb2); }
static void send_receive_add_to_menu (SendReceiveData *data, CamelService *service, gint position) { GtkWidget *menu_item; CamelProvider *provider; if (send_receive_find_menu_item (data, service) != NULL) return; provider = camel_service_get_provider (service); menu_item = gtk_menu_item_new (); gtk_widget_show (menu_item); e_binding_bind_property ( service, "display-name", menu_item, "label", G_BINDING_SYNC_CREATE); if (provider && (provider->flags & CAMEL_PROVIDER_IS_REMOTE) != 0) { gpointer object; if (CAMEL_IS_OFFLINE_STORE (service)) object = g_object_ref (service); else object = camel_service_ref_session (service); e_signal_connect_notify_object ( object, "notify::online", G_CALLBACK (service_online_state_changed_cb), menu_item, 0); g_object_unref (object); } g_hash_table_insert ( data->menu_items, menu_item, g_object_ref (service)); g_signal_connect ( menu_item, "activate", G_CALLBACK (send_receive_account_item_activate_cb), data); /* Position is with respect to the sorted list of CamelService-s, * not menu item position. */ if (position < 0) gtk_menu_shell_append (data->menu, menu_item); else gtk_menu_shell_insert (data->menu, menu_item, position + 4); }
GtkWidget * empathy_presence_chooser_create_menu (void) { const gchar *status; GtkWidget *menu; GtkWidget *item; GtkWidget *image; guint i; menu = gtk_menu_new (); for (i = 0; i < G_N_ELEMENTS (states); i += 2) { GList *list, *l; status = empathy_presence_get_default_message (states[i]); presence_chooser_menu_add_item (menu, status, states[i]); if (states[i+1]) { /* Set custom messages if wanted */ list = empathy_status_presets_get (states[i], 5); for (l = list; l; l = l->next) { presence_chooser_menu_add_item (menu, l->data, states[i]); } g_list_free (list); } } /* Separator. */ item = gtk_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); gtk_widget_show (item); /* Custom messages */ item = gtk_image_menu_item_new_with_label (_("Custom messages...")); image = gtk_image_new_from_stock (GTK_STOCK_EDIT, GTK_ICON_SIZE_MENU); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); gtk_widget_show (image); gtk_widget_show (item); g_signal_connect (item, "activate", G_CALLBACK (presence_chooser_custom_activate_cb), NULL); return menu; }
static GtkMenu *make_menu(GList *l, GtkText *gtktext) { GtkWidget *menu, *item; char *caption; menu = gtk_menu_new(); { caption = g_strdup_printf("Not in dictionary: %s", (char*)l->data); item = gtk_menu_item_new_with_label(caption); /* I'd like to make it so this item is never selectable, like * the menu titles in the GNOME panel... unfortunately, the GNOME * panel creates their own custom widget to do this! */ gtk_widget_show(item); gtk_menu_append(GTK_MENU(menu), item); item = gtk_menu_item_new(); gtk_widget_show(item); gtk_menu_append(GTK_MENU(menu), item); l = l->next; if (l == NULL) { item = gtk_menu_item_new_with_label("(no suggestions)"); gtk_widget_show(item); gtk_menu_append(GTK_MENU(menu), item); } else { GtkWidget *curmenu = menu; int count = 0; do { if (l->data == NULL && l->next != NULL) { count = 0; curmenu = gtk_menu_new(); item = gtk_menu_item_new_with_label("Other Possibilities..."); gtk_widget_show(item); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), curmenu); gtk_menu_append(GTK_MENU(curmenu), item); l = l->next; } else if (count > MENUCOUNT) { count -= MENUCOUNT; item = gtk_menu_item_new_with_label("More..."); gtk_widget_show(item); gtk_menu_append(GTK_MENU(curmenu), item); curmenu = gtk_menu_new(); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), curmenu); } item = gtk_menu_item_new_with_label((char*)l->data); gtk_signal_connect(GTK_OBJECT(item), "activate", GTK_SIGNAL_FUNC(replace_word), gtktext); gtk_widget_show(item); gtk_menu_append(GTK_MENU(curmenu), item); count++; } while ((l = l->next) != NULL); } } return GTK_MENU(menu); }
void EvalCcRqINSERTSEPARATOR (CrossCallInfo *pcci) /* hmenu, pos no result. */ { GtkWidget *menu, *menu_item; printf("EvalCcRqINSERTSEPARATOR\n"); menu = GTK_WIDGET(pcci->p1); menu_item = gtk_menu_item_new(); gtk_menu_insert(GTK_MENU(menu), menu_item, (gint) pcci->p2); gtk_widget_show_all(menu_item); MakeReturn1Cci (pcci, (int64_t) menu_item); }
void ToolDrawCombocontrol::createMenuItem(string name, string icon, ActionType type) { XOJ_CHECK_TYPE(ToolDrawCombocontrol); GtkWidget* menuItem = gtk_menu_item_new (); GtkWidget* box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6); gtk_container_add(GTK_CONTAINER(box), gtk_image_new_from_icon_name(icon.c_str(), GTK_ICON_SIZE_SMALL_TOOLBAR)); gtk_container_add(GTK_CONTAINER(box), gtk_label_new(name.c_str())); gtk_container_add(GTK_CONTAINER(menuItem), box); gtk_container_add(GTK_CONTAINER(popupMenu), menuItem); toolMenuHandler->registerMenupoint(menuItem, type, GROUP_RULER); gtk_widget_show_all(menuItem); }
static void tray_make_item (GtkWidget *menu, char *label, void *callback, void *userdata) { GtkWidget *item; if (label) item = gtk_menu_item_new_with_mnemonic (label); else item = gtk_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (callback), userdata); gtk_widget_show (item); }
GtkWidget *create_server_type_menu (int active_type, gboolean (*filterfunc)(enum server_type), GtkSignalFunc callback) { GtkWidget *option_menu = NULL; GtkWidget *menu = NULL; GtkWidget *menu_item = NULL; GtkWidget *first_menu_item = NULL; int i; int j = 0; int menu_type = 0; option_menu = gtk_option_menu_new (); menu = gtk_menu_new (); for (i = 0; i < GAMES_TOTAL; ++i) { if (filterfunc && !filterfunc (i)) continue; menu_item = gtk_menu_item_new (); if (i == active_type) { first_menu_item = menu_item; menu_type = j; } else if (!first_menu_item) first_menu_item = menu_item; gtk_menu_append (GTK_MENU (menu), menu_item); gtk_container_add (GTK_CONTAINER (menu_item), game_pixmap_with_label (i)); if (callback) gtk_signal_connect (GTK_OBJECT (menu_item), "activate", GTK_SIGNAL_FUNC (callback), GINT_TO_POINTER (i)); gtk_widget_show (menu_item); ++j; // must be here in case the continue was used } gtk_option_menu_set_menu (GTK_OPTION_MENU (option_menu), menu); // initiates callback to set servertype to first configured game if (active_type != -1 && first_menu_item) { gtk_menu_item_activate (GTK_MENU_ITEM (first_menu_item)); gtk_option_menu_set_history (GTK_OPTION_MENU (option_menu), menu_type); } return option_menu; }
static void load_command_bar_sub_menu(const xmlNode *menu, form_element_t *parent) { const xmlChar *title = entry_title_ex(menu, false); GtkToolItem *submenu = gtk_menu_tool_button_new(NULL, GTK_CHAR(title)); form_element_t m; m.widget = gtk_menu_new(); const xmlNode *c = find_by_path(menu, "ContainedItems"); for (c = c->children; c ; c = c->next) { if (is_oftype(c, "Button")) { const xmlChar *c_title = entry_title_ex(c, false); GtkWidget *mel = gtk_menu_item_new_with_label(GTK_CHAR(c_title)); gtk_menu_shell_append(GTK_MENU_SHELL(m.widget), mel); } if (is_oftype(c, "Buttons")) { form_element_t sm; sm.widget = gtk_menu_new(); const xmlChar *c_title = entry_title_ex(c, false); GtkWidget *mel = gtk_menu_item_new_with_label(GTK_CHAR(c_title)); load_command_bar_sub_menu_buttons(c, &sm); gtk_menu_item_set_submenu(GTK_MENU_ITEM(mel), sm.widget); gtk_menu_shell_append(GTK_MENU_SHELL(m.widget), mel); } } gtk_menu_tool_button_set_menu(GTK_MENU_TOOL_BUTTON(submenu), m.widget); { /*! TODO: Выяснить, почему подменю не появляется, если его не добавить в видимое меню на форме */ GtkWidget *mel = gtk_menu_item_new(); gtk_menu_item_set_submenu(GTK_MENU_ITEM(mel), m.widget); gtk_menu_shell_append(GTK_MENU_SHELL(global_menu_bar), mel); } gtk_toolbar_insert(GTK_TOOLBAR(parent->widget), submenu, -1); }
GtkWidget*sc_image_text_item_new(const guint8*data,const char*text,int siz) { GtkWidget*image; GtkWidget*item=gtk_menu_item_new(); GtkWidget*box=gtk_grid_new();//gtk_box_new(GTK_ORIENTATION_HORIZONTAL,2); GtkWidget*label=gtk_label_new(text); gtk_label_set_justify(GTK_LABEL(label),GTK_JUSTIFY_RIGHT); gtk_widget_set_hexpand(label,TRUE); gtk_widget_set_halign(label,GTK_ALIGN_START); GdkPixbuf*pxf=gdk_pixbuf_new_from_inline(-1,data,FALSE,NULL); GdkPixbuf*real_pxf; if(!pxf) { image=gtk_image_new_from_icon_name("image-x-generic",GTK_ICON_SIZE_BUTTON); } else { real_pxf=gdk_pixbuf_scale_simple(pxf,siz,siz,GDK_INTERP_HYPER); g_object_unref(pxf); image=gtk_image_new_from_pixbuf(real_pxf); g_object_set(image,"pixel-size",GTK_IMAGE_PIXBUF,NULL); } g_object_unref(real_pxf); // gtk_widget_set_hexpand(image,FALSE); // gtk_widget_set_halign(image,GTK_ALIGN_START); gtk_grid_attach(GTK_GRID(box),image,0,0,1,1); gtk_grid_attach(GTK_GRID(box),label,1,0,1,1); gtk_grid_set_column_spacing(GTK_GRID(box),20); // gtk_box_pack_start(GTK_BOX(box),image,TRUE,FALSE,0); // gtk_box_pack_end(GTK_BOX(box),label,TRUE,TRUE,0); gtk_container_add(GTK_CONTAINER(item),box); gtk_container_set_border_width(GTK_CONTAINER(box),0); gtk_container_set_border_width(GTK_CONTAINER(item),0); return item; }
static GtkWidget *menu_item_new_with_icon_text(GIcon *icon, const char *text) { GtkWidget *menuitem = gtk_menu_item_new(); GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6); GtkWidget *image = gtk_image_new_from_gicon(icon, GTK_ICON_SIZE_LARGE_TOOLBAR); GtkWidget *label = gtk_label_new(text); gtk_image_set_pixel_size(GTK_IMAGE(image), 24); gtk_box_pack_start(GTK_BOX(box), image, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(box), label, FALSE, FALSE, 0); gtk_container_add(GTK_CONTAINER(menuitem), box); return menuitem; }
gboolean gtkui_plugin_context(GtkWidget *widget, GdkEventButton *event, gpointer data) { GtkTreeIter iter; GtkTreeModel *model; GtkWidget *menu, *item; char *plugin = NULL; (void) widget; (void) data; model = GTK_TREE_MODEL(ls_plugins); menu = gtk_menu_new(); item = gtk_menu_item_new(); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(gtkui_select_plugin), NULL); gtk_widget_show(item); if (gtk_tree_selection_get_selected (GTK_TREE_SELECTION(selection), &model, &iter)) { gtk_tree_model_get (model, &iter, 1, &plugin, -1); } else return FALSE; /* nothing is selected */ if(!plugin) return FALSE; /* bad pointer from gtk_tree_model_get, shouldn't happen */ /* print the message */ if (plugin_is_activated(plugin) == 0) gtk_menu_item_set_label(GTK_MENU_ITEM(item), "Activate"); else gtk_menu_item_set_label(GTK_MENU_ITEM(item), "Deactivate"); if (event->button == 3) { #if GTK_CHECK_VERSION(3,22,0) gtk_menu_popup_at_pointer(GTK_MENU(menu), (GdkEvent*)event); #else gtk_menu_popup(GTK_MENU(data), NULL, NULL, NULL, NULL, 3, event->time); #endif /* * button press event handle must return TRUE to keep the selection * active when pressing the mouse button */ return TRUE; } return FALSE; }
GtkWidget *dt_clist_get_widget(int error_context, struct formfill *form, GByteArray *data, GCallback *activatefunc, gpointer funcdata) { GQTypeDisplayClass* klass = g_type_class_ref(form->dt_handler); GtkWidget *w = dt_generic_binary_get_widget(error_context, form, data, activatefunc, funcdata); GtkWidget *menu = dt_generic_binary_retrieve_menu_widget(w); GtkWidget *item, *s; s = gtk_hseparator_new(); gtk_widget_show(s); item = gtk_menu_item_new(); gtk_widget_show(item); gtk_container_add(GTK_CONTAINER(item), s); gtk_menu_append(GTK_MENU(menu), item); item = gtk_menu_item_new_with_label(_("Details...")); gtk_widget_show(item); gtk_object_set_data(GTK_OBJECT(w), "details", GTK_WIDGET(item)); g_signal_connect(item, "activate", G_CALLBACK(dt_clist_details_button_clicked), w); /* gtk_widget_set_sensitive(item, FALSE); */ gtk_menu_append(GTK_MENU(menu), item); /* PSt: FIXME: hardcoded sizes are BAD */ if (data) { DT_CLIST(klass)->dt_generic.show_entries(form, w, TRUE); gtk_widget_set_usize(w, -1, DT_CLIST_FULL_HEIGHT); } else { DT_CLIST(klass)->dt_generic.show_entries(form, w, FALSE); gtk_widget_set_usize(w, -1, DT_CLIST_EMPTY_HEIGHT); } g_type_class_unref(klass); return w; }
/* Stolen from indicator-loader.c in unity. */ static void entry_added (IndicatorObject * io, IndicatorObjectEntry * entry, gpointer user_data) { GtkMenuShell *menubar = user_data; g_debug("Signal: Entry Added"); GtkWidget * menuitem = gtk_menu_item_new(); g_object_set_data_full (G_OBJECT (menuitem), "indicator object", g_object_ref (io), g_object_unref); GtkWidget * hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3); if (entry->image != NULL) { gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(entry->image), FALSE, FALSE, 0); } gtk_container_add(GTK_CONTAINER(menuitem), hbox); gtk_widget_show(hbox); if (entry->menu != NULL) { gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), GTK_WIDGET(entry->menu)); } gint position = indicator_object_get_position (io); gint i = -1; if (position > 0) { i = 0; GList *items = gtk_container_get_children (GTK_CONTAINER (menubar)); if (items) { GList *it; for (it = items; it != NULL; it = it->next, i++) { IndicatorObject *item_io = g_object_get_data (it->data, "indicator object"); gint item_position = indicator_object_get_position (item_io); if (position > item_position) break; } g_list_free (items); } } menu_shell_insert (menubar, menuitem, i); gtk_widget_show(menuitem); g_object_set_data(G_OBJECT(menuitem), ENTRY_DATA_NAME, entry); return; }
void gui_popup_menu_parallel(void) { GtkWidget *menu; GtkWidget *undockInt = NULL; GtkWidget *module_options; GtkWidget *separator; GtkWidget *module_options_menu; menu = gtk_menu_new(); g_object_set_data(G_OBJECT(menu), "pmInt", menu); if (!settings.showparatab) { undockInt = gtk_menu_item_new_with_label(_("Detach/Attach")); gtk_widget_show(undockInt); gtk_container_add(GTK_CONTAINER(menu), undockInt); } module_options = gtk_menu_item_new_with_label(_("Module Options")); gtk_widget_show(module_options); gtk_container_add(GTK_CONTAINER(menu), module_options); module_options_menu = gtk_menu_new(); gtk_menu_item_set_submenu(GTK_MENU_ITEM(module_options), module_options_menu); main_load_g_ops_parallel(module_options_menu); separator = gtk_menu_item_new(); gtk_widget_show(separator); gtk_container_add(GTK_CONTAINER(menu), separator); gtk_widget_set_sensitive(separator, FALSE); if (!settings.showparatab) { if (undockInt) { g_signal_connect(G_OBJECT(undockInt), "activate", G_CALLBACK(on_undockInt_activate), &settings); } else { XI_warning(("undockInt is NULL?")); } } gtk_menu_popup((GtkMenu *)menu, NULL, NULL, NULL, NULL, 0, gtk_get_current_event_time()); }
/**** Menu item constructor ****/ int clip_GTK_MENUITEMNEW(ClipMachine * ClipMachineMemory) { ClipVar *cv = _clip_spar(ClipMachineMemory, 1); char *label = _clip_parc(ClipMachineMemory, 2); char *pchar = _clip_parc(ClipMachineMemory, 3); GtkWidget *wid = NULL; C_widget *cwid; guint accel_key = 0; CHECKOPT(1, MAP_type_of_ClipVarType); CHECKOPT(2, CHARACTER_type_of_ClipVarType); CHECKOPT(3, CHARACTER_type_of_ClipVarType); if (pchar) { char *pc; for (pc = label; pc && *pc; pc++) if (*pc == *pchar) *pc = '_'; } if (_clip_parinfo(ClipMachineMemory, 2) != CHARACTER_type_of_ClipVarType) wid = gtk_menu_item_new(); else { LOCALE_TO_UTF(label); wid = gtk_menu_item_new_with_label(label); if (pchar) accel_key = gtk_label_parse_uline(GTK_LABEL(GTK_BIN(&(GTK_ITEM(wid)->bin))->child), label); FREE_TEXT(label); } if (!wid) goto err; cwid = _register_widget(ClipMachineMemory, wid, cv); _clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &cwid->obj); _clip_mputn(ClipMachineMemory, &cwid->obj, HASH_ACCELKEY, accel_key); return 0; err: return 1; }