static GtkWidget* create_menu() { GtkWidget* menu; menu = gtk_menu_new(); menu_item_state = gtk_menu_item_new_with_label("State: "); gtk_widget_set_sensitive(menu_item_state, FALSE); GtkWidget* delay3 = gtk_menu_item_new_with_label("delay 3 min"); GtkWidget* delay5 = gtk_menu_item_new_with_label("delay 5 min"); GtkWidget* pause = gtk_menu_item_new_with_label("pause"); GtkWidget* unpause = gtk_menu_item_new_with_label("continue"); GtkWidget* rest_now = gtk_menu_item_new_with_label("rest now"); GtkWidget* quit = gtk_menu_item_new_with_label("quit"); GtkWidget* sep1 = gtk_separator_menu_item_new(); GtkWidget* sep2 = gtk_separator_menu_item_new(); GtkWidget* sep3 = gtk_separator_menu_item_new(); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item_state); gtk_menu_shell_append(GTK_MENU_SHELL(menu), sep1); gtk_menu_shell_append(GTK_MENU_SHELL(menu), delay3); gtk_menu_shell_append(GTK_MENU_SHELL(menu), delay5); gtk_menu_shell_append(GTK_MENU_SHELL(menu), sep2); gtk_menu_shell_append(GTK_MENU_SHELL(menu), pause); gtk_menu_shell_append(GTK_MENU_SHELL(menu), unpause); gtk_menu_shell_append(GTK_MENU_SHELL(menu), rest_now); gtk_menu_shell_append(GTK_MENU_SHELL(menu), sep3); gtk_menu_shell_append(GTK_MENU_SHELL(menu), quit); g_signal_connect (G_OBJECT(delay3), "activate", G_CALLBACK(on_delay), GUINT_TO_POINTER(180)); g_signal_connect (G_OBJECT(delay5), "activate", G_CALLBACK(on_delay), GUINT_TO_POINTER(300)); g_signal_connect (G_OBJECT(pause), "activate", G_CALLBACK(on_pause), NULL); g_signal_connect (G_OBJECT(unpause), "activate", G_CALLBACK(on_unpause), NULL); g_signal_connect (G_OBJECT(rest_now), "activate", G_CALLBACK(on_rest_now), NULL); g_signal_connect (G_OBJECT(quit), "activate", G_CALLBACK(on_quit), NULL); gtk_widget_show_all(menu); return menu; }
/* * CreateBarSubMenu * * Create a submenu within an existing submenu. (In other words, it's not * the menubar.) * * menu - existing submenu * szName - label to be given to the new submenu off of this submenu * * returns new menu widget */ GtkWidget *CreateBarSubMenu (GtkWidget *menu, char *szName) { GtkWidget *menuitem; GtkWidget *submenu; /* --- Create menu --- */ menuitem = gtk_menu_item_new_with_label (szName); /* --- Add it to the menubar --- */ gtk_menu_bar_append (GTK_MENU_BAR (menu), menuitem); gtk_widget_show (menuitem); /* --- Get a menu and attach to the menuitem --- */ submenu = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu); /* --- Viola! --- */ return (submenu); }
void show_user(void) { gint UID = getuid(); struct passwd *p = getpwuid(UID); user_button = gtk_button_new_with_label(strtok(p->pw_gecos, ",\n\t\0")); gtk_button_set_relief(GTK_BUTTON(user_button), GTK_RELIEF_NONE); g_signal_connect(G_OBJECT(user_button), "button-press-event", G_CALLBACK(show_user_context), NULL); g_signal_connect(G_OBJECT(user_button), "destroy", G_CALLBACK(redraw_user), NULL); user_menu = gtk_menu_new(); GtkWidget *logout = gtk_menu_item_new_with_label("Logout"); gtk_menu_shell_append(GTK_MENU_SHELL(user_menu), logout); g_signal_connect(G_OBJECT(logout), "button-press-event", G_CALLBACK(user_logout), NULL); gtk_widget_show_all(user_menu); gtk_box_pack_end(GTK_BOX(box), user_button, FALSE, FALSE, 5); }
static void property_dialog_setup_option_menu (GtkWidget *option_menu, GCallback func, gpointer user_data, gconstpointer str1, ...) { GtkWidget *menu; GtkWidget *menu_item; gint i; va_list args; gconstpointer str; gint type; menu = gtk_option_menu_get_menu (GTK_OPTION_MENU (option_menu)); if (menu) { gtk_widget_destroy (menu); } menu = gtk_menu_new (); va_start (args, str1); for (str = str1, i = 0; str != NULL; str = va_arg (args, gpointer), i++) { menu_item = gtk_menu_item_new_with_label (str); gtk_widget_show (menu_item); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item); type = va_arg (args, gint); g_object_set_data (G_OBJECT (menu_item), "data", GINT_TO_POINTER (type)); if (func) { g_signal_connect (menu_item, "activate", func, user_data); } } va_end (args); gtk_widget_show (menu); gtk_option_menu_set_menu (GTK_OPTION_MENU (option_menu), menu); }
static void gpp_append_new_item (GladeProjectProperties *properties, GtkWidget *popup, const gchar *label, GCallback activate_cb) { GtkWidget *item; if (label) item = gtk_menu_item_new_with_label (label); else item = gtk_separator_menu_item_new (); if (activate_cb) g_signal_connect (item, "activate", activate_cb, properties); gtk_menu_shell_append (GTK_MENU_SHELL (popup), item); gtk_widget_show (item); }
/* * Sets the properties of the widget. This is used for both applying the * properties changed in the property editor, and also for loading. */ static void gb_option_menu_set_properties (GtkWidget * widget, GbWidgetSetArgData * data) { gchar *items; GtkWidget *menu, *menuitem; gint choice; items = gb_widget_input_text (data, Items); if (data->apply) { gchar *pos = items; gchar *items_end = &items[strlen (items)]; menu = gtk_menu_new (); gtk_signal_connect (GTK_OBJECT (menu), "deactivate", GTK_SIGNAL_FUNC (gb_option_menu_on_option_selected), widget); while (pos < items_end) { gchar *item_end = strchr (pos, '\n'); if (item_end == NULL) item_end = items_end; *item_end = '\0'; menuitem = gtk_menu_item_new_with_label (pos); gtk_widget_show (menuitem); gtk_menu_append (GTK_MENU (menu), menuitem); pos = item_end + 1; } gtk_option_menu_set_menu (GTK_OPTION_MENU (widget), menu); } if (data->action == GB_APPLYING) g_free (items); choice = gb_widget_input_int (data, Choice); if (data->apply) { gtk_option_menu_set_history (GTK_OPTION_MENU (widget), choice); } }
GList* icon_theme_init() { // Build a menu list of available themes. icon_theme_set_theme(NULL); if(_debug_){ gint n_elements; gchar** path[64]; gtk_icon_theme_get_search_path(icon_theme, path, &n_elements); int i; for(i=0;i<n_elements;i++){ dbg(2, "icon_theme_path=%s", path[0][i]); } g_strfreev(*path); } GtkWidget* menu = gtk_menu_new(); GPtrArray* names = g_ptr_array_new(); get_theme_names(names); int i; for (i = 0; i < names->len; i++) { char* name = names->pdata[i]; dbg(2, "name=%s", name); GtkWidget* item = gtk_menu_item_new_with_label(name); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); g_object_set_data(G_OBJECT(item), "theme", g_strdup(name)); //make sure this string is free'd when menu is updated. g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(icon_theme_on_select), NULL); g_free(name); } gtk_widget_show_all(menu); g_ptr_array_free(names, TRUE); return themes = g_list_append(NULL, menu); }
static gboolean show_menu(GtkWidget *widget, GdkEventButton *event) { GtkWidget *menu = gtk_menu_new(); GtkWidget *header_item; if (event->button != 1) return FALSE; /* Create the menu items */ header_item = gtk_menu_item_new_with_label("Help"); gtk_widget_set_sensitive(header_item, FALSE); gtk_menu_append(GTK_MENU(menu), header_item); gtk_widget_show(header_item); /* Contact button */ GtkWidget* contact_item = gtk_image_menu_item_new_with_label("Contact Us"); g_signal_connect(contact_item, "activate", G_CALLBACK(contact_clicked), NULL); gtk_menu_append(GTK_MENU(menu), contact_item); gtk_widget_show(contact_item); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(contact_item), get_resized_icon(CONTACT_ICON)); /* Knowledge button */ GtkWidget* knowledge_item = gtk_image_menu_item_new_with_label("Help Center"); g_signal_connect(knowledge_item, "activate", G_CALLBACK(knowledge_clicked), NULL); gtk_menu_append(GTK_MENU(menu), knowledge_item); gtk_widget_show(knowledge_item); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(knowledge_item), get_resized_icon(KNOWLEDGE_ICON)); /* Screenshot button */ GtkWidget* screenshot_item = gtk_image_menu_item_new_with_label("Report a Problem"); g_signal_connect(screenshot_item, "activate", G_CALLBACK(screenshot_clicked), NULL); gtk_menu_append(GTK_MENU(menu), screenshot_item); gtk_widget_show(screenshot_item); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(screenshot_item), get_resized_icon(SCREENSHOT_ICON)); g_signal_connect(menu, "selection-done", G_CALLBACK(selection_done), NULL); /* Show the menu. */ gtk_menu_popup(GTK_MENU(menu), NULL, NULL, (GtkMenuPositionFunc) menu_pos, widget, event->button, event->time); return TRUE; }
/** * Add to any menu * mostly for allowing to assign for TrackWaypoint layer menus */ void vik_ext_tool_datasources_add_menu_items_to_menu ( VikWindow *vw, GtkMenu *menu ) { GList *iter; for (iter = ext_tool_datasources_list; iter; iter = iter->next) { VikExtTool *ext_tool = NULL; gchar *label = NULL; ext_tool = VIK_EXT_TOOL ( iter->data ); label = vik_ext_tool_get_label ( ext_tool ); if ( label ) { GtkWidget *item = NULL; item = gtk_menu_item_new_with_label ( _(label) ); g_free ( label ); label = NULL; // Store tool's ref into the menu entry g_object_set_data ( G_OBJECT(item), VIK_TOOL_DATASOURCE_KEY, ext_tool ); g_signal_connect ( G_OBJECT(item), "activate", G_CALLBACK(ext_tool_datasources_open_cb), vw ); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); gtk_widget_show ( item ); } } }
void create_list_for_type(pa_devicelist_t *list) { int i, j; for(i = 0; i < 16; i++) { if(!list[i].initialized) break; for(j = 0; j < list[i].n_ports; j++) { GtkWidget *widget = gtk_menu_item_new_with_label(list[i].ports[j].description); gtk_menu_append(GTK_MENU_SHELL (menu),widget); gtk_widget_show(widget); // HER VAR VI. SEGFAULT SOMEWHERE pa_device_port_t *dp = malloc(sizeof(pa_device_port_t)); dp->device = list[i]; dp->port = list[i].ports[j]; g_signal_connect(G_OBJECT(widget), "activate", G_CALLBACK(activate_action), dp); } } }
void fill_app_indicator(pa_devicelist_t *input, pa_devicelist_t *output) { gtk_widget_destroy(menu); GtkWidget *menu_items[3]; menu = gtk_menu_new(); create_list_for_type(input); add_separator_to_menu(); create_list_for_type(output); add_separator_to_menu(); GtkWidget *btn_quit = gtk_menu_item_new_with_label("Quit"); gtk_menu_append(GTK_MENU_SHELL (menu),btn_quit); gtk_widget_show(btn_quit); g_signal_connect (btn_quit, "activate", G_CALLBACK (gtk_main_quit), NULL); app_indicator_set_menu (indicator, GTK_MENU (menu)); }
static void populate_menus (GladeXML *dialog) { gint corner, action; GtkWidget *menu; GtkWidget *menuitem; for (corner = REGION_FIRST_CORNER; REGION_IS_CORNER (corner); ++corner) { menu = gtk_menu_new(); for (action = 0; action < HANDLED_ACTIONS; ++action) { menuitem = gtk_menu_item_new_with_label ( action_descriptions[action]); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); } gtk_option_menu_set_menu (GTK_OPTION_MENU ( WID (corners[corner].action_menu_id)), menu); } }
void view_popup_menu(GtkWidget *treeview, GdkEventButton *event, gpointer userdata) { GtkWidget *menu, *menuitem; menu = gtk_menu_new(); menuitem = gtk_menu_item_new_with_label("Do something"); g_signal_connect(menuitem, "activate",(GCallback) view_popup_menu_onDoSomething, treeview); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); gtk_widget_show_all(menu); /* Note: event can be NULL here when called from view_onPopupMenu; * gdk_event_get_time() accepts a NULL argument */ gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, (event != NULL) ? event->button : 0, gdk_event_get_time((GdkEvent*)event)); }
/* * gtunet_create_tray_menu * * Create the menu on the tray icon */ GtkMenu * gtunet_create_tray_menu () { GtkWidget *tray_menu; GtkWidget *tray_menu_quit; tray_menu_quit = gtk_menu_item_new_with_label("Quit"); g_signal_connect(G_OBJECT(tray_menu_quit), "activate", G_CALLBACK (on_button_quit_clicked), NULL); tray_menu = gtk_menu_new(); gtk_menu_shell_append((GtkMenuShell *)tray_menu, tray_menu_quit); gtk_widget_show(tray_menu_quit); return (GtkMenu *)tray_menu; }
int main(int argc, char *argv[]) { // {{{ if (!gtk_init_check(&argc, &argv)) { std::cout << "Could not init GTK." << std::endl; return 1; } GtkWidget *window; GtkWidget *vbox; GtkWidget *menubar, *viewmenu, *view, *tog_stat, *statusbar; // menubar window = gtk_window_new(GTK_WINDOW_TOPLEVEL); vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(window), vbox); menubar = gtk_menu_bar_new(); viewmenu = gtk_menu_new(); view = gtk_menu_item_new_with_label("View"); tog_stat = gtk_check_menu_item_new_with_label("View Statusbar"); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(tog_stat), TRUE); gtk_menu_item_set_submenu(GTK_MENU_ITEM(view), viewmenu); gtk_menu_shell_append(GTK_MENU_SHELL(viewmenu), tog_stat); gtk_menu_shell_append(GTK_MENU_SHELL(menubar), view); gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 3); statusbar = gtk_statusbar_new(); gtk_box_pack_end(GTK_BOX(vbox), statusbar, FALSE, TRUE, 1); gtk_widget_show_all(window); g_signal_connect_swapped(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL); g_signal_connect_swapped(G_OBJECT(tog_stat), "activate", G_CALLBACK(toggle_statusbar), statusbar); gtk_main(); return 0; } // }}}
/** * Create a menu with the list of accounts. This list is * clickable and activates func if specified. * used for now to add a submenu item in a main menu * * \param func Function to call when a line is selected * \param activate_currrent If set to TRUE, does not mark as * unsensitive current account * \param include_closed If set to TRUE, include the closed accounts * * \return A newly created menu */ GtkWidget *gsb_account_create_menu_list ( GCallback func, gboolean activate_currrent, gboolean include_closed ) { GtkWidget *menu; GtkWidget *item; GSList *list_tmp; menu = gtk_menu_new (); list_tmp = gsb_data_account_get_list_accounts (); while ( list_tmp ) { gint i; i = gsb_data_account_get_no_account ( list_tmp -> data ); if ( i >= 0 && ( !gsb_data_account_get_closed_account (i) || include_closed ) ) { item = gtk_menu_item_new_with_label ( gsb_data_account_get_name (i)); g_object_set_data ( G_OBJECT ( item ), "account_number", GINT_TO_POINTER (i)); if ( func ) g_signal_connect ( G_OBJECT ( item ), "activate", G_CALLBACK(func), NULL ); gtk_menu_shell_append ( GTK_MENU_SHELL ( menu ), item ); if ( !activate_currrent && gsb_gui_navigation_get_current_account () == i) { gtk_widget_set_sensitive ( item, FALSE ); } gtk_widget_show ( item ); } list_tmp = list_tmp -> next; } return ( menu ); }
/* returns a GtkMenu containing all available profiles for * monitor [mon] */ static int fill_profiles_menu (DdccApplet *applet) { struct profile* profile; GtkWidget* item; if (!ddcci_get_all_profiles (applet->monitor)) return 0; for (profile=applet->monitor->profiles;profile;profile=profile->next) { item = gtk_menu_item_new_with_label ((gchar*)profile->name); g_object_set_data (G_OBJECT (item), "ddcc_profile", profile); g_signal_connect (item, "activate", G_CALLBACK (change_profile_cb), applet); gtk_widget_show (item); gtk_container_add (GTK_CONTAINER (applet->w_profiles_menu), item); } return 1; }
void update_bookmark_menu() { GList *bookmarks; gint i; if (browser->bookmark_menu) { gtk_menu_item_set_submenu(GTK_MENU_ITEM(browser->bookmark_menu_item), NULL); browser->bookmark_menu = NULL; } browser->bookmark_menu = gtk_menu_new(); bookmarks = prefs_get_list("coverweb_bookmark_"); for (i = 0; i < g_list_length(bookmarks); ++i) { gchar *bookmark = g_list_nth_data(bookmarks, i); GtkWidget *bookitem = gtk_menu_item_new_with_label(bookmark); gtk_menu_shell_append(GTK_MENU_SHELL (browser->bookmark_menu), bookitem); g_signal_connect (G_OBJECT (bookitem), "activate", G_CALLBACK(bookmark_menu_item_cb), (gpointer) browser); gtk_widget_show(bookitem); } gtk_menu_item_set_submenu(GTK_MENU_ITEM (browser->bookmark_menu_item), browser->bookmark_menu); }
/** *显示接收附件的TreeView的弹出菜单回调函数.(待接收和已接收都用此函数) * @param widget TreeView * @param event 事件 */ gint DialogPeer::RcvTreePopup(GtkWidget *treeview,GdkEvent *event) { GtkWidget *menu,*menuitem; GdkEventButton *event_button; menu = gtk_menu_new(); menuitem = gtk_menu_item_new_with_label(_("Remove Selected")); g_signal_connect_swapped(menuitem, "activate", G_CALLBACK(RemoveSelectedRcv), treeview); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); if (event->type == GDK_BUTTON_PRESS) { event_button = (GdkEventButton *) event; if (event_button->button == 3) { gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, event_button->button, event_button->time); gtk_widget_show(menuitem); return TRUE; } } return FALSE; }
// Build the menu from the list of strings static void BuildRecentFilesMenu (GtkWidget *menu, GtkSignalFunc pfn, gpointer data) { int Nix ; char *pszBaseName = NULL ; GtkWidget *menu_item = NULL ; gtk_container_foreach (GTK_CONTAINER (menu), (GtkCallback)gtk_widget_destroy, NULL) ; for (Nix = 0 ; Nix < icRecentFiles ; Nix++) { pszBaseName = base_name (ppszRecentFiles[Nix]) ; menu_item = gtk_menu_item_new_with_label (pszBaseName) ; gtk_widget_ref (menu_item) ; gtk_object_set_data (GTK_OBJECT (menu_item), "file", ppszRecentFiles[Nix]) ; gtk_object_set_data (GTK_OBJECT (menu_item), "parent", menu) ; gtk_widget_show (menu_item) ; gtk_container_add (GTK_CONTAINER (menu), menu_item) ; gtk_signal_connect (GTK_OBJECT (menu_item), "activate", pfn, data) ; } }
static void create_menu_entry (GtkWidget * menu, int index, GtkWidget * box, GtkDataboxGraph * graph) { GtkWidget *menu_items; char buf[128]; col_sel *sel = g_new0 (col_sel, 1); sel->index = index; sel->box = box; sel->graph = graph; sprintf (buf, "Change Color #%d", index); menu_items = gtk_menu_item_new_with_label (buf); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items); g_signal_connect_swapped (G_OBJECT (menu_items), "activate", G_CALLBACK (menu_color_change_cb), (gpointer) sel); gtk_widget_show (menu_items); }
void iceb_pm_vibor(class iceb_u_spisok *strmenu,GtkWidget **opt,int *nomer_str) { *opt = gtk_option_menu_new(); GtkWidget *menu = gtk_menu_new(); int nomer=0; GtkWidget *item; for(int ii=0; ii < strmenu->kolih(); ii++) { item = gtk_menu_item_new_with_label (strmenu->ravno_toutf(ii)); gtk_signal_connect (GTK_OBJECT (item), "activate",GtkSignalFunc(iceb_pm_vibor_get),nomer_str); gtk_object_set_user_data(GTK_OBJECT(item),(gpointer)nomer++); gtk_widget_show (item); gtk_menu_append (GTK_MENU (menu), item); } gtk_option_menu_set_menu (GTK_OPTION_MENU (*opt), menu); gtk_option_menu_set_history(GTK_OPTION_MENU(*opt),*nomer_str); }
int main(int argc, char **argv) { bindtextdomain("tray_randr", LOCALE_DIR); textdomain("tray_randr"); gtk_init(&argc, &argv); icon = (GtkStatusIcon *) gtk_status_icon_new_from_file(ICON_PATH "randr.png"); menu = gtk_menu_new(); newitem(&item_swext, _("Switch to external display"), CMD_SWEXT); newitem(&item_swint, _("Switch to built-in display"), CMD_SWINT); newitem(&item_clone, _("Use both displays"), CMD_CLONE); sep = gtk_separator_menu_item_new(); gtk_widget_show(sep); gtk_menu_shell_append(GTK_MENU_SHELL(menu), sep); newitem(&item_ext1024, _("Set ext. resolution to 1024x768"), CMD_1024); newitem(&item_ext800, _("Set ext. resolution to 800x600"), CMD_800); newitem(&item_ext640, _("Set ext. resolution to 640x480"), CMD_640); g_signal_connect(G_OBJECT(icon), "popup-menu", G_CALLBACK(popup), NULL); sep = gtk_separator_menu_item_new(); gtk_widget_show(sep); gtk_menu_shell_append(GTK_MENU_SHELL(menu), sep); item_quit = gtk_menu_item_new_with_label(_("Quit")); gtk_widget_show(item_quit); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item_quit); g_signal_connect(G_OBJECT(item_quit), "activate", G_CALLBACK(quit), NULL); gtk_main(); return 0; }
static GtkMenu * build_sort_field_base_menu (SortFlowState *state) { gint start; gint end; gint index; GtkWidget *menu = gtk_menu_new (); GList* items = NULL; if (state->sel != NULL) { if (state->is_cols) { start = state->sel->v_range.cell.a.col; end = state->sel->v_range.cell.b.col; index = state->sel->v_range.cell.a.row; } else { start = state->sel->v_range.cell.a.row; end = state->sel->v_range.cell.b.row; index = state->sel->v_range.cell.a.col; } build_sort_field_menu (start, end, index, menu, state, state->sort_items); items = gtk_container_get_children (GTK_CONTAINER (menu)); } if (items == NULL) { GtkWidget *item; item = (GtkWidget *) gtk_menu_item_new_with_label(state->is_cols ? _("no available column"): _("no available row")); gtk_widget_set_sensitive( GTK_WIDGET (item), FALSE); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); gtk_widget_show (item); } g_list_free (items); return GTK_MENU (menu); }
static void xfce_constructor (XfcePanelPlugin *plugin) { MultiloadPlugin *multiload = multiload_new(); multiload->panel_data = plugin; multiload->panel_orientation = xfce_panel_plugin_get_orientation (plugin); gtk_container_add (GTK_CONTAINER (plugin), GTK_WIDGET(multiload->container)); multiload_ui_read (multiload); multiload_start(multiload); /* show the panel's right-click menu on this ebox */ xfce_panel_plugin_add_action_widget (plugin, GTK_WIDGET(multiload->container)); /* plugin signals */ g_signal_connect(G_OBJECT(plugin), "free-data", G_CALLBACK (xfce_free_cb), multiload); g_signal_connect(G_OBJECT(plugin), "save", G_CALLBACK (xfce_save_cb), multiload); g_signal_connect(G_OBJECT(plugin), "size-changed", G_CALLBACK (xfce_size_changed_cb), multiload); g_signal_connect(G_OBJECT(plugin), "orientation-changed", G_CALLBACK (xfce_orientation_changed_cb), multiload); /* menu items */ GtkMenuItem *mi_separator = GTK_MENU_ITEM(gtk_separator_menu_item_new ()); GtkMenuItem *mi_help = GTK_MENU_ITEM(gtk_menu_item_new_with_mnemonic (_("_Help"))); GtkMenuItem *mi_sysmon = GTK_MENU_ITEM(gtk_menu_item_new_with_label(_("Start task manager"))); xfce_panel_plugin_menu_show_configure (plugin); xfce_panel_plugin_menu_show_about (plugin); xfce_panel_plugin_menu_insert_item (plugin, mi_separator); xfce_panel_plugin_menu_insert_item (plugin, mi_help); xfce_panel_plugin_menu_insert_item (plugin, mi_sysmon); g_signal_connect (G_OBJECT (plugin), "configure-plugin", G_CALLBACK (xfce_configure_cb), multiload); g_signal_connect (G_OBJECT (plugin), "about", G_CALLBACK (xfce_about_cb), NULL); g_signal_connect (G_OBJECT (mi_help), "activate", G_CALLBACK (xfce_help_cb), NULL); g_signal_connect (G_OBJECT (mi_sysmon), "activate", G_CALLBACK (xfce_sysmon_cb), multiload); gtk_widget_show(GTK_WIDGET(mi_separator)); gtk_widget_show(GTK_WIDGET(mi_help)); gtk_widget_show(GTK_WIDGET(mi_sysmon)); }
int32 AddMenu(CefRefPtr<CefBrowser> browser, ExtensionString title, ExtensionString command, ExtensionString position, ExtensionString relativeId) { // if (tag == kTagNotFound) { // tag = NativeMenuModel::getInstance(getMenuParent(browser)).getOrCreateTag(command, ExtensionString()); // } else { // // menu already there // return NO_ERROR; // } GtkWidget* menuBar = GetMenuBar(browser); GtkWidget* menuWidget = gtk_menu_new(); GtkWidget* menuHeader = gtk_menu_item_new_with_label(title.c_str()); gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuHeader), menuWidget); gtk_menu_shell_append(GTK_MENU_SHELL(menuBar), menuHeader); gtk_widget_show(menuHeader); // FIXME add lookup for menu widgets _menuWidget = menuWidget; return NO_ERROR; }
static void fill_menu (GtkWidget *menu) { struct dirent *e; char *dname = gnome_unconditional_pixmap_file ("same-gnome"); DIR *dir; int itemno = 0; dir = opendir (dname); if (!dir) return; while ((e = readdir (dir)) != NULL){ GtkWidget *item; char *s = strdup (e->d_name); if (!strstr (e->d_name, ".png")) { free (s); continue; } item = gtk_menu_item_new_with_label (s); gtk_widget_show (item); gtk_menu_append (GTK_MENU(menu), item); gtk_signal_connect (GTK_OBJECT(item), "activate", GTK_SIGNAL_FUNC (set_selection), s); gtk_signal_connect (GTK_OBJECT(item), "destroy", GTK_SIGNAL_FUNC (free_str), s); if (!strcmp(scenario, s)) { gtk_menu_set_active(GTK_MENU(menu), itemno); } itemno++; } closedir (dir); }
/** * Create a menu containing a link to all possible CSV fields. This * is normally an event triggered by a click on a GtkTreeViewColumn. * * \param col Column that triggered event. * \param field Position of column that triggered event. * \param assistant Assistant that contains the column. * * \return A newly-created GtkMenu. */ GtkWidget * csv_import_fields_menu ( GtkTreeViewColumn * col, gint field, GtkWidget * assistant ) { GtkWidget * menu, * item; int i; menu = gtk_menu_new(); for ( i = 0 ; csv_fields[i] . name ; i++ ) { item = gtk_menu_item_new_with_label ( (gchar *) _( csv_fields[i] . name ) ); g_object_set_data ( G_OBJECT ( item ), "column", col ); g_object_set_data ( G_OBJECT ( item ), "field", GINT_TO_POINTER( field - 1 ) ); g_object_set_data ( G_OBJECT ( item ), "assistant", assistant ); g_signal_connect ( G_OBJECT ( item ), "activate", G_CALLBACK ( csv_import_change_field ), GINT_TO_POINTER( i ) ); gtk_menu_shell_append ( GTK_MENU_SHELL ( menu ), item ); } gtk_widget_show_all ( menu ); return menu; }
static gboolean goio_console_update_device_menu (GtkWidget *menu) { GtkWidget *sub_menu; GtkWidget *menu_item; GSList *device_names = NULL;//ngi_sensor_world_get_available_device_names(NGI_SENSOR_WORLD (sensor_world)); GSList *iter; g_return_val_if_fail (menu != NULL, FALSE); g_return_val_if_fail (GTK_MENU_ITEM (menu), FALSE); sub_menu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (menu)); if (!device_names) device_names = g_slist_append(device_names, g_string_new ("None")); GList *current = gtk_container_get_children (GTK_CONTAINER (sub_menu)); GList *iterc; for (iterc = current; iterc; iterc = g_list_next (iterc)) { gtk_container_remove (GTK_CONTAINER (sub_menu),GTK_WIDGET (iterc->data)); } for (iter = device_names; iter; iter = g_slist_next (iter)) { GString *label_name = iter->data; menu_item = gtk_menu_item_new_with_label (label_name->str); gtk_menu_shell_append (GTK_MENU_SHELL (sub_menu), menu_item); g_signal_connect_swapped (G_OBJECT (menu_item), "activate", G_CALLBACK (goio_console_device_selected), menu_item); gtk_widget_show (menu_item); } return TRUE; }
static GtkWidget *init_menu_item_manual_charset(gchar *manual_charset) { static GtkLabel *label; gchar *str; if (other_codeset_title == NULL) other_codeset_title = _("Other Codeset"); str = manual_charset ? g_strdup_printf("%s (%s)", other_codeset_title, manual_charset) : g_strdup_printf("%s...", other_codeset_title); if (!menu_item_manual_charset) { menu_item_manual_charset = gtk_menu_item_new_with_label(str); label = GTK_LABEL(gtk_bin_get_child(GTK_BIN(menu_item_manual_charset))); } else // gtk_label_set_text(GTK_LABEL(GTK_BIN(menu_item_manual_charset)->child), str); gtk_label_set_text(label, str); g_free(str); return menu_item_manual_charset; }