static GtkWidget * create_menu_item (GtkAction* action) { GtkWidget* menu; GtkWidget* menu_item; GList* actions = XDIFF_EXT_SUBMENU_ACTION(action)->actions; menu = gtk_menu_new (); while(actions) { GtkAction* a = GTK_ACTION(actions->data); if(a != NULL) { menu_item = gtk_action_create_menu_item(a); gtk_widget_show(menu_item); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item); } else { GtkWidget* s = gtk_separator_menu_item_new(); gtk_widget_show(s); gtk_menu_shell_append(GTK_MENU_SHELL(menu), s); } actions = g_list_next(actions); } gtk_widget_show(menu); menu_item = GTK_ACTION_CLASS(parent_class)->create_menu_item(action); gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item), menu); gtk_widget_show(menu_item); return menu_item; }
static GtkWidget *browserWindowCreateBackForwardMenu(BrowserWindow *window, GList *list) { if (!list) return NULL; GtkWidget *menu = gtk_menu_new(); GList *listItem; for (listItem = list; listItem; listItem = g_list_next(listItem)) { WebKitBackForwardListItem *item = (WebKitBackForwardListItem *)listItem->data; const char *uri = webkit_back_forward_list_item_get_uri(item); const char *title = webkit_back_forward_list_item_get_title(item); GtkAction *action = gtk_action_new(uri, title, NULL, NULL); g_object_set_data_full(G_OBJECT(action), "back-forward-list-item", g_object_ref(item), g_object_unref); g_signal_connect_swapped(action, "activate", G_CALLBACK(browserWindowHistoryItemActivated), window); GtkWidget *menuItem = gtk_action_create_menu_item(action); g_signal_connect_swapped(menuItem, "select", G_CALLBACK(browserWindowHistoryItemSelected), window); g_object_unref(action); gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), menuItem); gtk_widget_show(menuItem); } g_signal_connect(menu, "hide", G_CALLBACK(resetStatusText), window); return menu; }
gboolean _gtk_tool_item_create_menu_proxy (GtkToolItem *item) { GtkWidget *menu_item; gboolean visible_overflown; if (item->priv->action) { g_object_get (item->priv->action, "visible-overflown", &visible_overflown, NULL); if (visible_overflown) { menu_item = gtk_action_create_menu_item (item->priv->action); g_object_ref_sink (menu_item); gtk_tool_item_set_proxy_menu_item (item, "gtk-action-menu-item", menu_item); g_object_unref (menu_item); } else gtk_tool_item_set_proxy_menu_item (item, "gtk-action-menu-item", NULL); return TRUE; } return FALSE; }
/*! \param toolbar object add to it \param name name of the action and also display it in tooltip \param icon_path Address of the icon (It can be NULL) */ GtkAction* ijadi_gui_create_action_menu (GtkWidget *menu,const gchar *name) { GtkAction *action = gtk_action_new(name, name,name,NULL); GtkWidget *menuItem = gtk_action_create_menu_item(action); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuItem); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuItem), NULL); return action; }
/* * For application-level menu additions. */ void fm__add_menu_item(GtkAction* action) { AyyiFilemanager* fm = file_manager__get(); GtkWidget* menu_item = gtk_action_create_menu_item(action); gtk_menu_shell_append(GTK_MENU_SHELL(fm->menu), menu_item); gtk_widget_show(menu_item); }
int main(int argc, char *argv[]) { gtk_init(&argc, &argv); GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size(GTK_WINDOW(window), 200, 200); g_signal_connect(window, "destroy", G_CALLBACK(destroy), NULL); GtkWidget *menubar = gtk_menu_bar_new(); gtk_container_add(GTK_CONTAINER(window), menubar); GtkActionGroup *actiongroup = gtk_action_group_new("ActionGroup"); GtkAction *action = gtk_action_new("actionFile", "_File", NULL, NULL); gtk_action_group_add_action(GTK_ACTION_GROUP(actiongroup), action); GtkWidget *menuitemFile = gtk_action_create_menu_item(GTK_ACTION(action)); gtk_menu_bar_append(GTK_MENU_BAR(menubar), menuitemFile); GtkWidget *menu = gtk_menu_new(); gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitemFile), menu); GtkToggleAction *toggleaction; toggleaction = gtk_toggle_action_new("actionNew", "_New", "Create a new document", GTK_STOCK_NEW); gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(toggleaction), TRUE); gtk_action_group_add_action(GTK_ACTION_GROUP(actiongroup), GTK_ACTION(toggleaction)); GtkWidget *menuitemNew = gtk_action_create_menu_item(GTK_ACTION(toggleaction)); gtk_menu_append(GTK_MENU(menu), menuitemNew); toggleaction = gtk_toggle_action_new("actionOpen", "_Open", "Open a file", GTK_STOCK_OPEN); gtk_action_group_add_action(GTK_ACTION_GROUP(actiongroup), GTK_ACTION(toggleaction)); GtkWidget *menuitemOpen = gtk_action_create_menu_item(GTK_ACTION(toggleaction)); gtk_menu_append(GTK_MENU(menu), menuitemOpen); toggleaction = gtk_toggle_action_new("actionSave", "_Save", "Save a file", GTK_STOCK_SAVE); gtk_action_group_add_action(GTK_ACTION_GROUP(actiongroup), GTK_ACTION(toggleaction)); GtkWidget *menuitemSave = gtk_action_create_menu_item(GTK_ACTION(toggleaction)); gtk_menu_append(GTK_MENU(menu), menuitemSave); gtk_widget_show_all(window); gtk_main(); return 0; }
void GtkPopupMenu::appendItem(GtkAction* action) { GtkWidget* menuItem = gtk_action_create_menu_item(action); gtk_widget_set_tooltip_text(menuItem, gtk_action_get_tooltip(action)); g_signal_connect(menuItem, "select", G_CALLBACK(GtkPopupMenu::selectItemCallback), this); gtk_menu_shell_append(GTK_MENU_SHELL(m_popup.get()), menuItem); if (gtk_action_is_visible(action)) gtk_widget_show(menuItem); }
static GtkWidget *add_item(GtkWidget *menu, GtkAccelGroup *accelgrp, GtkActionGroup *actions, const char *name) { GtkAction *action; GtkWidget *item; action = gtk_action_group_get_action(actions, name); g_return_val_if_fail(action != NULL, NULL); gtk_action_set_accel_group(action, accelgrp); item = gtk_action_create_menu_item(action); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); gtk_widget_show(item); return item; }
void WebPopupMenuProxyGtk::populatePopupMenu(const Vector<WebPopupItem>& items) { int itemIndex = 0; for (const auto& item : items) { if (item.m_type == WebPopupItem::Separator) { GtkWidget* menuItem = gtk_separator_menu_item_new(); gtk_menu_shell_append(GTK_MENU_SHELL(m_popup), menuItem); gtk_widget_show(menuItem); } else { GRefPtr<GtkAction> action = adoptGRef(createGtkActionForMenuItem(item, itemIndex)); GtkWidget* menuItem = gtk_action_create_menu_item(action.get()); gtk_widget_set_tooltip_text(menuItem, gtk_action_get_tooltip(action.get())); g_signal_connect(menuItem, "select", G_CALLBACK(selectItemCallback), this); gtk_menu_shell_append(GTK_MENU_SHELL(m_popup), menuItem); if (gtk_action_is_visible(action.get())) gtk_widget_show(menuItem); } itemIndex++; } }
static gboolean create_popup_menu_item (GeditCollaborationWindowHelper *helper, GtkMenu *menu, const gchar *id, gboolean create_separator) { GtkAction *action; GtkWidget *item; GtkActionGroup *ac; action = get_action (helper, id); g_object_get (action, "action-group", &ac, NULL); if (!gtk_action_get_sensitive (action) || !gtk_action_group_get_sensitive (ac)) { g_object_unref (ac); return FALSE; } gtk_action_set_accel_group (action, gtk_ui_manager_get_accel_group (helper->priv->uimanager)); g_object_unref (ac); if (create_separator) { item = gtk_separator_menu_item_new (); gtk_widget_show (item); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); } item = gtk_action_create_menu_item (action); gtk_widget_show (item); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); return TRUE; }
/*! \brief Translate a resource tree into a menu structure * * \param [in] menu The GHidMainMenu widget to be acted on * \param [in] shall The base menu shell (a menu bar or popup menu) * \param [in] res The base of the resource tree * */ void ghid_main_menu_real_add_resource (GHidMainMenu *menu, GtkMenuShell *shell, const Resource *res) { int i, j; const Resource *tmp_res; gchar mnemonic = 0; for (i = 0; i < res->c; ++i) { const gchar *accel = NULL; char *menu_label; const char *res_val; const Resource *sub_res = res->v[i].subres; GtkAction *action = NULL; switch (resource_type (res->v[i])) { case 101: /* name, subres: passthrough */ ghid_main_menu_real_add_resource (menu, shell, sub_res); break; case 1: /* no name, subres */ tmp_res = resource_subres (sub_res, "a"); /* accelerator */ res_val = resource_value (sub_res, "m"); /* mnemonic */ if (res_val) mnemonic = res_val[0]; /* The accelerator resource will have two values, like * a={"Ctrl-Q" "Ctrl<Key>q"} * The first Gtk ignores. The second needs to be translated. */ if (tmp_res) accel = check_unique_accel (translate_accelerator (tmp_res->v[1].value)); /* Now look for the first unnamed value (not a subresource) to * figure out the name of the menu or the menuitem. */ res_val = "button"; for (j = 0; j < sub_res->c; ++j) if (resource_type (sub_res->v[j]) == 10) { res_val = _(sub_res->v[j].value); break; } /* Hack '_' in based on mnemonic value */ if (!mnemonic) menu_label = g_strdup (res_val); else { char *post_ = strchr (res_val, mnemonic); if (post_ == NULL) menu_label = g_strdup (res_val); else { GString *tmp = g_string_new (""); g_string_append_len (tmp, res_val, post_ - res_val); g_string_append_c (tmp, '_'); g_string_append (tmp, post_); menu_label = g_string_free (tmp, FALSE); } } /* If the subresource we're processing also has unnamed * subresources, it's a submenu, not a regular menuitem. */ if (sub_res->flags & FLAG_S) { /* SUBMENU */ GtkWidget *submenu = gtk_menu_new (); GtkWidget *item = gtk_menu_item_new_with_mnemonic (menu_label); GtkWidget *tearoff = gtk_tearoff_menu_item_new (); gtk_menu_shell_append (shell, item); gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), submenu); /* add tearoff to menu */ gtk_menu_shell_append (GTK_MENU_SHELL (submenu), tearoff); /* recurse on the newly-added submenu */ ghid_main_menu_real_add_resource (menu, GTK_MENU_SHELL (submenu), sub_res); } else { /* NON-SUBMENU: MENU ITEM */ const char *checked = resource_value (sub_res, "checked"); const char *label = resource_value (sub_res, "sensitive"); const char *tip = resource_value (sub_res, "tip"); if (checked) { /* TOGGLE ITEM */ gchar *name = g_strdup_printf ("MainMenuAction%d", action_counter++); action = GTK_ACTION (gtk_toggle_action_new (name, menu_label, tip, NULL)); /* checked=foo is a binary flag (checkbox) * checked=foo,bar is a flag compared to a value (radio) */ gtk_toggle_action_set_draw_as_radio (GTK_TOGGLE_ACTION (action), !!strchr (checked, ',')); } else if (label && strcmp (label, "false") == 0) { /* INSENSITIVE ITEM */ GtkWidget *item = gtk_menu_item_new_with_label (menu_label); gtk_widget_set_sensitive (item, FALSE); gtk_menu_shell_append (shell, item); } else { /* NORMAL ITEM */ gchar *name = g_strdup_printf ("MainMenuAction%d", action_counter++); action = gtk_action_new (name, menu_label, tip, NULL); } } /* Connect accelerator, if there is one */ if (action) { GtkWidget *item; gtk_action_set_accel_group (action, menu->accel_group); gtk_action_group_add_action_with_accel (menu->action_group, action, accel); gtk_action_connect_accelerator (action); g_signal_connect (G_OBJECT (action), "activate", menu->action_cb, (gpointer) sub_res); g_object_set_data (G_OBJECT (action), "resource", (gpointer) sub_res); item = gtk_action_create_menu_item (action); gtk_menu_shell_append (shell, item); menu->actions = g_list_append (menu->actions, action); menu->special_key_cb (accel, action, sub_res); } /* Scan rest of resource in case there is more work */ for (j = 0; j < sub_res->c; j++) { const char *res_name; /* named value = X resource */ if (resource_type (sub_res->v[j]) == 110) { res_name = sub_res->v[j].name; /* translate bg, fg to background, foreground */ if (strcmp (res_name, "fg") == 0) res_name = "foreground"; if (strcmp (res_name, "bg") == 0) res_name = "background"; /* ignore special named values (m, a, sensitive) */ if (strcmp (res_name, "m") == 0 || strcmp (res_name, "a") == 0 || strcmp (res_name, "sensitive") == 0 || strcmp (res_name, "tip") == 0) break; /* log checked and active special values */ if (action && strcmp (res_name, "checked") == 0) g_object_set_data (G_OBJECT (action), "checked-flag", sub_res->v[j].value); else if (action && strcmp (res_name, "active") == 0) g_object_set_data (G_OBJECT (action), "active-flag", sub_res->v[j].value); else /* if we got this far it is supposed to be an X * resource. For now ignore it and warn the user */ Message (_("The gtk gui currently ignores \"%s\"" "as part of a menuitem resource.\n" "Feel free to provide patches\n"), sub_res->v[j].value); } } break; case 10: /* no name, value */ /* If we get here, the resource is "-" or "@foo" for some foo */ if (res->v[i].value[0] == '@') { GList *children; int pos; children = gtk_container_get_children (GTK_CONTAINER (shell)); pos = g_list_length (children); g_list_free (children); if (strcmp (res->v[i].value, "@layerview") == 0) { menu->layer_view_shell = shell; menu->layer_view_pos = pos; } else if (strcmp (res->v[i].value, "@layerpick") == 0) { menu->layer_pick_shell = shell; menu->layer_pick_pos = pos; } else if (strcmp (res->v[i].value, "@routestyles") == 0) { menu->route_style_shell = shell; menu->route_style_pos = pos; } else Message (_("GTK GUI currently ignores \"%s\" in the menu\n" "resource file.\n"), res->v[i].value); } else if (strcmp (res->v[i].value, "-") == 0) { GtkWidget *item = gtk_separator_menu_item_new (); gtk_menu_shell_append (shell, item); } else if (i > 0) { /* This is an action-less menuitem. It is really only useful * when you're starting to build a new menu and you're looking * to get the layout right. */ GtkWidget *item = gtk_menu_item_new_with_label (_(res->v[i].value)); gtk_menu_shell_append (shell, item); } break; } } }
int main (int argc, char *argv[]) { int i; const char *commandLine_File = NULL; GtkWidget *pVBox; GtkWidget *pMenuBar; GtkWidget *pMenu, *pSubMenu; GtkWidget *pMenuItem, *pSubMenuItem; GtkAccelGroup * accel_group; if(argc == 2) commandLine_File = argv[1]; #ifdef DEBUG LogStart(); #endif gtk_init(&argc, &argv); SDL_Init(SDL_INIT_VIDEO); desmume_init(); dTools_running = (BOOL*)malloc(sizeof(BOOL) * dTools_list_size); for(i=0; i<dTools_list_size; i++) dTools_running[i]=FALSE; CONFIG_FILE = g_build_filename(g_get_home_dir(), ".desmume.ini", NULL); Read_ConfigFile(); /* Creation de la fenetre */ pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(pWindow), "Desmume"); gtk_window_set_policy (GTK_WINDOW (pWindow), FALSE, FALSE, FALSE); gtk_window_set_icon(GTK_WINDOW (pWindow), gdk_pixbuf_new_from_xpm_data(DeSmuME_xpm)); g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL); g_signal_connect(G_OBJECT(pWindow), "key_press_event", G_CALLBACK(Key_Press), NULL); g_signal_connect(G_OBJECT(pWindow), "key_release_event", G_CALLBACK(Key_Release), NULL); /* Creation de la GtkVBox */ pVBox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(pWindow), pVBox); accel_group = gtk_accel_group_new(); action_group = gtk_action_group_new("dui"); gtk_action_group_add_actions(action_group, action_entries, sizeof(action_entries) / sizeof(GtkActionEntry), pWindow); { GList * list = gtk_action_group_list_actions(action_group); g_list_foreach(list, dui_set_accel_group, accel_group); } gtk_window_add_accel_group(GTK_WINDOW(pWindow), accel_group); gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "pause"), FALSE); gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "run"), FALSE); gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "reset"), FALSE); gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "printscreen"), FALSE); /**** Creation du menu ****/ pMenuBar = gtk_menu_bar_new(); /** Menu "Fichier" **/ pMenu = gtk_menu_new(); gtk_container_add(GTK_CONTAINER(pMenu), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "open"))); gtk_container_add(GTK_CONTAINER(pMenu), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "printscreen"))); gtk_container_add(GTK_CONTAINER(pMenu), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "quit"))); pMenuItem = gtk_menu_item_new_with_label("File"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), pMenu); gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem); /** Menu "Emulation" **/ GtkWidget *mEmulation; GtkWidget *mFrameskip; GtkWidget *mFrameskip_Radio[MAX_FRAMESKIP]; GtkWidget *mGraphics; GtkWidget *mSize; GtkWidget *mSize_Radio[MAX_SCREENCOEFF]; GtkWidget *mLayers; GtkWidget *mLayers_Radio[10]; mEmulation = gtk_menu_new(); pMenuItem = gtk_menu_item_new_with_label("Emulation"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mEmulation); gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem); gtk_container_add(GTK_CONTAINER(mEmulation), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "run"))); gtk_container_add(GTK_CONTAINER(mEmulation), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "pause"))); gtk_container_add(GTK_CONTAINER(mEmulation), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "reset"))); mFrameskip = gtk_menu_new(); pMenuItem = gtk_menu_item_new_with_label("Frameskip"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mFrameskip); gtk_menu_shell_append(GTK_MENU_SHELL(mEmulation), pMenuItem); for(i = 0; i < MAX_FRAMESKIP; i++) { char frameskipRadio_buf[16]; sprintf(frameskipRadio_buf, "%d", i); if(i>0) mFrameskip_Radio[i] = gtk_radio_menu_item_new_with_label_from_widget(GTK_RADIO_MENU_ITEM(mFrameskip_Radio[i-1]), frameskipRadio_buf); else mFrameskip_Radio[i] = gtk_radio_menu_item_new_with_label(NULL, frameskipRadio_buf); g_signal_connect(G_OBJECT(mFrameskip_Radio[i]), "activate", G_CALLBACK(Modify_Frameskip), GINT_TO_POINTER(i)); gtk_menu_shell_append(GTK_MENU_SHELL(mFrameskip), mFrameskip_Radio[i]); } gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mFrameskip_Radio[0]), TRUE); mGraphics = gtk_menu_new(); pMenuItem = gtk_menu_item_new_with_label("Graphics"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mGraphics); gtk_menu_shell_append(GTK_MENU_SHELL(mEmulation), pMenuItem); // TODO: Un jour, peut être... >< mSize = gtk_menu_new(); pMenuItem = gtk_menu_item_new_with_label("Size"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mSize); gtk_menu_shell_append(GTK_MENU_SHELL(mGraphics), pMenuItem); for(i = 1; i < MAX_SCREENCOEFF; i++) { char sizeRadio_buf[16]; sprintf(sizeRadio_buf, "x%d", i); if(i>1) mSize_Radio[i] = gtk_radio_menu_item_new_with_label_from_widget(GTK_RADIO_MENU_ITEM(mSize_Radio[i-1]), sizeRadio_buf); else mSize_Radio[i] = gtk_radio_menu_item_new_with_label(NULL, sizeRadio_buf); g_signal_connect(G_OBJECT(mSize_Radio[i]), "activate", G_CALLBACK(Modify_ScreenCoeff), GINT_TO_POINTER(i)); gtk_menu_shell_append(GTK_MENU_SHELL(mSize), mSize_Radio[i]); } gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mFrameskip_Radio[0]), TRUE); mLayers = gtk_menu_new(); pMenuItem = gtk_menu_item_new_with_label("Layers"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mLayers); gtk_menu_shell_append(GTK_MENU_SHELL(mGraphics), pMenuItem); for(i = 0; i < 10; i++) { mLayers_Radio[i] = gtk_check_menu_item_new_with_label(Layers_Menu[i]); g_signal_connect(G_OBJECT(mLayers_Radio[i]), "activate", G_CALLBACK(Modify_Layer), (void*)Layers_Menu[i]); gtk_menu_shell_append(GTK_MENU_SHELL(mLayers), mLayers_Radio[i]); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mLayers_Radio[i]), TRUE); } /** Menu "Options" **/ GtkWidget *mConfig = gtk_menu_new(); pMenuItem = gtk_menu_item_new_with_label("Config"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mConfig); gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem); pMenuItem = gtk_menu_item_new_with_label("Edit controls"); g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(Edit_Controls), (GtkWidget*) pWindow); gtk_menu_shell_append(GTK_MENU_SHELL(mConfig), pMenuItem); #if 0 GtkWidget *mFirmware; mFirmware = gtk_menu_new(); pMenuItem = gtk_menu_item_new_with_label("Firmware"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mFirmware); gtk_menu_shell_append(GTK_MENU_SHELL(mConfig), pMenuItem); pMenuItem = gtk_menu_item_new_with_label("Select..."); g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(SelectFirmwareFile), (gpointer)0); gtk_menu_shell_append(GTK_MENU_SHELL(mFirmware), pMenuItem); pMenuItem = gtk_menu_item_new_with_label("Config"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mConfig); gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem); #endif /** Menu "Outils" **/ pMenu = gtk_menu_new(); for(i = 0; i < dTools_list_size; i++) { pMenuItem = gtk_menu_item_new_with_label(dTools_list[i]->name); g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(Start_dTool), GINT_TO_POINTER(i)); gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem); } pMenuItem = gtk_menu_item_new_with_label("Tools"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), pMenu); gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem); /** Menu "?" **/ pMenu = gtk_menu_new(); #if ((GTK_MAJOR_VERSION >= 2) && (GTK_MINOR_VERSION >= 6)) pMenuItem = gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT,NULL); #else pMenuItem = gtk_menu_item_new_with_label("About"); #endif g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(About), (GtkWidget*) pWindow); gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem); pMenuItem = gtk_menu_item_new_with_label("?"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), pMenu); gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem); /* Ajout du menu a la fenetre */ gtk_box_pack_start(GTK_BOX(pVBox), pMenuBar, FALSE, FALSE, 0); /* Création de la Toolbar */ pToolbar = gtk_toolbar_new(); gtk_box_pack_start(GTK_BOX(pVBox), pToolbar, FALSE, FALSE, 0); gtk_toolbar_insert(GTK_TOOLBAR(pToolbar), GTK_TOOL_ITEM(gtk_action_create_tool_item(gtk_action_group_get_action(action_group, "open"))), -1); gtk_toolbar_insert(GTK_TOOLBAR(pToolbar), GTK_TOOL_ITEM(gtk_action_create_tool_item(gtk_action_group_get_action(action_group, "run"))), -1); gtk_toolbar_insert(GTK_TOOLBAR(pToolbar), GTK_TOOL_ITEM(gtk_action_create_tool_item(gtk_action_group_get_action(action_group, "pause"))), -1); gtk_toolbar_insert(GTK_TOOLBAR(pToolbar), GTK_TOOL_ITEM(gtk_action_create_tool_item(gtk_action_group_get_action(action_group, "quit"))), -1); /* Création de l'endroit pour l'affichage des écrans */ pDrawingArea= gtk_drawing_area_new(); gtk_drawing_area_size(GTK_DRAWING_AREA(pDrawingArea), 256, 384); gtk_widget_set_usize (pDrawingArea, 256, 384); gtk_widget_set_events(pDrawingArea, GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_KEY_PRESS_MASK ); g_signal_connect(G_OBJECT(pDrawingArea), "button_press_event", G_CALLBACK(Stylus_Press), NULL); g_signal_connect(G_OBJECT(pDrawingArea), "button_release_event", G_CALLBACK(Stylus_Release), NULL); g_signal_connect(G_OBJECT(pDrawingArea), "motion_notify_event", G_CALLBACK(Stylus_Move), NULL); g_signal_connect( G_OBJECT(pDrawingArea), "realize", G_CALLBACK(Draw), NULL ) ; g_signal_connect( G_OBJECT(pDrawingArea), "expose_event", G_CALLBACK(gtkFloatExposeEvent), NULL ) ; gtk_box_pack_start(GTK_BOX(pVBox), pDrawingArea, FALSE, FALSE, 0); /* Création de la barre d'état */ pStatusBar = gtk_statusbar_new(); pStatusBar_Ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(pStatusBar), "Global"); pStatusBar_Change("Desmume"); gtk_box_pack_end(GTK_BOX(pVBox), pStatusBar, FALSE, FALSE, 0); gtk_widget_show_all(pWindow); //LoadFirmware("fw.bin"); /* Vérifie la ligne de commandes */ if(commandLine_File) { if(Open(commandLine_File) >= 0) { Launch(); } else { GtkWidget *pDialog = gtk_message_dialog_new(GTK_WINDOW(pWindow), GTK_DIALOG_MODAL, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, "Unable to load :\n%s", commandLine_File); gtk_dialog_run(GTK_DIALOG(pDialog)); gtk_widget_destroy(pDialog); } } /* Boucle principale */ // gtk_idle_add(&EmuLoop, pWindow); // g_idle_add(&EmuLoop, pWindow); gtk_main(); desmume_free(); #ifdef DEBUG LogStop(); #endif SDL_Quit(); Write_ConfigFile(); return EXIT_SUCCESS; }
static GtkWidget * create_send_receive_submenu (EMailShellView *mail_shell_view) { EShellView *shell_view; EShellWindow *shell_window; EShellBackend *shell_backend; EMailAccountStore *account_store; EMailBackend *backend; EMailSession *session; GtkWidget *menu; GtkAccelGroup *accel_group; GtkUIManager *ui_manager; GtkAction *action; GtkTreeModel *model; GtkTreeIter iter; SendReceiveData *data; g_return_val_if_fail (mail_shell_view != NULL, NULL); shell_view = E_SHELL_VIEW (mail_shell_view); shell_window = e_shell_view_get_shell_window (shell_view); shell_backend = e_shell_view_get_shell_backend (shell_view); backend = E_MAIL_BACKEND (shell_backend); session = e_mail_backend_get_session (backend); account_store = e_mail_ui_session_get_account_store (E_MAIL_UI_SESSION (session)); menu = gtk_menu_new (); ui_manager = e_shell_window_get_ui_manager (shell_window); accel_group = gtk_ui_manager_get_accel_group (ui_manager); action = e_shell_window_get_action (shell_window, "mail-send-receive"); gtk_action_set_accel_group (action, accel_group); gtk_menu_shell_append ( GTK_MENU_SHELL (menu), gtk_action_create_menu_item (action)); action = e_shell_window_get_action ( shell_window, "mail-send-receive-receive-all"); gtk_action_set_accel_group (action, accel_group); gtk_menu_shell_append ( GTK_MENU_SHELL (menu), gtk_action_create_menu_item (action)); action = e_shell_window_get_action ( shell_window, "mail-send-receive-send-all"); gtk_action_set_accel_group (action, accel_group); gtk_menu_shell_append ( GTK_MENU_SHELL (menu), gtk_action_create_menu_item (action)); gtk_menu_shell_append ( GTK_MENU_SHELL (menu), gtk_separator_menu_item_new ()); data = send_receive_data_new (mail_shell_view, menu); model = GTK_TREE_MODEL (account_store); if (gtk_tree_model_get_iter_first (model, &iter)) { CamelService *service; do { service = NULL; gtk_tree_model_get ( model, &iter, E_MAIL_ACCOUNT_STORE_COLUMN_SERVICE, &service, -1); if (send_receive_can_use_service (account_store, service, &iter)) send_receive_add_to_menu (data, service, -1); if (service) g_object_unref (service); } while (gtk_tree_model_iter_next (model, &iter)); } gtk_widget_show_all (menu); return menu; }
int main ( int argc, char **argv ) { int k; GtkWidget *window, *child, *box, *menu, *subMenu; GtkAction *action[2]; GtkUIManager *manager; gtk_init ( &argc, &argv ); window = gtk_window_new ( GTK_WINDOW_TOPLEVEL ); box = gtk_vbox_new ( 0, 0 ); gtk_container_add ( GTK_CONTAINER ( window ), box ); /* menuBar = gtk_menu_bar_new(); gtk_container_add( GTK_CONTAINER( box ), menuBar ); menu = gtk_menu_item_new_with_label( "Menu" ); gtk_container_add( GTK_CONTAINER( menuBar ), menu ); subMenu = gtk_menu_new(); gtk_menu_item_set_submenu( menu, subMenu ); */ { /* actionGroup name -entries ... -toggleEntries ... -radioEntries $name addEntries $name addToggleEntries $name addRadioEntries */ GtkActionGroup *action_group = gtk_action_group_new ( "MenuActions" ); gtk_action_group_add_actions ( action_group, entries, G_N_ELEMENTS ( entries ), window ); gtk_action_group_add_toggle_actions ( action_group, toggle_entries, G_N_ELEMENTS ( toggle_entries ), window ); gtk_action_group_add_radio_actions ( action_group, radio_entries, G_N_ELEMENTS ( radio_entries ), 0, func1, window ); /* uiManager addUI ui_description -groups $name $manager addGroup */ manager = gtk_ui_manager_new (); gtk_ui_manager_insert_action_group ( manager , action_group, 0 ); } { /* $manager setAccelWindow window */ GtkAccelGroup *accel_group = gtk_ui_manager_get_accel_group ( manager ); gtk_window_add_accel_group ( GTK_WINDOW ( window ), accel_group ); } { /* $manager setUiDescription xxx */ GError *error = NULL; if ( !gtk_ui_manager_add_ui_from_string ( manager, ui_description, -1, &error ) ) { g_message ( "building menus failed: %s", error->message ); g_error_free ( error ); exit ( 1 ); } } { /* $manager getWidget name */ GtkWidget *menuBar = gtk_ui_manager_get_widget ( manager, "/MainMenu" ); gtk_box_pack_start ( GTK_BOX ( box ), menuBar, FALSE, FALSE, 0 ); } gtk_widget_show_all ( window ); /* action[0] = GTK_ACTION( gtk_action_new( "name", "label", "tooltip", NULL ) ); action[1] = GTK_ACTION( gtk_action_new( "name2", "label2", "tooltip2", "gtk-quit" ) ); g_signal_connect( action[0], "activate", G_CALLBACK( func1 ), NULL); g_signal_connect( action[1], "activate", G_CALLBACK( func2 ), NULL); */ /* accelGroup = gtk_accel_group_new(); */ #if 0 group = gtk_action_group_new ( "global" ); gtk_action_group_add_actions ( group, entries, 1, window ); manager = gtk_ui_manager_new (); gtk_ui_manager_insert_action_group ( manager, group, 0 ); accelGroup = gtk_ui_manager_get_accel_group ( manager ); gtk_window_add_accel_group ( GTK_WINDOW ( window ), accelGroup ); for ( k = 0; k < 2; ++k ) { child = gtk_action_create_menu_item ( action[k] ); gtk_container_add ( GTK_CONTAINER ( subMenu ), child ); child = gtk_action_create_tool_item ( action[k] ); gtk_container_add ( GTK_CONTAINER ( box ), child ); } gtk_action_group_add_action_with_accel ( group, action[0], "<control>w" ); gtk_action_group_add_action_with_accel ( group, action[1], NULL ); #endif gtk_widget_show_all ( window ); gtk_main(); return 0; }
static VALUE rg_create_menu_item(VALUE self) { return GOBJ2RVAL(gtk_action_create_menu_item(_SELF(self))); }
/** * thunar_dnd_ask: * @widget : the widget on which the drop was performed. * @folder : the #ThunarFile to which the @path_list is being dropped. * @path_list : the #GFile<!---->s of the files being dropped to @file. * @timestamp : the time of the drop event. * @actions : the list of actions supported for the drop. * * Pops up a menu that asks the user to choose one of the * @actions or to cancel the drop. If the user chooses a * valid #GdkDragAction from @actions, then this action is * returned. Else if the user cancels the drop, 0 will be * returned. * * This method can be used to implement a response to the * #GDK_ACTION_ASK action on drops. * * Return value: the selected #GdkDragAction or 0 to cancel. **/ GdkDragAction thunar_dnd_ask (GtkWidget *widget, ThunarFile *folder, GList *path_list, guint timestamp, GdkDragAction dnd_actions) { static const GdkDragAction dnd_action_items[] = { GDK_ACTION_COPY, GDK_ACTION_MOVE, GDK_ACTION_LINK }; static const gchar *dnd_action_names[] = { N_ ("_Copy here"), N_ ("_Move here"), N_ ("_Link here") }; static const gchar *dnd_action_icons[] = { "stock_folder-copy", "stock_folder-move", NULL }; ThunarxProviderFactory *factory; GdkDragAction dnd_action = 0; ThunarFile *file; GtkWidget *window; GtkWidget *image; GtkWidget *menu; GtkWidget *item; GList *file_list = NULL; GList *providers = NULL; GList *actions = NULL; GList *lp; guint n; _thunar_return_val_if_fail (thunar_file_is_directory (folder), 0); _thunar_return_val_if_fail (GTK_IS_WIDGET (widget), 0); /* connect to the provider factory */ factory = thunarx_provider_factory_get_default (); /* prepare the popup menu */ menu = gtk_menu_new (); /* append the various items */ for (n = 0; n < G_N_ELEMENTS (dnd_action_items); ++n) if (G_LIKELY ((dnd_actions & dnd_action_items[n]) != 0)) { item = gtk_image_menu_item_new_with_mnemonic (_(dnd_action_names[n])); g_object_set_data (G_OBJECT (item), I_("dnd-action"), GUINT_TO_POINTER (dnd_action_items[n])); g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (dnd_action_selected), &dnd_action); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); gtk_widget_show (item); /* add image to the menu item */ if (G_LIKELY (dnd_action_icons[n] != NULL)) { image = gtk_image_new_from_icon_name (dnd_action_icons[n], GTK_ICON_SIZE_MENU); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image); } } /* append the separator */ item = gtk_separator_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); gtk_widget_show (item); /* determine the toplevel window the widget belongs to */ window = gtk_widget_get_toplevel (widget); if (G_LIKELY (window != NULL && gtk_widget_get_toplevel (window))) { /* check if we can resolve all paths */ for (lp = path_list; lp != NULL; lp = lp->next) { /* try to resolve this path */ file = thunar_file_cache_lookup (lp->data); if (G_LIKELY (file != NULL)) file_list = g_list_prepend (file_list, file); else break; } /* check if we resolved all paths (and have atleast one file) */ if (G_LIKELY (file_list != NULL && lp == NULL)) { /* load the menu providers from the provider factory */ providers = thunarx_provider_factory_list_providers (factory, THUNARX_TYPE_MENU_PROVIDER); /* load the dnd actions offered by the menu providers */ for (lp = providers; lp != NULL; lp = lp->next) { /* merge the actions from this provider */ actions = g_list_concat (actions, thunarx_menu_provider_get_dnd_actions (lp->data, window, THUNARX_FILE_INFO (folder), file_list)); g_object_unref (G_OBJECT (lp->data)); } g_list_free (providers); /* check if we have atleast one action */ if (G_UNLIKELY (actions != NULL)) { /* add menu items for all actions */ for (lp = actions; lp != NULL; lp = lp->next) { /* add a menu item for the action */ item = gtk_action_create_menu_item (lp->data); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); g_object_unref (G_OBJECT (lp->data)); gtk_widget_show (item); } g_list_free (actions); /* append another separator */ item = gtk_separator_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); gtk_widget_show (item); } } } /* append the cancel item */ item = gtk_image_menu_item_new_from_stock (GTK_STOCK_CANCEL, NULL); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); gtk_widget_show (item); /* run the menu on the widget's screen (takes over the floating reference of menu) */ thunar_gtk_menu_run (GTK_MENU (menu), widget, NULL, NULL, 3, timestamp); /* cleanup */ g_object_unref (G_OBJECT (factory)); g_list_free_full (file_list, g_object_unref); return dnd_action; }