static void gui_restore_after_callback (Gimp *gimp, GimpInitStatusFunc status_callback) { GimpGuiConfig *gui_config = GIMP_GUI_CONFIG (gimp->config); GimpDisplay *display; if (gimp->be_verbose) g_print ("INIT: %s\n", G_STRFUNC); gimp->message_handler = GIMP_MESSAGE_BOX; if (gui_config->restore_accels) menus_restore (gimp); ui_configurer = g_object_new (GIMP_TYPE_UI_CONFIGURER, "gimp", gimp, NULL); image_ui_manager = gimp_menu_factory_manager_new (global_menu_factory, "<Image>", gimp, gui_config->tearoff_menus); gimp_ui_manager_update (image_ui_manager, gimp); #ifdef GDK_WINDOWING_QUARTZ { GtkosxApplication *osx_app; GtkWidget *menu; GtkWidget *item; osx_app = gtkosx_application_get (); menu = gtk_ui_manager_get_widget (GTK_UI_MANAGER (image_ui_manager), "/image-menubar"); if (GTK_IS_MENU_ITEM (menu)) menu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (menu)); gtkosx_application_set_menu_bar (osx_app, GTK_MENU_SHELL (menu)); gtkosx_application_set_use_quartz_accelerators (osx_app, FALSE); gui_add_to_app_menu (image_ui_manager, osx_app, "/image-menubar/Help/dialogs-about", 0); #define PREFERENCES "/image-menubar/Edit/Preferences/" gui_add_to_app_menu (image_ui_manager, osx_app, PREFERENCES "dialogs-preferences", 2); gui_add_to_app_menu (image_ui_manager, osx_app, PREFERENCES "dialogs-input-devices", 3); gui_add_to_app_menu (image_ui_manager, osx_app, PREFERENCES "dialogs-keyboard-shortcuts", 4); gui_add_to_app_menu (image_ui_manager, osx_app, PREFERENCES "dialogs-module-dialog", 5); gui_add_to_app_menu (image_ui_manager, osx_app, PREFERENCES "plug-in-unit-editor", 6); #undef PREFERENCES item = gtk_separator_menu_item_new (); gtkosx_application_insert_app_menu_item (osx_app, item, 7); item = gtk_ui_manager_get_widget (GTK_UI_MANAGER (image_ui_manager), "/image-menubar/File/file-quit"); gtk_widget_hide (item); g_signal_connect (osx_app, "NSApplicationBlockTermination", G_CALLBACK (gui_quartz_quit_callback), image_ui_manager); gtkosx_application_ready (osx_app); } #endif /* GDK_WINDOWING_QUARTZ */ g_signal_connect_object (gui_config, "notify::single-window-mode", G_CALLBACK (gui_single_window_mode_notify), ui_configurer, 0); g_signal_connect_object (gui_config, "notify::tearoff-menus", G_CALLBACK (gui_tearoff_menus_notify), image_ui_manager, 0); g_signal_connect (image_ui_manager, "show-tooltip", G_CALLBACK (gui_menu_show_tooltip), gimp); g_signal_connect (image_ui_manager, "hide-tooltip", G_CALLBACK (gui_menu_hide_tooltip), gimp); gimp_devices_restore (gimp); gimp_controllers_restore (gimp, image_ui_manager); if (status_callback == splash_update) splash_destroy (); color_history_restore (gimp); if (gimp_get_show_gui (gimp)) { GimpDisplayShell *shell; /* create the empty display */ display = GIMP_DISPLAY (gimp_create_display (gimp, NULL, GIMP_UNIT_PIXEL, 1.0)); shell = gimp_display_get_shell (display); if (gui_config->restore_session) session_restore (gimp); /* move keyboard focus to the display */ gtk_window_present (GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (shell)))); } /* indicate that the application has finished loading */ gdk_notify_startup_complete (); }
gint main (gint argc, gchar **argv) { GtkWidget *window, *toolbar, *grid, *treeview, *scrolled_window; GtkWidget *hbox, *hbox1, *hbox2, *checkbox, *option_menu, *menu; gint i; static const gchar *toolbar_styles[] = { "icons", "text", "both (vertical)", "both (horizontal)" }; GtkToolItem *item; GtkListStore *store; GtkWidget *image; GtkWidget *menuitem; GtkWidget *button; GtkWidget *label; GIcon *gicon; GSList *group; gtk_init (&argc, &argv); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_signal_connect (window, "destroy", G_CALLBACK(gtk_main_quit), NULL); grid = gtk_grid_new (); gtk_container_add (GTK_CONTAINER (window), grid); toolbar = gtk_toolbar_new (); gtk_widget_set_vexpand (toolbar, TRUE); gtk_grid_attach (GTK_GRID (grid), toolbar, 0, 0, 2, 1); hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3); gtk_container_set_border_width (GTK_CONTAINER (hbox1), 5); gtk_widget_set_vexpand (hbox1, TRUE); gtk_grid_attach (GTK_GRID (grid), hbox1, 1, 1, 1, 1); hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); gtk_container_set_border_width (GTK_CONTAINER (hbox2), 5); gtk_widget_set_vexpand (hbox2, TRUE); gtk_grid_attach (GTK_GRID (grid), hbox2, 1, 2, 1, 1); checkbox = gtk_check_button_new_with_mnemonic("_Vertical"); gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0); g_signal_connect (checkbox, "toggled", G_CALLBACK (change_orientation), toolbar); checkbox = gtk_check_button_new_with_mnemonic("_Show Arrow"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), TRUE); gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0); g_signal_connect (checkbox, "toggled", G_CALLBACK (change_show_arrow), toolbar); checkbox = gtk_check_button_new_with_mnemonic("_Set Toolbar Style:"); g_signal_connect (checkbox, "toggled", G_CALLBACK (set_toolbar_style_toggled), toolbar); gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0); option_menu = gtk_combo_box_text_new (); gtk_widget_set_sensitive (option_menu, FALSE); g_object_set_data (G_OBJECT (checkbox), "option-menu", option_menu); for (i = 0; i < G_N_ELEMENTS (toolbar_styles); i++) gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (option_menu), toolbar_styles[i]); gtk_combo_box_set_active (GTK_COMBO_BOX (option_menu), gtk_toolbar_get_style (GTK_TOOLBAR (toolbar))); gtk_box_pack_start (GTK_BOX (hbox2), option_menu, FALSE, FALSE, 0); g_signal_connect (option_menu, "changed", G_CALLBACK (change_toolbar_style), toolbar); checkbox = gtk_check_button_new_with_mnemonic("_Set Icon Size:"); g_signal_connect (checkbox, "toggled", G_CALLBACK (set_icon_size_toggled), toolbar); gtk_box_pack_start (GTK_BOX (hbox2), checkbox, FALSE, FALSE, 0); option_menu = gtk_combo_box_text_new (); g_object_set_data (G_OBJECT (checkbox), "option-menu", option_menu); gtk_widget_set_sensitive (option_menu, FALSE); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (option_menu), "small toolbar"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (option_menu), "large toolbar"); gtk_box_pack_start (GTK_BOX (hbox2), option_menu, FALSE, FALSE, 0); g_signal_connect (option_menu, "changed", G_CALLBACK (icon_size_history_changed), toolbar); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_hexpand (scrolled_window, TRUE); gtk_widget_set_vexpand (scrolled_window, TRUE); gtk_grid_attach (GTK_GRID (grid), scrolled_window, 1, 3, 1, 1); store = create_items_list (&treeview); gtk_container_add (GTK_CONTAINER (scrolled_window), treeview); item = gtk_tool_button_new (NULL, NULL); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "document-new"); gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Custom label"); add_item_to_list (store, item, "New"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); gdk_threads_add_timeout (3000, (GSourceFunc) timeout_cb, item); gtk_tool_item_set_expand (item, TRUE); menu = gtk_menu_new (); for (i = 0; i < 20; i++) { char *text; text = g_strdup_printf ("Menuitem %d", i); menuitem = gtk_menu_item_new_with_label (text); g_free (text); gtk_widget_show (menuitem); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); } item = gtk_menu_tool_button_new (NULL, NULL); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "document-open"); gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Open"); gtk_menu_tool_button_set_menu (GTK_MENU_TOOL_BUTTON (item), menu); add_item_to_list (store, item, "Open"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); gdk_threads_add_timeout (3000, (GSourceFunc) timeout_cb1, item); menu = gtk_menu_new (); for (i = 0; i < 20; i++) { char *text; text = g_strdup_printf ("A%d", i); menuitem = gtk_menu_item_new_with_label (text); g_free (text); gtk_widget_show (menuitem); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); } item = gtk_menu_tool_button_new (NULL, NULL); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "go-previous"); gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Back"); gtk_menu_tool_button_set_menu (GTK_MENU_TOOL_BUTTON (item), menu); add_item_to_list (store, item, "BackWithHistory"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_separator_tool_item_new (); add_item_to_list (store, item, "-----"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); image = gtk_image_new_from_icon_name ("dialog-warning", GTK_ICON_SIZE_DIALOG); item = gtk_tool_item_new (); gtk_widget_show (image); gtk_container_add (GTK_CONTAINER (item), image); add_item_to_list (store, item, "(Custom Item)"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_tool_button_new (NULL, NULL); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "go-previous"); gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Back"); add_item_to_list (store, item, "Back"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_separator_tool_item_new (); add_item_to_list (store, item, "-----"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_tool_button_new (NULL, NULL); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "go-next"); gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Forward"); add_item_to_list (store, item, "Forward"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_toggle_tool_button_new (); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-text-bold"); g_signal_connect (item, "toggled", G_CALLBACK (bold_toggled), NULL); add_item_to_list (store, item, "Bold"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); gtk_widget_set_sensitive (GTK_WIDGET (item), FALSE); item = gtk_separator_tool_item_new (); add_item_to_list (store, item, "-----"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); gtk_tool_item_set_expand (item, TRUE); gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM (item), FALSE); g_assert (gtk_toolbar_get_nth_item (GTK_TOOLBAR (toolbar), 0) != 0); item = gtk_radio_tool_button_new (NULL); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-justify-left"); group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (item)); add_item_to_list (store, item, "Left"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_radio_tool_button_new (group); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-justify-center"); make_prop_editor (G_OBJECT (item)); group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (item)); add_item_to_list (store, item, "Center"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_radio_tool_button_new (group); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-justify-right"); add_item_to_list (store, item, "Right"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_tool_button_new (gtk_image_new_from_file ("apple-red.png"), "_Apple"); add_item_to_list (store, item, "Apple"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); gtk_tool_button_set_use_underline (GTK_TOOL_BUTTON (item), TRUE); gicon = g_content_type_get_icon ("video/ogg"); image = gtk_image_new_from_gicon (gicon, GTK_ICON_SIZE_LARGE_TOOLBAR); g_object_unref (gicon); item = gtk_tool_button_new (image, "Video"); add_item_to_list (store, item, "Video"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); image = gtk_image_new_from_icon_name ("utilities-terminal", GTK_ICON_SIZE_LARGE_TOOLBAR); item = gtk_tool_button_new (image, "Terminal"); add_item_to_list (store, item, "Terminal"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); image = gtk_spinner_new (); gtk_spinner_start (GTK_SPINNER (image)); item = gtk_tool_button_new (image, "Spinner"); add_item_to_list (store, item, "Spinner"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5); gtk_container_set_border_width (GTK_CONTAINER (hbox), 5); gtk_widget_set_hexpand (hbox, TRUE); gtk_grid_attach (GTK_GRID (grid), hbox, 1, 4, 1, 1); button = gtk_button_new_with_label ("Drag me to the toolbar"); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); label = gtk_label_new ("Drop index:"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); label = gtk_label_new (""); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); checkbox = gtk_check_button_new_with_mnemonic("_Right to left"); if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), TRUE); else gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), FALSE); g_signal_connect (checkbox, "toggled", G_CALLBACK (rtl_toggled), NULL); gtk_box_pack_end (GTK_BOX (hbox), checkbox, FALSE, FALSE, 0); gtk_drag_source_set (button, GDK_BUTTON1_MASK, target_table, G_N_ELEMENTS (target_table), GDK_ACTION_MOVE); gtk_drag_dest_set (toolbar, GTK_DEST_DEFAULT_DROP, target_table, G_N_ELEMENTS (target_table), GDK_ACTION_MOVE); g_signal_connect (toolbar, "drag_motion", G_CALLBACK (toolbar_drag_motion), NULL); g_signal_connect (toolbar, "drag_leave", G_CALLBACK (toolbar_drag_leave), NULL); g_signal_connect (toolbar, "drag_drop", G_CALLBACK (toolbar_drag_drop), label); gtk_widget_show_all (window); make_prop_editor (G_OBJECT (toolbar)); g_signal_connect (window, "delete_event", G_CALLBACK (gtk_main_quit), NULL); g_signal_connect (toolbar, "popup_context_menu", G_CALLBACK (popup_context_menu), NULL); gtk_main (); return 0; }
static void store_populate_menu_items (GtkListStore *store, GtkMenuShell *menu, const gchar *parent_path) { GList *children; GList *node; children = gtk_container_get_children (GTK_CONTAINER (menu)); for (node = children; node; node = node->next) { if (GTK_IS_SEPARATOR_MENU_ITEM (node->data) || ! gtk_widget_get_visible (node->data)) { /* skip that */ } else if (GTK_IS_MENU_ITEM (node->data)) { GtkWidget *submenu; gchar *path; gchar *item_label; gboolean use_underline; GtkStockItem item; if (GTK_IS_IMAGE_MENU_ITEM (node->data) && gtk_image_menu_item_get_use_stock (node->data) && gtk_stock_lookup (gtk_menu_item_get_label (node->data), &item)) { item_label = g_strdup (item.label); use_underline = TRUE; } else { item_label = g_strdup (gtk_menu_item_get_label (node->data)); use_underline = gtk_menu_item_get_use_underline (node->data); } /* remove underlines */ if (use_underline) { gchar *p = item_label; gsize len = strlen (p); while ((p = strchr (p, '_')) != NULL) { len -= (gsize) (p - item_label); memmove (p, p + 1, len); } } if (parent_path) { path = g_strconcat (parent_path, PATH_SEPARATOR, item_label, NULL); } else { path = g_strdup (item_label); } submenu = gtk_menu_item_get_submenu (node->data); if (submenu) { /* go deeper in the menus... */ store_populate_menu_items (store, GTK_MENU_SHELL (submenu), path); } else { gchar *tmp; gchar *tooltip; gchar *label = g_markup_printf_escaped ("<big>%s</big>", item_label); tooltip = gtk_widget_get_tooltip_markup (node->data); if (tooltip) { SETPTR (label, g_strconcat (label, "\n<small>", tooltip, "</small>", NULL)); g_free (tooltip); } tmp = g_markup_escape_text (path, -1); SETPTR (label, g_strconcat (label, "\n<small><i>", tmp, "</i></small>", NULL)); g_free (tmp); gtk_list_store_insert_with_values (store, NULL, -1, COL_LABEL, label, COL_PATH, path, COL_TYPE, COL_TYPE_MENU_ITEM, COL_WIDGET, node->data, -1); g_free (label); } g_free (item_label); g_free (path); } else { g_warning ("Unknown widget type in the menu: %s", G_OBJECT_TYPE_NAME (node->data)); } } g_list_free (children); }
bool C4EditCursor::DoContextMenu(DWORD dwKeyState) { bool fObjectSelected = !!Selection.ObjectCount(); #ifdef USE_WIN32_WINDOWS POINT point; GetCursorPos(&point); HMENU hContext = GetSubMenu(hMenu,0); SetMenuItemEnable( hContext, IDM_VIEWPORT_DELETE, fObjectSelected && Console.Editing); SetMenuItemEnable( hContext, IDM_VIEWPORT_DUPLICATE, fObjectSelected && Console.Editing); SetMenuItemEnable( hContext, IDM_VIEWPORT_CONTENTS, fObjectSelected && Selection.GetObject()->Contents.ObjectCount() && Console.Editing); SetMenuItemText(hContext,IDM_VIEWPORT_DELETE,LoadResStr("IDS_MNU_DELETE")); SetMenuItemText(hContext,IDM_VIEWPORT_DUPLICATE,LoadResStr("IDS_MNU_DUPLICATE")); SetMenuItemText(hContext,IDM_VIEWPORT_CONTENTS,LoadResStr("IDS_MNU_CONTENTS")); ObjselectDelItems(); C4FindObjectAtPoint pFO(X,Y); C4ValueArray * atcursor; atcursor = pFO.FindMany(::Objects, ::Objects.Sectors); // needs freeing (single object ptr) int itemcount = atcursor->GetSize(); if(itemcount > 0) { const int maxitems = 25; // Maximum displayed objects. if you raise it, also change note with IDM_VPORTDYN_FIRST in resource.h if(itemcount > maxitems) itemcount = maxitems+1; itemsObjselect.resize(itemcount+1); // +1 for a separator itemsObjselect[0].ItemId = IDM_VPORTDYN_FIRST; itemsObjselect[0].Object = NULL; AppendMenu(hContext, MF_SEPARATOR, IDM_VPORTDYN_FIRST, NULL); int i = 1; for(std::vector<ObjselItemDt>::iterator it = itemsObjselect.begin() + 1; it != itemsObjselect.end(); ++it, ++i) { C4Object * obj = (*atcursor)[i-1].getObj(); assert(obj); it->ItemId = IDM_VPORTDYN_FIRST+i; it->Object = obj; AppendMenu(hContext, MF_STRING, it->ItemId, FormatString("%s #%i (%i/%i)", obj->GetName(), obj->Number, obj->GetX(), obj->GetY()).GetWideChar()); } if(atcursor->GetSize() > maxitems) { AppendMenu(hContext, MF_GRAYED, IDM_VPORTDYN_FIRST+maxitems+1, L"..."); itemsObjselect[maxitems+1].ItemId = IDM_VPORTDYN_FIRST+maxitems+1; itemsObjselect[maxitems+1].Object = NULL; } } delete atcursor; int32_t iItem = TrackPopupMenu( hContext, TPM_LEFTALIGN | TPM_TOPALIGN | TPM_RETURNCMD | TPM_LEFTBUTTON | TPM_NONOTIFY, point.x,point.y, 0, Console.hWindow, NULL); switch (iItem) { case IDM_VIEWPORT_DELETE: Delete(); break; case IDM_VIEWPORT_DUPLICATE: Duplicate(); break; case IDM_VIEWPORT_CONTENTS: GrabContents(); break; case 0: break; default: for(std::vector<ObjselItemDt>::iterator it = itemsObjselect.begin() + 1; it != itemsObjselect.end(); ++it) if(it->ItemId == iItem) { DoContextObjsel(it->Object, (dwKeyState & MK_SHIFT) == 0); break; } break; } ObjselectDelItems(); #else #ifdef WITH_DEVELOPER_MODE gtk_widget_set_sensitive(itemDelete, fObjectSelected && Console.Editing); gtk_widget_set_sensitive(itemDuplicate, fObjectSelected && Console.Editing); gtk_widget_set_sensitive(itemGrabContents, fObjectSelected && Selection.GetObject()->Contents.ObjectCount() && Console.Editing); ObjselectDelItems(); C4FindObjectAtPoint pFO(X,Y); C4ValueArray * atcursor; atcursor = pFO.FindMany(::Objects, ::Objects.Sectors); // needs freeing int itemcount = atcursor->GetSize(); if(itemcount > 0) { itemsObjselect.resize(itemcount+1); // +1 for a separator itemsObjselect[0].MenuItem = gtk_separator_menu_item_new(); itemsObjselect[0].EditCursor = this; gtk_menu_shell_append(GTK_MENU_SHELL(menuContext), itemsObjselect[0].MenuItem); int i = 0; for(std::vector<ObjselItemDt>::iterator it = itemsObjselect.begin() + 1; it != itemsObjselect.end(); ++it, ++i) { it->EditCursor = this; C4Object * obj = (*atcursor)[i].getObj(); assert(obj); it->Object = obj; GtkWidget * wdg = gtk_menu_item_new_with_label(FormatString("%s #%i (%i/%i)", obj->GetName(), obj->Number, obj->GetX(), obj->GetY()).getData()); it->MenuItem = wdg; gtk_menu_shell_append(GTK_MENU_SHELL(menuContext), wdg); g_signal_connect(G_OBJECT(wdg), "activate", G_CALLBACK(OnObjselect), &*it); } } delete atcursor; gtk_widget_show_all(menuContext); gtk_menu_popup(GTK_MENU(menuContext), NULL, NULL, NULL, NULL, 3, 0); #endif #endif return true; }
static void create_menuitem (GtkWidget *menu, GMenuTreeEntry *entry, GMenuTreeDirectory *alias_directory) { GtkWidget *menuitem; menuitem = panel_image_menu_item_new2 (); if (alias_directory) panel_load_menu_image_deferred (menuitem, panel_menu_icon_get_size (), gmenu_tree_directory_get_icon (alias_directory), NULL, NULL); else panel_load_menu_image_deferred (menuitem, panel_menu_icon_get_size (), g_app_info_get_icon (G_APP_INFO (gmenu_tree_entry_get_app_info (entry))), NULL, NULL); setup_menuitem (menuitem, panel_menu_icon_get_size (), NULL, alias_directory ? gmenu_tree_directory_get_name (alias_directory) : g_app_info_get_display_name (G_APP_INFO (gmenu_tree_entry_get_app_info (entry)))); if (alias_directory && gmenu_tree_directory_get_comment (alias_directory)) panel_util_set_tooltip_text (menuitem, gmenu_tree_directory_get_comment (alias_directory)); else if (!alias_directory) { const char *description = g_app_info_get_description (G_APP_INFO (gmenu_tree_entry_get_app_info (entry))); if (!description) description = g_desktop_app_info_get_generic_name (gmenu_tree_entry_get_app_info (entry)); if (description) panel_util_set_tooltip_text (menuitem, description); } g_signal_connect_after (menuitem, "button_press_event", G_CALLBACK (menu_dummy_button_press_event), NULL); if (!panel_lockdown_get_panels_locked_down_s ()) { GIcon *icon; static GtkTargetEntry menu_item_targets[] = { { "text/uri-list", 0, 0 } }; gtk_drag_source_set (menuitem, GDK_BUTTON1_MASK | GDK_BUTTON2_MASK, menu_item_targets, 1, GDK_ACTION_COPY); icon = g_app_info_get_icon (G_APP_INFO (gmenu_tree_entry_get_app_info (entry))); if (icon != NULL) gtk_drag_source_set_icon_gicon (menuitem, icon); g_signal_connect (G_OBJECT (menuitem), "drag_begin", G_CALLBACK (drag_begin_menu_cb), NULL); g_signal_connect (menuitem, "drag_data_get", G_CALLBACK (drag_data_get_menu_cb), entry); g_signal_connect (menuitem, "drag_end", G_CALLBACK (drag_end_menu_cb), NULL); } gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); g_signal_connect (menuitem, "activate", G_CALLBACK (activate_app_def), entry); gtk_widget_show (menuitem); }
GtkWidget* usejournal_build_menu(const char *defaultjournal, const char *currentjournal, GSList *journals, gpointer doc) { GtkWidget *menu, *curmenu, *item, *label; GSList *group = NULL; GSList *l; char *journal; char *curmenuprefix = NULL; char prefix[30]; curmenu = menu = gtk_menu_new(); item = gtk_radio_menu_item_new_with_label(group, defaultjournal); group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item)); g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(activate_cb), doc); if (currentjournal == NULL) gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE); gtk_widget_show(item); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); for (l = journals; l != NULL; l = l->next) { journal = (char*)l->data; if (curmenuprefix) { /* try to match this item to the prefix. */ if (sharedprefix(curmenuprefix, journal)) { /* match. */ } else { curmenu = menu; curmenuprefix = NULL; } } if (!curmenuprefix && l->next) { /* try to see if this begins a new prefix. */ char *nextjournal = (char*)l->next->data; int ofs; ofs = sharedprefix(journal, nextjournal); if (ofs) { /* make a new submenu for these shared-prefix journals. */ memcpy(prefix, journal, ofs); prefix[ofs] = 0; item = gtk_menu_item_new(); label = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); gtk_label_set_markup(GTK_LABEL(label), prefix); gtk_container_add(GTK_CONTAINER(item), label); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); curmenu = gtk_menu_new(); curmenuprefix = prefix; gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), curmenu); gtk_widget_show_all(item); } } item = gtk_radio_menu_item_new_with_label(group, journal); if (currentjournal && strcmp(currentjournal, journal) == 0) gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE); g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(activate_cb), doc); gtk_widget_show(item); gtk_menu_shell_append(GTK_MENU_SHELL(curmenu), item); group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item)); } return menu; }
static void wireless_applet_properties_dialog (BonoboUIComponent *uic, WirelessApplet *applet) { static GtkWidget *global_property_box = NULL, *glade_property_box = NULL; GtkWidget *pct, *dialog, *device; g_return_if_fail (PANEL_IS_APPLET (PANEL_APPLET (applet))); if (applet->prefs != NULL) { gtk_widget_show (applet->prefs); gtk_window_present (GTK_WINDOW (applet->prefs)); return; } if (global_property_box == NULL) { xml = glade_xml_new (glade_file, NULL, NULL); glade_property_box = glade_xml_get_widget (xml,"dialog1"); } applet->prefs = glade_property_box; gtk_window_set_resizable (GTK_WINDOW (applet->prefs), FALSE); pct = glade_xml_get_widget (xml, "pct_check_button"); dialog = glade_xml_get_widget (xml, "dialog_check_button"); device = glade_xml_get_widget (xml, "device_menu"); /* Set the show-percent thingy */ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pct), applet->show_percent); g_signal_connect (GTK_OBJECT (pct), "toggled", GTK_SIGNAL_FUNC (wireless_applet_option_change), applet); gtk_object_set_data (GTK_OBJECT (applet->prefs), "show-percent-button", pct); /* Set the device menu */ gtk_option_menu_remove_menu (GTK_OPTION_MENU (device)); { GtkWidget *menu; GtkWidget *item; GList *d; int idx = 0, choice = 0; menu = gtk_menu_new (); for (d = applet->devices; d != NULL; d = g_list_next (d)) { item = gtk_menu_item_new_with_label ((char*)d->data); gtk_menu_shell_append (GTK_MENU_SHELL (menu),item); gtk_object_set_data_full (GTK_OBJECT (item), "device-selected", g_strdup (d->data), g_free); g_signal_connect (GTK_OBJECT (item), "activate", GTK_SIGNAL_FUNC (wireless_applet_option_change), applet); if ((applet->device != NULL) && (d->data != NULL) && strcmp (applet->device, d->data)==0) { choice = idx; } idx++; } if (applet->devices == NULL) { char *markup; GtkWidget *label; label = gtk_label_new (NULL); markup = g_strdup_printf ("<i>%s</i>", _("No Wireless Devices")); gtk_label_set_markup (GTK_LABEL (label), markup); g_free (markup); item = gtk_menu_item_new (); gtk_container_add (GTK_CONTAINER (item), label); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); } gtk_option_menu_set_menu (GTK_OPTION_MENU (device), menu); gtk_option_menu_set_history (GTK_OPTION_MENU (device), choice); } gtk_object_set_data (GTK_OBJECT (applet->prefs), "device-menu", device); g_signal_connect (GTK_OBJECT (applet->prefs), "response", G_CALLBACK (prefs_response_cb), NULL); g_signal_connect (GTK_OBJECT (applet->prefs), "destroy", GTK_SIGNAL_FUNC (gtk_widget_destroy), NULL); g_object_add_weak_pointer (G_OBJECT (applet->prefs), (void**)&(applet->prefs)); gtk_window_set_screen (GTK_WINDOW (applet->prefs), gtk_widget_get_screen (GTK_WIDGET (applet))); gtk_widget_show_all (applet->prefs); }
GtkWidget* XNavGtk::build_menu(GtkWidget* Parent, int MenuType, const char* MenuTitle, void* MenuUserData, void (*Callback)(GtkWidget*, gpointer), void* CallbackData, xmenu_sMenuItem* Items, int* idx) { GtkWidget *Menu, *W; int i; unsigned int Level; Menu = (GtkWidget*)g_object_new(GTK_TYPE_MENU, NULL); g_object_set_data((GObject*)Menu, "userdata", (gpointer)MenuUserData); Level = Items[*idx].Level; for (; Items[*idx].Level != 0 && Items[*idx].Level >= Level; (*idx)++) { switch (Items[*idx].Item) { case xmenu_eMenuItem_Ref: { if (MenuType == MENU_OPTION) { printf("You can't have submenus from option menu items."); return NULL; } i = *idx; GtkWidget* sub = gtk_menu_item_new_with_label( CoWowGtk::translate_utf8(Items[*idx].Name)); (*idx)++; W = build_menu(Menu, MENU_PULLDOWN, Lng::translate(Items[i].Name), MenuUserData, Callback, CallbackData, Items, idx); (*idx)--; gtk_menu_item_set_submenu(GTK_MENU_ITEM(sub), GTK_WIDGET(W)); gtk_menu_shell_append(GTK_MENU_SHELL(Menu), sub); gtk_widget_show(sub); break; } case xmenu_eMenuItem_Cascade: { if (MenuType == MENU_OPTION) { printf("You can't have submenus from option menu items."); return NULL; } // Check that the Cascade contains any pushbuttons int found = 0; unsigned int cascade_level = Items[*idx].Level; int cidx; for (cidx = *idx + 1; Items[cidx].Level != 0 && Items[cidx].Level > cascade_level; cidx++) { if (Items[cidx].Item == xmenu_eMenuItem_Ref || Items[cidx].Item == xmenu_eMenuItem_Button) { found = 1; break; } } if (found) { i = *idx; GtkWidget* sub = gtk_menu_item_new_with_label( CoWowGtk::translate_utf8(Items[*idx].Name)); (*idx)++; W = build_menu(Menu, MENU_PULLDOWN, Lng::translate(Items[i].Name), MenuUserData, Callback, CallbackData, Items, idx); (*idx)--; gtk_menu_item_set_submenu(GTK_MENU_ITEM(sub), GTK_WIDGET(W)); gtk_menu_shell_append(GTK_MENU_SHELL(Menu), sub); gtk_widget_show(sub); } else { *idx = cidx - 1; } break; } case xmenu_eMenuItem_Separator: // Separator W = gtk_separator_menu_item_new(); gtk_menu_shell_append(GTK_MENU_SHELL(Menu), W); gtk_widget_show(W); break; case xmenu_eMenuItem_Button: // Pushbutton W = gtk_menu_item_new_with_label( CoWowGtk::translate_utf8(Items[*idx].Name)); gtk_widget_set_sensitive(W, Items[*idx].Flags.f.Sensitive ? TRUE : FALSE); g_object_set_data((GObject*)W, "userdata", (gpointer)((long int)*idx)); if (Callback) g_signal_connect(W, "activate", G_CALLBACK(Callback), CallbackData); gtk_menu_shell_append(GTK_MENU_SHELL(Menu), W); gtk_widget_show(W); break; default:; } } return Menu; }
GtkWidget *create_pho_sel_area() { hbox_pho_sel = gtk_hbox_new (FALSE, 0); int i; for(i=0; i < bigphoN; i++) { bigpho[i].opt_menu = gtk_combo_box_new_text (); #if !GTK_CHECK_VERSION(2,4,0) GtkWidget *menu = gtk_menu_new (); #endif gtk_box_pack_start (GTK_BOX (hbox_pho_sel), bigpho[i].opt_menu, FALSE, FALSE, 0); int j; for(j=0; j < bigpho[i].phokeysN; j++) { char t[128]; char *phostr; if (is_gtab) { int tlen; u_int64_t key64; if (ph_key_sz == 4) { u_int32_t key32; cp_ph_key(bigpho[i].phokeys,j, &key32); key64 = key32; } else cp_ph_key(bigpho[i].phokeys,j, &key64); gtab_key2name(pinmd, key64, t, &tlen); // dbg("%d,%d] %s\n", i,j, t); phostr = t; } else { phokey_t k; cp_ph_key(bigpho[i].phokeys, j, &k); phostr = b_pinyin? phokey2pinyin(k):phokey_to_str(k); } #if GTK_CHECK_VERSION(2,4,0) gtk_combo_box_append_text (GTK_COMBO_BOX_TEXT (bigpho[i].opt_menu), phostr); #else GtkWidget *item = gtk_menu_item_new_with_label (phostr); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); #endif } #if GTK_CHECK_VERSION(2,4,0) gtk_combo_box_set_active (GTK_COMBO_BOX(bigpho[i].opt_menu), 0); #else gtk_option_menu_set_menu (GTK_OPTION_MENU (bigpho[i].opt_menu), menu); #endif } GtkWidget *button_ok = gtk_button_new_with_label("OK to add"); gtk_box_pack_start (GTK_BOX (hbox_pho_sel), button_ok, FALSE, FALSE, 20); g_signal_connect (G_OBJECT (button_ok), "clicked", G_CALLBACK (cb_button_ok), NULL); GtkWidget *button_cancel = gtk_button_new_from_stock (GTK_STOCK_CANCEL); gtk_box_pack_start (GTK_BOX (hbox_pho_sel), button_cancel, FALSE, FALSE, 20); g_signal_connect (G_OBJECT (button_cancel), "clicked", G_CALLBACK (cb_button_cancel), NULL); return hbox_pho_sel; }
GtkWidget * menu_new(GtkWindow * main_window, MapArea * map_area, Config * config) { Menu * menubar = g_object_new(GOSM_TYPE_MENU, NULL); menubar -> main_window = main_window; menubar -> map_area = map_area; menubar -> config = config; /******************************************************************************************** * the following part is autogenerated; to regenerate, type: * :r !./misc/menu_gen.py 2 misc/Menu.txt ********************************************************************************************/ GtkWidget *item_1 = gtk_menu_item_new_with_label("File"); GtkWidget *menu_1 = gtk_menu_new(); GtkWidget *item_1_1 = gtk_menu_item_new_with_label("Quit"); GtkWidget *item_2 = gtk_menu_item_new_with_label("View"); GtkWidget *menu_2 = gtk_menu_new(); GtkWidget *item_2_1 = gtk_check_menu_item_new_with_label("Fullscreen"); GtkWidget *item_2_2 = gtk_menu_item_new_with_label("Control"); GtkWidget *menu_2_2 = gtk_menu_new(); GtkWidget *item_2_2_1 = gtk_menu_item_new_with_label("Zoom In"); GtkWidget *item_2_2_2 = gtk_menu_item_new_with_label("Zoom Out"); GtkWidget *item_2_2_3 = gtk_menu_item_new_with_label("Move Up"); GtkWidget *item_2_2_4 = gtk_menu_item_new_with_label("Move Down"); GtkWidget *item_2_2_5 = gtk_menu_item_new_with_label("Move Left"); GtkWidget *item_2_2_6 = gtk_menu_item_new_with_label("Move Right"); GtkWidget *item_2_3 = gtk_menu_item_new_with_label("Tiles"); GtkWidget *menu_2_3 = gtk_menu_new(); GtkWidget *item_2_3_1 = gtk_radio_menu_item_new_with_label(NULL, "Mapnik"); GtkWidget *item_2_3_2 = gtk_radio_menu_item_new_with_label(gtk_radio_menu_item_get_group((GtkRadioMenuItem*)item_2_3_1), "Osmarender"); GtkWidget *item_2_3_3 = gtk_radio_menu_item_new_with_label(gtk_radio_menu_item_get_group((GtkRadioMenuItem*)item_2_3_1), "OpenAerial"); GtkWidget *item_2_3_4 = gtk_radio_menu_item_new_with_label(gtk_radio_menu_item_get_group((GtkRadioMenuItem*)item_2_3_1), "Google"); GtkWidget *item_2_3_5 = gtk_radio_menu_item_new_with_label(gtk_radio_menu_item_get_group((GtkRadioMenuItem*)item_2_3_1), "Yahoo"); GtkWidget *item_3 = gtk_menu_item_new_with_label("Selection"); GtkWidget *menu_3 = gtk_menu_new(); GtkWidget *item_3_1 = gtk_check_menu_item_new_with_label("Snap to Map"); GtkWidget *item_3_2 = gtk_check_menu_item_new_with_label("Hide"); GtkWidget *item_3_3 = gtk_menu_item_new_with_label("Export"); GtkWidget *item_3_4 = gtk_menu_item_new_with_label("Download"); GtkWidget *item_4 = gtk_menu_item_new_with_label("Options"); GtkWidget *menu_4 = gtk_menu_new(); GtkWidget *item_4_1 = gtk_menu_item_new_with_label("Preferences"); GtkWidget *item_5 = gtk_menu_item_new_with_label("Help"); GtkWidget *menu_5 = gtk_menu_new(); GtkWidget *item_5_1 = gtk_menu_item_new_with_label("Manual"); GtkWidget *item_5_2 = gtk_menu_item_new_with_label("About GOsmView"); GtkWidget *item_5_3 = gtk_menu_item_new_with_label("About OpenStreetMap"); GtkWidget *item_5_4 = gtk_menu_item_new_with_label("About Namefinder"); GtkWidget *item_5_5 = gtk_menu_item_new_with_label("License"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_1), menu_1); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_2), menu_2); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_2_2), menu_2_2); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_2_3), menu_2_3); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_3), menu_3); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_4), menu_4); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_5), menu_5); gtk_menu_shell_append(GTK_MENU_SHELL(menubar), item_1); gtk_menu_shell_append(GTK_MENU_SHELL(menu_1), item_1_1); gtk_menu_shell_append(GTK_MENU_SHELL(menubar), item_2); gtk_menu_shell_append(GTK_MENU_SHELL(menu_2), item_2_1); gtk_menu_shell_append(GTK_MENU_SHELL(menu_2), item_2_2); gtk_menu_shell_append(GTK_MENU_SHELL(menu_2_2), item_2_2_1); gtk_menu_shell_append(GTK_MENU_SHELL(menu_2_2), item_2_2_2); gtk_menu_shell_append(GTK_MENU_SHELL(menu_2_2), item_2_2_3); gtk_menu_shell_append(GTK_MENU_SHELL(menu_2_2), item_2_2_4); gtk_menu_shell_append(GTK_MENU_SHELL(menu_2_2), item_2_2_5); gtk_menu_shell_append(GTK_MENU_SHELL(menu_2_2), item_2_2_6); gtk_menu_shell_append(GTK_MENU_SHELL(menu_2), item_2_3); gtk_menu_shell_append(GTK_MENU_SHELL(menu_2_3), item_2_3_1); gtk_menu_shell_append(GTK_MENU_SHELL(menu_2_3), item_2_3_2); gtk_menu_shell_append(GTK_MENU_SHELL(menu_2_3), item_2_3_3); gtk_menu_shell_append(GTK_MENU_SHELL(menu_2_3), item_2_3_4); gtk_menu_shell_append(GTK_MENU_SHELL(menu_2_3), item_2_3_5); gtk_menu_shell_append(GTK_MENU_SHELL(menubar), item_3); gtk_menu_shell_append(GTK_MENU_SHELL(menu_3), item_3_1); gtk_menu_shell_append(GTK_MENU_SHELL(menu_3), item_3_2); gtk_menu_shell_append(GTK_MENU_SHELL(menu_3), item_3_3); gtk_menu_shell_append(GTK_MENU_SHELL(menu_3), item_3_4); gtk_menu_shell_append(GTK_MENU_SHELL(menubar), item_4); gtk_menu_shell_append(GTK_MENU_SHELL(menu_4), item_4_1); gtk_menu_shell_append(GTK_MENU_SHELL(menubar), item_5); gtk_menu_shell_append(GTK_MENU_SHELL(menu_5), item_5_1); gtk_menu_shell_append(GTK_MENU_SHELL(menu_5), item_5_2); gtk_menu_shell_append(GTK_MENU_SHELL(menu_5), item_5_3); gtk_menu_shell_append(GTK_MENU_SHELL(menu_5), item_5_4); gtk_menu_shell_append(GTK_MENU_SHELL(menu_5), item_5_5); menubar -> menu_file_quit = item_1_1; menubar -> menu_view_fullscreen = item_2_1; menubar -> menu_control_zoom_in = item_2_2_1; menubar -> menu_control_zoom_out = item_2_2_2; menubar -> menu_control_move_up = item_2_2_3; menubar -> menu_control_move_down = item_2_2_4; menubar -> menu_control_move_left = item_2_2_5; menubar -> menu_control_move_right = item_2_2_6; menubar -> menu_tiles_mapnik = item_2_3_1; menubar -> menu_tiles_osmarender = item_2_3_2; menubar -> menu_tiles_openaerial = item_2_3_3; menubar -> menu_tiles_google = item_2_3_4; menubar -> menu_tiles_yahoo = item_2_3_5; menubar -> menu_selection_snap = item_3_1; menubar -> menu_selection_show = item_3_2; menubar -> menu_selection_export = item_3_3; menubar -> menu_selection_download = item_3_4; menubar -> menu_options_preferences = item_4_1; menubar -> menu_help_manual = item_5_1; menubar -> menu_help_about_gosm = item_5_2; menubar -> menu_help_about_osm = item_5_3; menubar -> menu_help_about_nf = item_5_4; menubar -> menu_help_license = item_5_5; /******************************************************************************************** * end auto-generated part ********************************************************************************************/ gtk_widget_set_sensitive(menubar -> menu_tiles_osmarender, FALSE); gtk_widget_set_sensitive(menubar -> menu_tiles_openaerial, FALSE); gtk_widget_set_sensitive(menubar -> menu_tiles_google, FALSE); gtk_widget_set_sensitive(menubar -> menu_tiles_yahoo, FALSE); /******************************************************************************************** * signals ********************************************************************************************/ g_signal_connect( G_OBJECT(menubar -> menu_file_quit), "activate", G_CALLBACK(exit_cb), (gpointer)menubar); g_signal_connect( G_OBJECT(menubar -> menu_options_preferences), "activate", G_CALLBACK(show_preferences_cb), (gpointer)menubar); g_signal_connect( G_OBJECT(menubar -> menu_help_manual), "activate", G_CALLBACK(show_manual_cb), (gpointer)menubar); g_signal_connect( G_OBJECT(menubar -> menu_help_about_gosm), "activate", G_CALLBACK(show_about_gosm_cb), (gpointer)menubar); g_signal_connect( G_OBJECT(menubar -> menu_help_about_osm), "activate", G_CALLBACK(show_about_osm_cb), (gpointer)menubar); g_signal_connect( G_OBJECT(menubar -> menu_help_about_nf), "activate", G_CALLBACK(show_about_nf_cb), (gpointer)menubar); g_signal_connect( G_OBJECT(menubar -> menu_help_license), "activate", G_CALLBACK(show_about_license_cb), (gpointer)menubar); g_signal_connect( G_OBJECT(menubar -> menu_control_zoom_in), "activate", G_CALLBACK(button_zoom_in_cb), (gpointer)menubar); g_signal_connect( G_OBJECT(menubar -> menu_control_zoom_out), "activate", G_CALLBACK(button_zoom_out_cb), (gpointer)menubar); g_signal_connect( G_OBJECT(menubar -> menu_control_move_up), "activate", G_CALLBACK(button_move_up_cb), (gpointer)menubar); g_signal_connect( G_OBJECT(menubar -> menu_control_move_down), "activate", G_CALLBACK(button_move_down_cb), (gpointer)menubar); g_signal_connect( G_OBJECT(menubar -> menu_control_move_left), "activate", G_CALLBACK(button_move_left_cb), (gpointer)menubar); g_signal_connect( G_OBJECT(menubar -> menu_control_move_right), "activate", G_CALLBACK(button_move_right_cb), (gpointer)menubar); g_signal_connect( G_OBJECT(menubar -> menu_view_fullscreen), "toggled", G_CALLBACK(menubar_fullscreen_cb), (gpointer)menubar); /* notice when window is being fullscreened */ g_signal_connect( G_OBJECT(main_window), "window-state-event", G_CALLBACK(window_event_cb), (gpointer)menubar); return GTK_WIDGET(menubar); }
int main (int argc, char *argv[]) { GtkWidget *win = NULL; GtkWidget *textarea = NULL; GtkWidget *vbox; GtkWidget *menubar; GtkWidget *filemenu; GtkWidget *file; GtkWidget *quit; GtkWidget *help; GtkWidget *helpmenu; GtkWidget *author; GtkWidget *website; GtkWidget *open; GtkWidget *save; GtkWidget *save_as; GtkWidget *close; /* Initialize GTK+ */ g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING, (GLogFunc) gtk_false, NULL); gtk_init (&argc, &argv); g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING, g_log_default_handler, NULL); // Create a Window win = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_container_set_border_width (GTK_CONTAINER (win), 8); gtk_window_set_title (GTK_WINDOW (win), "Ringo Text Editor"); gtk_window_set_position (GTK_WINDOW (win), GTK_WIN_POS_CENTER); gtk_widget_realize (win); g_signal_connect (win, "destroy", gtk_main_quit, NULL); gtk_window_set_default_size(GTK_WINDOW(win),640,480); //create a text box vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(win), vbox); textarea = gtk_text_view_new (); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textarea),GTK_WRAP_WORD); gtk_box_pack_start (GTK_BOX (vbox), textarea, TRUE, TRUE, 0); menubar = gtk_menu_bar_new(); filemenu = gtk_menu_new(); helpmenu = gtk_menu_new(); file = gtk_menu_item_new_with_label("File"); open = gtk_menu_item_new_with_label("Open"); save = gtk_menu_item_new_with_label("Save"); close = gtk_menu_item_new_with_label("Close"); save_as = gtk_menu_item_new_with_label("Save as.."); quit = gtk_menu_item_new_with_label("Quit"); help = gtk_menu_item_new_with_label("Help"); author = gtk_menu_item_new_with_label("Authors"); website = gtk_menu_item_new_with_label("Official Web Site"); // Меню файлов gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), filemenu); gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), open); gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), close); gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), save); gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), save_as); gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), quit); gtk_menu_shell_append(GTK_MENU_SHELL(menubar), file); //Help Menu gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), helpmenu); gtk_menu_shell_append(GTK_MENU_SHELL(helpmenu), author); gtk_menu_shell_append(GTK_MENU_SHELL(helpmenu), website); gtk_menu_shell_append(GTK_MENU_SHELL(menubar), help); //Connect gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 3); g_signal_connect(G_OBJECT(quit), "activate", G_CALLBACK(gtk_main_quit), NULL); g_signal_connect(G_OBJECT(author), "activate", G_CALLBACK(authors_call), NULL); g_signal_connect(G_OBJECT(website), "activate", G_CALLBACK(open_web_site), NULL); g_signal_connect(G_OBJECT(open), "activate", G_CALLBACK(open_file),NULL); // Открытие файла передача в переменную if (opened == 1) { } //вроде конец gtk_widget_show_all (win); gtk_main (); return 0; }
/**************************************************************** Worklist editor shell. *****************************************************************/ GtkWidget *create_worklist(void) { GtkWidget *editor, *table, *sw, *bbox; GtkWidget *src_view, *dst_view, *label, *button; GtkWidget *menubar, *item, *menu, *image; GtkWidget *table2, *arrow, *check; GtkSizeGroup *group; GtkListStore *src_store, *dst_store; struct worklist_data *ptr; ptr = fc_malloc(sizeof(*ptr)); src_store = gtk_list_store_new(1, G_TYPE_INT); dst_store = gtk_list_store_new(1, G_TYPE_INT); ptr->global_worklist_id = -1; ptr->pcity = NULL; ptr->src = src_store; ptr->dst = dst_store; ptr->future = FALSE; /* create shell. */ editor = gtk_grid_new(); gtk_grid_set_row_spacing(GTK_GRID(editor), 6); gtk_orientable_set_orientation(GTK_ORIENTABLE(editor), GTK_ORIENTATION_VERTICAL); g_signal_connect(editor, "destroy", G_CALLBACK(worklist_destroy), ptr); g_object_set_data(G_OBJECT(editor), "data", ptr); ptr->editor = editor; /* add source and target lists. */ table = gtk_grid_new(); gtk_container_add(GTK_CONTAINER(editor), table); group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_grid_attach(GTK_GRID(table), sw, 3, 1, 2, 1); src_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(src_store)); gtk_widget_set_hexpand(src_view, TRUE); gtk_widget_set_vexpand(src_view, TRUE); g_object_unref(src_store); gtk_size_group_add_widget(group, src_view); gtk_widget_set_name(src_view, "small_font"); populate_view(GTK_TREE_VIEW(src_view), &ptr->pcity, &ptr->src_col); gtk_container_add(GTK_CONTAINER(sw), src_view); label = g_object_new(GTK_TYPE_LABEL, "use-underline", TRUE, "mnemonic-widget", src_view, "label", _("Source _Tasks:"), "xalign", 0.0, "yalign", 0.5, NULL); gtk_grid_attach(GTK_GRID(table), label, 3, 0, 1, 1); check = gtk_check_button_new_with_mnemonic(_("Show _Future Targets")); gtk_grid_attach(GTK_GRID(table), check, 4, 0, 1, 1); g_signal_connect(check, "toggled", G_CALLBACK(future_callback), ptr); table2 = gtk_grid_new(); gtk_grid_attach(GTK_GRID(table), table2, 2, 1, 1, 1); button = gtk_button_new(); gtk_widget_set_margin_top(button, 24); gtk_widget_set_margin_bottom(button, 24); ptr->prepend_cmd = button; gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE); gtk_grid_attach(GTK_GRID(table2), button, 0, 0, 1, 1); arrow = gtk_arrow_new(GTK_ARROW_LEFT, GTK_SHADOW_NONE); gtk_container_add(GTK_CONTAINER(button), arrow); g_signal_connect_swapped(button, "clicked", G_CALLBACK(queue_prepend), ptr); gtk_widget_set_sensitive(ptr->prepend_cmd, FALSE); button = gtk_button_new(); ptr->up_cmd = button; gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE); gtk_grid_attach(GTK_GRID(table2), button, 0, 1, 1, 1); arrow = gtk_arrow_new(GTK_ARROW_UP, GTK_SHADOW_NONE); gtk_container_add(GTK_CONTAINER(button), arrow); g_signal_connect_swapped(button, "clicked", G_CALLBACK(queue_bubble_up), ptr); gtk_widget_set_sensitive(ptr->up_cmd, FALSE); button = gtk_button_new(); ptr->down_cmd = button; gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE); gtk_grid_attach(GTK_GRID(table2), button, 0, 2, 1, 1); arrow = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_IN); gtk_container_add(GTK_CONTAINER(button), arrow); g_signal_connect_swapped(button, "clicked", G_CALLBACK(queue_bubble_down), ptr); gtk_widget_set_sensitive(ptr->down_cmd, FALSE); button = gtk_button_new(); gtk_widget_set_margin_top(button, 24); gtk_widget_set_margin_bottom(button, 24); ptr->append_cmd = button; gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE); gtk_grid_attach(GTK_GRID(table2), button, 0, 3, 1, 1); arrow = gtk_arrow_new(GTK_ARROW_LEFT, GTK_SHADOW_NONE); gtk_container_add(GTK_CONTAINER(button), arrow); g_signal_connect_swapped(button, "clicked", G_CALLBACK(queue_append), ptr); gtk_widget_set_sensitive(ptr->append_cmd, FALSE); button = gtk_button_new(); gtk_widget_set_margin_top(button, 24); gtk_widget_set_margin_bottom(button, 24); ptr->remove_cmd = button; gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE); gtk_grid_attach(GTK_GRID(table2), button, 0, 4, 1, 1); arrow = gtk_arrow_new(GTK_ARROW_RIGHT, GTK_SHADOW_IN); gtk_container_add(GTK_CONTAINER(button), arrow); g_signal_connect_swapped(button, "clicked", G_CALLBACK(queue_remove), ptr); gtk_widget_set_sensitive(ptr->remove_cmd, FALSE); sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_grid_attach(GTK_GRID(table), sw, 0, 1, 2, 1); dst_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(dst_store)); gtk_widget_set_hexpand(dst_view, TRUE); gtk_widget_set_vexpand(dst_view, TRUE); g_object_unref(dst_store); gtk_size_group_add_widget(group, dst_view); gtk_widget_set_name(dst_view, "small_font"); populate_view(GTK_TREE_VIEW(dst_view), &ptr->pcity, &ptr->dst_col); gtk_container_add(GTK_CONTAINER(sw), dst_view); label = g_object_new(GTK_TYPE_LABEL, "use-underline", TRUE, "mnemonic-widget", dst_view, "label", _("Target _Worklist:"), "xalign", 0.0, "yalign", 0.5, NULL); gtk_grid_attach(GTK_GRID(table), label, 0, 0, 1, 1); /* add bottom menu and buttons. */ bbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL); gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END); gtk_box_set_spacing(GTK_BOX(bbox), 10); gtk_container_add(GTK_CONTAINER(editor), bbox); menubar = gtk_aux_menu_bar_new(); gtk_container_add(GTK_CONTAINER(bbox), menubar); gtk_button_box_set_child_secondary(GTK_BUTTON_BOX(bbox), menubar, TRUE); menu = gtk_menu_new(); image = gtk_image_new_from_stock(GTK_STOCK_ADD, GTK_ICON_SIZE_MENU); item = gtk_image_menu_item_new_with_mnemonic(_("_Add Global Worklist")); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), menu); gtk_menu_shell_append(GTK_MENU_SHELL(menubar), item); g_signal_connect(menu, "show", G_CALLBACK(popup_add_menu), ptr); ptr->add_cmd = item; gtk_widget_set_sensitive(ptr->add_cmd, FALSE); button = gtk_button_new_from_stock(GTK_STOCK_HELP); gtk_container_add(GTK_CONTAINER(bbox), button); g_signal_connect(button, "clicked", G_CALLBACK(help_callback), ptr); ptr->help_cmd = button; gtk_widget_set_sensitive(ptr->help_cmd, FALSE); button = gtk_button_new_with_mnemonic(_("Change Prod_uction")); gtk_container_add(GTK_CONTAINER(bbox), button); g_signal_connect(button, "clicked", G_CALLBACK(change_callback), ptr); ptr->change_cmd = button; gtk_widget_set_sensitive(ptr->change_cmd, FALSE); ptr->src_view = src_view; ptr->dst_view = dst_view; ptr->src_selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(src_view)); ptr->dst_selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dst_view)); gtk_tree_selection_set_mode(ptr->dst_selection, GTK_SELECTION_MULTIPLE); /* DND and other state changing callbacks. */ gtk_tree_view_set_reorderable(GTK_TREE_VIEW(dst_view), TRUE); g_signal_connect(dst_view, "drag_end", G_CALLBACK(dst_dnd_callback), ptr); g_signal_connect(src_view, "row_activated", G_CALLBACK(src_row_callback), ptr); g_signal_connect(src_view, "key_press_event", G_CALLBACK(src_key_press_callback), ptr); g_signal_connect(dst_view, "row_activated", G_CALLBACK(dst_row_callback), ptr); g_signal_connect(dst_view, "key_press_event", G_CALLBACK(dst_key_press_callback), ptr); g_signal_connect(ptr->src_selection, "changed", G_CALLBACK(src_selection_callback), ptr); g_signal_connect(ptr->dst_selection, "changed", G_CALLBACK(dst_selection_callback), ptr); gtk_widget_show_all(table); gtk_widget_show_all(bbox); return editor; }
XAttOneGtk::XAttOneGtk( GtkWidget *xa_parent_wid, void *xa_parent_ctx, pwr_sAttrRef *xa_aref, char *xa_title, unsigned int xa_priv, int *xa_sts) : XAttOne( xa_parent_ctx, xa_aref, xa_title, xa_priv, xa_sts), parent_wid(xa_parent_wid) { pwr_tAName title; *xa_sts = gdh_AttrrefToName( &aref, title, sizeof(title), cdh_mNName); if ( EVEN(*xa_sts)) return; toplevel = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW, "default-height", 200, "default-width", 500, "title", CoWowGtk::convert_utf8(title), NULL); g_signal_connect( toplevel, "delete_event", G_CALLBACK(delete_event), this); g_signal_connect( toplevel, "destroy", G_CALLBACK(destroy_event), this); g_signal_connect( toplevel, "focus-in-event", G_CALLBACK(action_inputfocus), this); CoWowGtk::SetWindowIcon( toplevel); // Menu // Accelerators GtkAccelGroup *accel_g = (GtkAccelGroup *) g_object_new(GTK_TYPE_ACCEL_GROUP, NULL); gtk_window_add_accel_group(GTK_WINDOW(toplevel), accel_g); GtkMenuBar *menu_bar = (GtkMenuBar *) g_object_new(GTK_TYPE_MENU_BAR, NULL); // File entry GtkWidget *file_close = gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, accel_g); g_signal_connect(file_close, "activate", G_CALLBACK(activate_exit), this); GtkMenu *file_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL); gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_close); GtkWidget *file = gtk_menu_item_new_with_mnemonic("_File"); gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file); gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), GTK_WIDGET(file_menu)); // Help entry GtkWidget *help_help = gtk_image_menu_item_new_from_stock(GTK_STOCK_HELP, accel_g); g_signal_connect(help_help, "activate", G_CALLBACK(activate_help), this); GtkMenu *help_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL); gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_help); GtkWidget *help = gtk_menu_item_new_with_mnemonic("_Help"); gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), help); gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), GTK_WIDGET(help_menu)); // Prompt, label, input entry msg_label = gtk_label_new( ""); gtk_widget_set_size_request( msg_label, -1, 25); cmd_prompt = gtk_label_new( "value > "); gtk_widget_set_size_request( cmd_prompt, -1, 25); cmd_label = gtk_label_new(""); gtk_widget_set_size_request( cmd_label, -1, 25); gtk_misc_set_alignment( GTK_MISC(cmd_label), 0.0, 0.5); cmd_entry = new CoWowEntryGtk( &value_recall); cmd_input = cmd_entry->widget(); gtk_widget_set_size_request( cmd_input, -1, 25); g_signal_connect( cmd_input, "activate", G_CALLBACK(activate_cmd_input), this); // Scrolled text input cmd_scrolled_buffer = gtk_text_buffer_new( NULL); cmd_scrolledtextview = gtk_text_view_new_with_buffer( cmd_scrolled_buffer); GtkWidget *viewport = gtk_viewport_new( NULL, NULL); GtkWidget *scrolledwindow = gtk_scrolled_window_new(NULL, NULL); gtk_container_add( GTK_CONTAINER(viewport), cmd_scrolledtextview); gtk_container_add( GTK_CONTAINER(scrolledwindow), viewport); cmd_scrolledinput = gtk_vbox_new( FALSE, 0); gtk_box_pack_start( GTK_BOX(cmd_scrolledinput), scrolledwindow, TRUE, TRUE, 0); // Buttons cmd_scrolled_ok = gtk_button_new_with_label( CoWowGtk::translate_utf8("Ok")); gtk_widget_set_size_request( cmd_scrolled_ok, 70, 25); g_signal_connect( cmd_scrolled_ok, "clicked", G_CALLBACK(activate_cmd_scrolled_ok), this); cmd_scrolled_ap = gtk_button_new_with_label( CoWowGtk::translate_utf8("Apply")); gtk_widget_set_size_request( cmd_scrolled_ap, 70, 25); g_signal_connect( cmd_scrolled_ap, "clicked", G_CALLBACK(activate_cmd_scrolled_ap), this); cmd_scrolled_ca = gtk_button_new_with_label( CoWowGtk::translate_utf8("Cancel")); gtk_widget_set_size_request( cmd_scrolled_ca, 70, 25); g_signal_connect( cmd_scrolled_ca, "clicked", G_CALLBACK(activate_cmd_scrolled_ca), this); GtkWidget *hboxbuttons = gtk_hbox_new( TRUE, 40); gtk_box_pack_start( GTK_BOX(hboxbuttons), cmd_scrolled_ok, FALSE, FALSE, 0); gtk_box_pack_start( GTK_BOX(hboxbuttons), cmd_scrolled_ap, FALSE, FALSE, 0); gtk_box_pack_end( GTK_BOX(hboxbuttons), cmd_scrolled_ca, FALSE, FALSE, 0); // Horizontal box GtkWidget *statusbar = gtk_hbox_new( FALSE, 0); gtk_box_pack_start( GTK_BOX(statusbar), msg_label, FALSE, FALSE, 15); gtk_box_pack_start( GTK_BOX(statusbar), cmd_prompt, FALSE, FALSE, 15); gtk_box_pack_start( GTK_BOX(statusbar), cmd_label, TRUE, TRUE, 15); gtk_box_pack_start( GTK_BOX(statusbar), cmd_input, TRUE, TRUE, 15); gtk_box_pack_start( GTK_BOX(statusbar), cmd_scrolledinput, TRUE, TRUE, 15); GtkWidget *vbox = gtk_vbox_new( FALSE, 0); gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(menu_bar), FALSE, FALSE, 0); gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(statusbar), TRUE, TRUE, 0); gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(gtk_hseparator_new()), FALSE, FALSE, 0); gtk_box_pack_end( GTK_BOX(vbox), hboxbuttons, FALSE, FALSE, 5); gtk_container_add( GTK_CONTAINER(toplevel), vbox); gtk_widget_show_all( toplevel); if ( priv & pwr_mPrv_RtWrite || priv & pwr_mPrv_System) access_rw = 1; else access_rw = 0; if ( access_rw) g_object_set( cmd_label, "visible", FALSE, NULL); else { g_object_set( cmd_input, "visible", FALSE, NULL); g_object_set( cmd_scrolledinput, "visible", FALSE, NULL); g_object_set( cmd_scrolled_ok, "visible", FALSE, NULL); g_object_set( cmd_scrolled_ap, "visible", FALSE, NULL); } change_value( 1); *xa_sts = XATT__SUCCESS; }
WPkgGtk::WPkgGtk( GtkWidget *wa_parent_wid, void *wa_parent_ctx) : WPkg(wa_parent_ctx), parent_wid(wa_parent_wid), clock_cursor(0) { const int window_width = 600; const int window_height = 600; int sts; pwr_tFileName fname; toplevel = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW, "default-height", window_height, "default-width", window_width, "title", "Distributor", NULL); g_signal_connect( toplevel, "delete_event", G_CALLBACK(delete_event), this); g_signal_connect( toplevel, "destroy", G_CALLBACK(destroy_event), this); g_signal_connect( toplevel, "focus-in-event", G_CALLBACK(action_inputfocus), this); CoWowGtk::SetWindowIcon( toplevel); GtkAccelGroup *accel_g = (GtkAccelGroup *) g_object_new(GTK_TYPE_ACCEL_GROUP, NULL); gtk_window_add_accel_group(GTK_WINDOW(toplevel), accel_g); GtkMenuBar *menu_bar = (GtkMenuBar *) g_object_new(GTK_TYPE_MENU_BAR, NULL); // File Entry GtkWidget *file_history = gtk_menu_item_new_with_mnemonic( "_History"); g_signal_connect( file_history, "activate", G_CALLBACK(WPkgGtk::activate_history), this); GtkWidget *file_close = gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, accel_g); g_signal_connect(file_close, "activate", G_CALLBACK(WPkgGtk::activate_exit), this); GtkMenu *file_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL); gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_history); gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_close); GtkWidget *file = gtk_menu_item_new_with_mnemonic("_File"); gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file); gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), GTK_WIDGET(file_menu)); // Functions Entry GtkWidget *functions_distribute = gtk_menu_item_new_with_mnemonic( "_Distribute"); g_signal_connect( functions_distribute, "activate", G_CALLBACK(WPkgGtk::activate_distribute), this); gtk_widget_add_accelerator( functions_distribute, "activate", accel_g, 'd', GdkModifierType(GDK_CONTROL_MASK), GTK_ACCEL_VISIBLE); GtkWidget *functions_createpkg = gtk_menu_item_new_with_mnemonic( "_Create Package"); g_signal_connect( functions_createpkg, "activate", G_CALLBACK(WPkgGtk::activate_createpkg), this); GtkWidget *functions_deletepkg = gtk_menu_item_new_with_mnemonic( "D_elete Package"); g_signal_connect( functions_deletepkg, "activate", G_CALLBACK(WPkgGtk::activate_deletepkg), this); GtkMenu *functions_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL); gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_distribute); gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_createpkg); gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_deletepkg); GtkWidget *functions = gtk_menu_item_new_with_mnemonic("F_unctions"); gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), functions); gtk_menu_item_set_submenu(GTK_MENU_ITEM(functions), GTK_WIDGET(functions_menu)); // View menu GtkWidget *view_zoom_in = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_IN, NULL); g_signal_connect(view_zoom_in, "activate", G_CALLBACK(WPkgGtk::activate_zoom_in), this); gtk_widget_add_accelerator( view_zoom_in, "activate", accel_g, 'i', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); GtkWidget *view_zoom_out = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_OUT, NULL); g_signal_connect(view_zoom_out, "activate", G_CALLBACK(WPkgGtk::activate_zoom_out), this); gtk_widget_add_accelerator( view_zoom_out, "activate", accel_g, 'o', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); GtkWidget *view_zoom_reset = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_100, NULL); g_signal_connect(view_zoom_reset, "activate", G_CALLBACK(WPkgGtk::activate_zoom_reset), this); GtkWidget *view_dmode_filediff = gtk_menu_item_new_with_mnemonic( "_Display File Differences"); g_signal_connect( view_dmode_filediff, "activate", G_CALLBACK(WPkgGtk::activate_dmode_filediff), this); GtkWidget *view_dmode_filetime = gtk_menu_item_new_with_mnemonic( "Display Files In _Time Order"); g_signal_connect( view_dmode_filetime, "activate", G_CALLBACK(WPkgGtk::activate_dmode_filetime), this); GtkWidget *view_dmode_filepath = gtk_menu_item_new_with_mnemonic( "Display File _Path"); g_signal_connect( view_dmode_filepath, "activate", G_CALLBACK(WPkgGtk::activate_dmode_filepath), this); GtkMenu *view_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL); gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_in); gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_out); gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_reset); gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_dmode_filediff); gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_dmode_filetime); gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_dmode_filepath); GtkWidget *view = gtk_menu_item_new_with_mnemonic("_View"); gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), view); gtk_menu_item_set_submenu(GTK_MENU_ITEM(view), GTK_WIDGET(view_menu)); // Menu Help GtkWidget *help_help = gtk_image_menu_item_new_with_mnemonic("_Help"); gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(help_help), gtk_image_new_from_stock( "gtk-help", GTK_ICON_SIZE_MENU)); g_signal_connect(help_help, "activate", G_CALLBACK(WPkgGtk::activate_help), this); gtk_widget_add_accelerator( help_help, "activate", accel_g, 'h', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); GtkMenu *help_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL); gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_help); GtkWidget *help = gtk_menu_item_new_with_mnemonic("_Help"); gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), help); gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), GTK_WIDGET(help_menu)); // Toolbar GtkToolbar *tools = (GtkToolbar *) g_object_new(GTK_TYPE_TOOLBAR, NULL); GtkWidget *tools_distribute = gtk_button_new(); dcli_translate_filename( fname, "$pwr_exe/wpkg_distribute.png"); gtk_container_add( GTK_CONTAINER(tools_distribute), gtk_image_new_from_file( fname)); g_signal_connect(tools_distribute, "clicked", G_CALLBACK(WPkgGtk::activate_distribute), this); g_object_set( tools_distribute, "can-focus", FALSE, NULL); gtk_toolbar_append_widget( tools, tools_distribute, "Distribute", ""); GtkWidget *tools_zoom_in = gtk_button_new(); dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_in.png"); gtk_container_add( GTK_CONTAINER(tools_zoom_in), gtk_image_new_from_file( fname)); g_signal_connect(tools_zoom_in, "clicked", G_CALLBACK(WPkgGtk::activate_zoom_in), this); g_object_set( tools_zoom_in, "can-focus", FALSE, NULL); gtk_toolbar_append_widget( tools, tools_zoom_in, "Zoom in", ""); GtkWidget *tools_zoom_out = gtk_button_new(); dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_out.png"); gtk_container_add( GTK_CONTAINER(tools_zoom_out), gtk_image_new_from_file( fname)); g_signal_connect(tools_zoom_out, "clicked", G_CALLBACK(WPkgGtk::activate_zoom_out), this); g_object_set( tools_zoom_out, "can-focus", FALSE, NULL); gtk_toolbar_append_widget( tools, tools_zoom_out, "Zoom out", ""); GtkWidget *tools_zoom_reset = gtk_button_new(); dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_reset.png"); gtk_container_add( GTK_CONTAINER(tools_zoom_reset), gtk_image_new_from_file( fname)); g_signal_connect(tools_zoom_reset, "clicked", G_CALLBACK(WPkgGtk::activate_zoom_reset), this); g_object_set( tools_zoom_reset, "can-focus", FALSE, NULL); gtk_toolbar_append_widget( tools, tools_zoom_reset, "Zoom reset", ""); GtkWidget *vbox = gtk_vbox_new( FALSE, 0); utility = ((WUtility *)parent_ctx)->utype; wpkgnav = new WPkgNavGtk( (void *)this, vbox, "Packages", utility, &brow_widget, &sts); ((WPkgNav *)wpkgnav)->message_cb = message_cb; ((WPkgNav *)wpkgnav)->set_clock_cursor_cb = set_clock_cursor_cb; ((WPkgNav *)wpkgnav)->reset_cursor_cb = reset_cursor_cb; GtkWidget *statusbar = gtk_hbox_new( FALSE, 0); msg_label = gtk_label_new( ""); gtk_box_pack_start( GTK_BOX(statusbar), msg_label, FALSE, FALSE, 20); gtk_widget_show_all( statusbar); gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(menu_bar), FALSE, FALSE, 0); gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(tools), FALSE, FALSE, 0); gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(brow_widget), TRUE, TRUE, 0); gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(statusbar), FALSE, FALSE, 3); gtk_container_add( GTK_CONTAINER(toplevel), vbox); gtk_widget_show_all( toplevel); wow = new CoWowGtk( toplevel); if ( utility == wb_eUtility_Wtt) { ((Wtt *)parent_ctx)->register_utility( (void *) this, wb_eUtility_Distributor); } }
GtkWidget * mate_panel_applet_create_menu (AppletInfo *info) { GtkWidget *menu; GtkWidget *menuitem; GList *l; PanelWidget *panel_widget; gboolean added_anything = FALSE; panel_widget = mate_panel_applet_get_panel_widget (info); menu = g_object_ref_sink (gtk_menu_new ()); /* connect the show & deactivate signal, so that we can "disallow" and * "re-allow" autohide when the menu is shown/deactivated. */ g_signal_connect (menu, "show", G_CALLBACK (applet_menu_show), info); g_signal_connect (menu, "deactivate", G_CALLBACK (applet_menu_deactivate), info); for (l = info->user_menu; l; l = l->next) { AppletUserMenu *user_menu = l->data; if (user_menu->is_enabled_func && !user_menu->is_enabled_func ()) continue; add_to_submenus (info, "", user_menu->name, user_menu, menu, info->user_menu); added_anything = TRUE; } if (!panel_lockdown_get_locked_down ()) { GtkWidget *image; gboolean locked; gboolean lockable; gboolean movable; gboolean removable; lockable = mate_panel_applet_lockable (info); movable = mate_panel_applet_can_freely_move (info); removable = panel_profile_id_lists_are_writable (); locked = panel_widget_get_applet_locked (panel_widget, info->widget); if (added_anything) { menuitem = gtk_separator_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); gtk_widget_show (menuitem); } menuitem = gtk_image_menu_item_new_with_mnemonic (_("_Remove From Panel")); image = gtk_image_new_from_stock (GTK_STOCK_REMOVE, GTK_ICON_SIZE_MENU); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image); g_signal_connect (menuitem, "activate", G_CALLBACK (applet_remove_callback), info); gtk_widget_show (menuitem); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); gtk_widget_set_sensitive (menuitem, (!locked || lockable) && removable); menuitem = gtk_menu_item_new_with_mnemonic (_("_Move")); g_signal_connect (menuitem, "activate", G_CALLBACK (move_applet_callback), info); gtk_widget_show (menuitem); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); gtk_widget_set_sensitive (menuitem, !locked && movable); g_assert (info->move_item == NULL); info->move_item = menuitem; g_object_add_weak_pointer (G_OBJECT (menuitem), (gpointer *) &info->move_item); menuitem = gtk_separator_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); gtk_widget_show (menuitem); menuitem = gtk_check_menu_item_new_with_mnemonic (_("Loc_k To Panel")); gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menuitem), locked); g_signal_connect (menuitem, "toggled", G_CALLBACK (mate_panel_applet_lock), info); gtk_widget_show (menuitem); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); gtk_widget_set_sensitive (menuitem, lockable); added_anything = TRUE; } if ( ! added_anything) { g_object_unref (menu); return NULL; } return menu; }
// // Create a new ute window // WUtedGtk::WUtedGtk( void *wu_parent_ctx, GtkWidget *wu_parent_wid, const char *wu_name, const char *wu_iconname, ldh_tWBContext wu_ldhwb, ldh_tSesContext wu_ldhses, int wu_editmode, void (*wu_quit_cb)(void *), pwr_tStatus *status) : WUted(wu_parent_ctx,wu_name,wu_iconname,wu_ldhwb,wu_ldhses,wu_editmode,wu_quit_cb, status), parent_wid(wu_parent_wid), cursor(0) { const int window_width = 800; const int window_height = 400; memset( &widgets, 0, sizeof(widgets)); toplevel = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW, "default-height", window_height, "default-width", window_width, NULL); g_signal_connect( toplevel, "delete_event", G_CALLBACK(delete_event), this); g_signal_connect( toplevel, "destroy", G_CALLBACK(destroy_event), this); CoWowGtk::SetWindowIcon( toplevel); GtkAccelGroup *accel_g = (GtkAccelGroup *) g_object_new(GTK_TYPE_ACCEL_GROUP, NULL); gtk_window_add_accel_group(GTK_WINDOW(toplevel), accel_g); GtkMenuBar *menu_bar = (GtkMenuBar *) g_object_new(GTK_TYPE_MENU_BAR, NULL); // File Entry GtkWidget *file_close = gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, accel_g); g_signal_connect(file_close, "activate", G_CALLBACK(activate_quit), this); GtkMenu *file_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL); gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_close); GtkWidget *file = gtk_menu_item_new_with_mnemonic("_File"); gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file); gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), GTK_WIDGET(file_menu)); // View Entry GtkWidget *view_show_cmd = gtk_menu_item_new_with_mnemonic( "_Show Current Command"); g_signal_connect( view_show_cmd, "activate", G_CALLBACK(activate_show_cmd), this); GtkMenu *view_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL); gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_show_cmd); GtkWidget *view = gtk_menu_item_new_with_mnemonic("_View"); gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), view); gtk_menu_item_set_submenu(GTK_MENU_ITEM(view), GTK_WIDGET(view_menu)); // Commands entry GtkMenu *commands_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL); GtkMenu *current_menu = commands_menu; int j = 0; int in_submenu = 0; uted_sCommand *next_cmd; for ( uted_sCommand *command_ptr = commands; command_ptr->command[0]; command_ptr++) { // Build submenu if first command verb is equal to next char cmd_verb[5][80]; int num; char next_cmd_verb[5][80]; int next_num; num = dcli_parse( command_ptr->command, " ", "", (char *)cmd_verb, sizeof( cmd_verb) / sizeof( cmd_verb[0]), sizeof( cmd_verb[0]), 0); next_cmd = command_ptr + 1; int close_submenu = 0; if ( next_cmd->command[0]) { next_num = dcli_parse( next_cmd->command, " ", "", (char *)next_cmd_verb, sizeof( next_cmd_verb) / sizeof( next_cmd_verb[0]), sizeof( next_cmd_verb[0]), 0); if ( in_submenu) { // Check if time to close menu if ( strcmp( cmd_verb[0], next_cmd_verb[0]) != 0) { // Close submenu close_submenu = 1; } } else if ( strcmp( cmd_verb[0], next_cmd_verb[0]) == 0) { // Open submenu GtkWidget *submenu_item = gtk_menu_item_new_with_label( cmd_verb[0]); GtkMenu *submenu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL); gtk_menu_item_set_submenu(GTK_MENU_ITEM(submenu_item), GTK_WIDGET(submenu)); gtk_menu_shell_append(GTK_MENU_SHELL(commands_menu), submenu_item); current_menu = submenu; in_submenu = 1; } } else if ( in_submenu) { // Last command close_submenu = 1; } widgets.optmenubuttons[j] = gtk_menu_item_new(); widgets.optmenubuttonslabel[j] = gtk_label_new( command_ptr->command); gtk_misc_set_alignment( GTK_MISC(widgets.optmenubuttonslabel[j]), 0.0, 0.5); gtk_container_add( GTK_CONTAINER(widgets.optmenubuttons[j]), widgets.optmenubuttonslabel[j]); g_signal_connect( widgets.optmenubuttons[j], "activate", G_CALLBACK(activate_command), this); gtk_menu_shell_append(GTK_MENU_SHELL(current_menu), widgets.optmenubuttons[j]); if ( close_submenu) { current_menu = commands_menu; in_submenu = 0; } j++; } GtkWidget *commands = gtk_menu_item_new_with_mnemonic("_Commands"); gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), commands); gtk_menu_item_set_submenu(GTK_MENU_ITEM(commands), GTK_WIDGET(commands_menu)); // Menu Help GtkWidget *help_utils = gtk_image_menu_item_new_with_mnemonic("_On Window"); gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(help_utils), gtk_image_new_from_stock( "gtk-help", GTK_ICON_SIZE_MENU)); g_signal_connect(help_utils, "activate", G_CALLBACK(activate_helputils), this); gtk_widget_add_accelerator( help_utils, "activate", accel_g, 'h', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); GtkWidget *help_cmd = gtk_menu_item_new_with_mnemonic( "On _Commands"); g_signal_connect( help_cmd, "activate", G_CALLBACK(activate_helppwr_plc), this); GtkMenu *help_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL); gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_utils); gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_cmd); GtkWidget *help = gtk_menu_item_new_with_mnemonic("_Help"); gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), help); gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), GTK_WIDGET(help_menu)); // Qualifier labels, entries and checkboxes GtkWidget *qual_box_qual = gtk_vbox_new( FALSE, 0); GtkWidget *qual_box_value = gtk_vbox_new( FALSE, 0); for ( j = 0; j < 10; j++) { widgets.qualifier[j] = gtk_label_new( "Qual"); gtk_widget_set_size_request( widgets.qualifier[j], 120, 20); gtk_misc_set_alignment( GTK_MISC(widgets.qualifier[j]), 0.0, 0.5); gtk_box_pack_start( GTK_BOX(qual_box_qual), widgets.qualifier[j], FALSE, FALSE, 5); GtkWidget *box = gtk_hbox_new( FALSE, 0); widgets.value[j] = gtk_entry_new(); gtk_widget_set_size_request( widgets.value[j], -1, 20); gtk_box_pack_start( GTK_BOX(box), widgets.value[j], TRUE, TRUE, 0); widgets.present[j] = gtk_check_button_new(); gtk_widget_set_size_request( widgets.present[j], -1, 20); gtk_box_pack_start( GTK_BOX(box), widgets.present[j], FALSE, FALSE, 0); gtk_box_pack_start( GTK_BOX(qual_box_value), box, FALSE, FALSE, 5); } g_signal_connect( widgets.present[0], "toggled", G_CALLBACK(activate_present1), this); g_signal_connect( widgets.present[1], "toggled", G_CALLBACK(activate_present2), this); g_signal_connect( widgets.present[2], "toggled", G_CALLBACK(activate_present3), this); g_signal_connect( widgets.present[3], "toggled", G_CALLBACK(activate_present4), this); g_signal_connect( widgets.present[4], "toggled", G_CALLBACK(activate_present5), this); g_signal_connect( widgets.present[5], "toggled", G_CALLBACK(activate_present6), this); g_signal_connect( widgets.present[6], "toggled", G_CALLBACK(activate_present7), this); g_signal_connect( widgets.present[7], "toggled", G_CALLBACK(activate_present8), this); g_signal_connect( widgets.present[8], "toggled", G_CALLBACK(activate_present9), this); g_signal_connect( widgets.present[9], "toggled", G_CALLBACK(activate_present10), this); // Command label GtkWidget *cmdlabel = gtk_label_new( "Command"); widgets.commandlabel = gtk_label_new( "No command selected"); gtk_misc_set_alignment( GTK_MISC(widgets.commandlabel), 0.0, 0.5); gtk_widget_set_size_request( widgets.commandlabel, 140, -1); GtkWidget *vbox_command = gtk_hbox_new( FALSE, 0); gtk_box_pack_start( GTK_BOX(vbox_command), cmdlabel, FALSE, FALSE, 10); gtk_box_pack_start( GTK_BOX(vbox_command), widgets.commandlabel, FALSE, FALSE, 10); // Apply button GtkWidget *applybutton = gtk_button_new_with_label( "Apply"); gtk_widget_set_size_request( applybutton, 70, 25); g_signal_connect( applybutton, "clicked", G_CALLBACK(activate_ok), this); GtkWidget *left_box = gtk_vbox_new( FALSE, 0); gtk_box_pack_start( GTK_BOX(left_box), vbox_command, FALSE, FALSE, 10); GtkWidget *button_box = gtk_hbox_new( FALSE, 0); gtk_box_pack_start( GTK_BOX(button_box), applybutton, FALSE, FALSE, 50); GtkWidget *qual_box = gtk_hbox_new( FALSE, 0); gtk_box_pack_start( GTK_BOX(qual_box), left_box, FALSE, FALSE, 10); gtk_box_pack_start( GTK_BOX(qual_box), gtk_vseparator_new(), FALSE, FALSE, 0); gtk_box_pack_start( GTK_BOX(qual_box), qual_box_qual, FALSE, FALSE, 10); gtk_box_pack_start( GTK_BOX(qual_box), qual_box_value, TRUE, TRUE, 10); // Statusbar GtkWidget *statusbar = gtk_hbox_new( FALSE, 0); widgets.label = gtk_label_new( ""); gtk_box_pack_start( GTK_BOX(statusbar), widgets.label, FALSE, FALSE, 20); GtkWidget *vbox = gtk_vbox_new( FALSE, 0); gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(menu_bar), FALSE, FALSE, 0); gtk_box_pack_start( GTK_BOX(vbox), qual_box, TRUE, TRUE, 0); gtk_box_pack_start( GTK_BOX(vbox), gtk_hseparator_new(), FALSE, FALSE, 3); gtk_box_pack_start( GTK_BOX(vbox), button_box, FALSE, FALSE, 3); gtk_box_pack_start( GTK_BOX(vbox), statusbar, FALSE, FALSE, 3); gtk_container_add( GTK_CONTAINER(toplevel), vbox); gtk_widget_show_all( toplevel); batch_sts = UTED_BATCH_CURRSESS; reset_qual(); enable_entries( wu_editmode); #if 0 Arg args[20]; pwr_tStatus sts; int i; MrmHierarchy s_MrmH; MrmType dclass; /* DRM database hierarchy related variables */ static Pixmap icon = 0; Dimension icon_w; Dimension icon_h; static Atom MwmDeleteWind = 0; char uid_filename[200] = {"pwr_exe:wb_uted.uid"}; char *uid_filename_p = uid_filename; static MrmRegisterArg reglist[] = { /* First the context variable */ { "uted_ctx", 0 }, /* Callbacks for the controlled foe widget */ {"uted_create_adb",(caddr_t)create_adb}, {"uted_create_quit",(caddr_t)create_quit}, {"uted_activate_quit",(caddr_t)activate_quit}, {"uted_create_commandlabel",(caddr_t)create_commandlabel}, {"uted_create_batchoptmenu",(caddr_t)create_batchoptmenu}, {"uted_create_batch",(caddr_t)create_batch}, {"uted_create_currsess",(caddr_t)create_currsess}, {"uted_create_file_entry",(caddr_t)create_file_entry}, {"uted_create_label",(caddr_t)create_label}, {"uted_create_adb",(caddr_t)create_adb}, {"uted_activate_command",(caddr_t)activate_command}, {"uted_create_command",(caddr_t)create_command}, {"uted_activate_batch",(caddr_t)activate_batch}, {"uted_activate_currsess",(caddr_t)activate_currsess}, {"uted_activate_ok",(caddr_t)activate_ok}, {"uted_activate_cancel",(caddr_t)activate_cancel}, {"uted_activate_show_cmd",(caddr_t)activate_show_cmd}, {"uted_create_commandwind_button",(caddr_t)create_commandwind_button}, {"uted_activate_cmd_wind",(caddr_t)activate_cmd_wind}, {"uted_create_cmd_wind",(caddr_t)create_cmd_wind}, {"uted_create_timelabel",(caddr_t)create_timelabel}, {"uted_create_timevalue",(caddr_t)create_timevalue}, {"uted_create_qualifier1",(caddr_t)create_qualifier1}, {"uted_create_value1",(caddr_t)create_value1}, {"uted_activate_present1",(caddr_t)activate_present1}, {"uted_create_present1",(caddr_t)create_present1}, {"uted_create_qualifier2",(caddr_t)create_qualifier2}, {"uted_create_value2",(caddr_t)create_value2}, {"uted_activate_present2",(caddr_t)activate_present2}, {"uted_create_present2",(caddr_t)create_present2}, {"uted_create_qualifier3",(caddr_t)create_qualifier3}, {"uted_create_value3",(caddr_t)create_value3}, {"uted_activate_present3",(caddr_t)activate_present3}, {"uted_create_present3",(caddr_t)create_present3}, {"uted_create_qualifier4",(caddr_t)create_qualifier4}, {"uted_create_value4",(caddr_t)create_value4}, {"uted_activate_present4",(caddr_t)activate_present4}, {"uted_create_present4",(caddr_t)create_present4}, {"uted_create_qualifier5",(caddr_t)create_qualifier5}, {"uted_create_value5",(caddr_t)create_value5}, {"uted_activate_present5",(caddr_t)activate_present5}, {"uted_create_present5",(caddr_t)create_present5}, {"uted_create_qualifier6",(caddr_t)create_qualifier6}, {"uted_create_value6",(caddr_t)create_value6}, {"uted_activate_present6",(caddr_t)activate_present6}, {"uted_create_present6",(caddr_t)create_present6}, {"uted_create_qualifier7",(caddr_t)create_qualifier7}, {"uted_create_value7",(caddr_t)create_value7}, {"uted_activate_present7",(caddr_t)activate_present7}, {"uted_create_present7",(caddr_t)create_present7}, {"uted_create_qualifier8",(caddr_t)create_qualifier8}, {"uted_create_value8",(caddr_t)create_value8}, {"uted_activate_present8",(caddr_t)activate_present8}, {"uted_create_present8",(caddr_t)create_present8}, {"uted_create_qualifier9",(caddr_t)create_qualifier9}, {"uted_create_value9",(caddr_t)create_value9}, {"uted_activate_present9",(caddr_t)activate_present9}, {"uted_create_present9",(caddr_t)create_present9}, {"uted_create_qualifier10",(caddr_t)create_qualifier10}, {"uted_create_value10",(caddr_t)create_value10}, {"uted_activate_present10",(caddr_t)activate_present10}, {"uted_create_present10",(caddr_t)create_present10}, {"uted_activate_helputils",(caddr_t)activate_helputils}, {"uted_activate_helppwr_plc",(caddr_t)activate_helppwr_plc}, {"uted_commandchanged",(caddr_t)commandchanged}, {"uted_qbox_cr",(caddr_t)qbox_cr}, {"uted_qbox_yes_cb",(caddr_t)qbox_yes_cb}, {"uted_qbox_no_cb",(caddr_t)qbox_no_cb}, {"uted_qbox_cancel_cb",(caddr_t)qbox_cancel_cb} }; static int reglist_num = (sizeof reglist / sizeof reglist[0]); /* * Now start the module creation */ sts = dcli_translate_filename( uid_filename, uid_filename); if ( EVEN(sts)) { printf( "** pwr_exe is not defined\n"); exit(0); } /* set initialization values in context */ /* Save the context structure in the widget */ XtSetArg (args[0], XmNuserData, (unsigned int) this); /* * Create a new widget * Open the UID files (the output of the UIL compiler) in the hierarchy * Register the items DRM needs to bind for us. * Create a new widget * Close the hierarchy * Compile the additional button translations and augment and add actions */ sts = MrmOpenHierarchy( 1, &uid_filename_p, NULL, &s_MrmH); if (sts != MrmSUCCESS) printf("can't open hierarchy\n"); reglist[0].value = (caddr_t) this; MrmRegisterNames(reglist, reglist_num); if (icon == 0) sts = MrmFetchBitmapLiteral(s_MrmH,"icon", XtScreen(parent_wid), XtDisplay(parent_wid), &icon, &icon_w, &icon_h); i=0; XtSetArg(args[i],XmNiconName, wu_iconname); i++; XtSetArg(args[i],XmNiconPixmap, icon); i++; XtSetArg(args[i],XmNtitle, name); i++; /* SG 11.02.91 Save the id of the top in the context */ parent_wid = XtCreatePopupShell("utilities", topLevelShellGtkWidgetClass, parent_wid, args, i); /* the positioning of a top level can only be define after the creation of the widget . So i do it know: SG 24.02.91 use the parameters received x and y */ i=0; XtSetArg(args[i],XmNx,100);i++; XtSetArg(args[i],XmNy,100);i++; XtSetArg(args[i],XtNallowShellResize,TRUE), i++; XtSetValues( parent_wid, args, i); /* now that we have a top level we can get the main window */ sts = MrmFetchGtkWidgetOverride(s_MrmH, "uted_window", parent_wid , name, args, 1, &widgets.uted_window, &dclass); if (sts != MrmSUCCESS) printf("can't fetch utedit widget\n"); XtManageChild( widgets.uted_window); /* SG 09.02.91 a top level should always be realized ! */ XtPopup( parent_wid, XtGrabNone ); /* Ask MRM to fetch the question box */ i=0; if (MrmFetchGtkWidgetOverride(s_MrmH, "uted_qbox", widgets.uted_window, 0, args , i, &widgets.questionbox, &dclass) != MrmSUCCESS) { printf("can't fetch uted_qbox widget\n"); } MrmCloseHierarchy(s_MrmH); reset_qual(); batch_sts = UTED_BATCH_CURRSESS; XtSetArg(args[0],XmNsensitive, 0); XtSetValues( widgets.timelabel,args,1); XtUnmanageChild( widgets.timevalue); XtUnmanageChild( widgets.command_window); enable_entries( wu_editmode); if (MwmDeleteWind == 0) MwmDeleteWind = XInternAtom(XtDisplay(parent_wid), "WM_DELETE_WINDOW", FALSE); if (MwmDeleteWind != 0) { XtVaSetValues( parent_wid, XmNdeleteResponse, XmDO_NOTHING, NULL); XmAddWMProtocolCallback( parent_wid, MwmDeleteWind, (XtCallbackProc) activate_quit, this); } #endif *status = FOE__SUCCESS; }
/** \brief Show popup menu for a pass. * * */ void pass_popup_menu_exec (qth_t *qth, pass_t *pass, GdkEventButton *event, GtkWidget *toplevel) { GtkWidget *menu; GtkWidget *menuitem; GtkWidget *image; gchar *buff; menu = gtk_menu_new (); /* pass details */ menuitem = gtk_image_menu_item_new_with_label (_("Show details")); image = gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_FILL, GTK_ICON_SIZE_MENU); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image); g_object_set_data (G_OBJECT (menuitem), "pass", pass); g_object_set_data (G_OBJECT (menuitem), "qth", qth); g_signal_connect (menuitem, "activate", G_CALLBACK (show_pass_details), toplevel); gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem); /* separator */ menuitem = gtk_separator_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem); /* Polar plot pass */ menuitem = gtk_image_menu_item_new_with_label (_("Polar plot")); buff = icon_file_name ("gpredict-polar-small.png"); image = gtk_image_new_from_file (buff); g_free (buff); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image); g_object_set_data (G_OBJECT (menuitem), "pass", pass); g_object_set_data (G_OBJECT (menuitem), "qth", qth); g_signal_connect (menuitem, "activate", G_CALLBACK (polar_plot_pass_details), toplevel); gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem); gtk_widget_set_sensitive (menuitem, FALSE); /* Az/El plot pass */ menuitem = gtk_image_menu_item_new_with_label (_("Az/El plot")); buff = icon_file_name ("gpredict-azel-small.png"); image = gtk_image_new_from_file (buff); g_free (buff); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image); g_object_set_data (G_OBJECT (menuitem), "pass", pass); g_object_set_data (G_OBJECT (menuitem), "qth", qth); g_signal_connect (menuitem, "activate", G_CALLBACK (azel_plot_pass_details), toplevel); gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem); gtk_widget_set_sensitive (menuitem, FALSE); 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)); }
WCrrGtk::WCrrGtk( GtkWidget *xa_parent_wid, void *xa_parent_ctx, ldh_tSesContext xa_ldhses, pwr_sAttrRef *xa_objar, int xa_advanced_user, int *xa_sts) : WCrr( xa_parent_ctx, xa_ldhses, xa_objar, xa_advanced_user, xa_sts), parent_wid(xa_parent_wid) { int sts; char *namep; int size; pwr_tAName title; *xa_sts = ldh_AttrRefToName( xa_ldhses, &objar, cdh_mNName, &namep, &size); if ( EVEN(*xa_sts)) return; strncpy( title, namep, sizeof(title)); toplevel = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW, "default-height", 420, "default-width", 600, "title", CoWowGtk::convert_utf8(title), NULL); g_signal_connect( toplevel, "delete_event", G_CALLBACK(delete_event), this); g_signal_connect( toplevel, "destroy", G_CALLBACK(destroy_event), this); g_signal_connect( toplevel, "focus-in-event", G_CALLBACK(action_inputfocus), this); CoWowGtk::SetWindowIcon( toplevel); GtkWidget *vbox = gtk_vbox_new( FALSE, 0); // Menu // Accelerators GtkAccelGroup *accel_g = (GtkAccelGroup *) g_object_new(GTK_TYPE_ACCEL_GROUP, NULL); gtk_window_add_accel_group(GTK_WINDOW(toplevel), accel_g); GtkMenuBar *menu_bar = (GtkMenuBar *) g_object_new(GTK_TYPE_MENU_BAR, NULL); // File entry GtkWidget *file_print = gtk_image_menu_item_new_from_stock(GTK_STOCK_PRINT, accel_g); g_signal_connect(file_print, "activate", G_CALLBACK(activate_print), this); GtkWidget *file_close = gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, accel_g); g_signal_connect(file_close, "activate", G_CALLBACK(activate_exit), this); GtkMenu *file_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL); gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_print); gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_close); GtkWidget *file = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_File")); gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file); gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), GTK_WIDGET(file_menu)); // Functions entry GtkWidget *functions_open_plc = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("Open _Program")); g_signal_connect( functions_open_plc, "activate", G_CALLBACK(activate_openplc), this); gtk_widget_add_accelerator( functions_open_plc, "activate", accel_g, 'l', GdkModifierType(GDK_CONTROL_MASK), GTK_ACCEL_VISIBLE); GtkMenu *func_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL); gtk_menu_shell_append(GTK_MENU_SHELL(func_menu), functions_open_plc); GtkWidget *functions = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Functions")); gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), functions); gtk_menu_item_set_submenu(GTK_MENU_ITEM(functions), GTK_WIDGET(func_menu)); // Help entry GtkWidget *help_help = gtk_image_menu_item_new_from_stock(GTK_STOCK_HELP, accel_g); g_signal_connect(help_help, "activate", G_CALLBACK(activate_help), this); GtkMenu *help_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL); gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_help); GtkWidget *help = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Help")); gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), help); gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), GTK_WIDGET(help_menu)); xcrrnav = new WAttNavGtk( (void *)this, wattnav_eType_CrossRef, vbox, "Plant", xa_ldhses, objar, 0, xa_advanced_user, 1, wb_eUtility_AttributeEditor, &brow_widget, &sts); // xcrrnav->popup_menu_cb = &xcrr_popup_menu_cb; // xcrrnav->start_trace_cb = &xcrr_start_trace_cb; // xcrrnav->close_cb = &xcrr_close_cb; gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(menu_bar), FALSE, FALSE, 0); gtk_box_pack_end( GTK_BOX(vbox), GTK_WIDGET(brow_widget), TRUE, TRUE, 0); gtk_container_add( GTK_CONTAINER(toplevel), vbox); gtk_widget_show_all( toplevel); *xa_sts = XATT__SUCCESS; }
GtkWidget * panel_context_menu_create (PanelWidget *panel) { GtkWidget *retval; GtkWidget *menuitem; GtkWidget *image; if (panel->master_widget) { gpointer *pointer; AppletInfo *info; pointer = g_object_get_data (G_OBJECT (panel->master_widget), "applet_info"); g_assert (pointer != NULL); info = (AppletInfo *) pointer; if (info->menu == NULL) { info->menu = mate_panel_applet_create_menu (info); } return info->menu; } retval = create_empty_menu (); gtk_widget_set_name (retval, "mate-panel-context-menu"); if (!panel_lockdown_get_locked_down ()) panel_context_menu_build_edition (panel, retval); menuitem = gtk_image_menu_item_new_with_mnemonic (_("_Help")); image = gtk_image_new_from_stock (GTK_STOCK_HELP, GTK_ICON_SIZE_MENU); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image); gtk_widget_show (menuitem); gtk_menu_shell_append (GTK_MENU_SHELL (retval), menuitem); g_signal_connect (menuitem, "activate", G_CALLBACK (panel_context_menu_show_help), NULL); menuitem = gtk_image_menu_item_new_with_mnemonic (_("A_bout Panels")); image = gtk_image_new_from_stock (GTK_STOCK_ABOUT, GTK_ICON_SIZE_MENU); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image); gtk_widget_show (menuitem); gtk_menu_shell_append (GTK_MENU_SHELL (retval), menuitem); g_signal_connect (menuitem, "activate", G_CALLBACK (panel_context_menu_show_about_dialog), NULL); //FIXME: can we get rid of this? (needed by menu_get_panel()) g_object_set_data (G_OBJECT (retval), "menu_panel", panel); /* Set up theme and transparency support */ #if GTK_CHECK_VERSION (3, 0, 0) GtkWidget *toplevel = gtk_widget_get_toplevel (retval); /* Fix any failures of compiz/other wm's to communicate with gtk for transparency */ GdkScreen *screen = gtk_widget_get_screen(GTK_WIDGET(toplevel)); GdkVisual *visual = gdk_screen_get_rgba_visual(screen); gtk_widget_set_visual(GTK_WIDGET(toplevel), visual); /* Set menu and it's toplevel window to follow panel theme */ GtkStyleContext *context; context = gtk_widget_get_style_context (GTK_WIDGET(toplevel)); gtk_style_context_add_class(context,"gnome-panel-menu-bar"); gtk_style_context_add_class(context,"mate-panel-menu-bar"); #endif return retval; }
static gint on_button_press_event (GtkWidget *widget, GdkEventButton *event, GtkamList *list) { GtkTreePath *path = NULL; GtkWidget *w; GtkamCamera *camera; CameraAbilities a; switch (event->button) { case 3: if (!gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (list), event->x, event->y, &path, NULL, NULL, NULL)) return (FALSE); gtk_tree_model_get_iter (GTK_TREE_MODEL (list->priv->store), &list->priv->iter, path); gtk_tree_path_free (path); camera = gtkam_list_get_camera_from_iter (list, &list->priv->iter); gp_camera_get_abilities (camera->camera, &a); /* What operations does the camera support? */ w = gtk_item_factory_get_widget (list->priv->factory, "/Delete"); gtk_widget_set_sensitive (w, (a.file_operations & GP_FILE_OPERATION_DELETE)); #ifdef HAVE_BONOBO { Bonobo_ServerInfoList *l; guint i; GtkWidget *item, *c; CORBA_Environment ev; CameraFileInfo finfo; gchar *fo, *fi, *query; ViewAsData *d; GList *cl; w = gtk_item_factory_get_widget (list->priv->factory, "/View with..."); c = gtk_item_factory_get_widget (list->priv->factory, "/View with.../Built-in viewer"); cl = gtk_container_get_children (GTK_CONTAINER (w)); for (i = 0; i < g_list_length (cl); i++) { if (g_list_nth_data (cl, i) != c) gtk_container_remove (GTK_CONTAINER (w), GTK_WIDGET (g_list_nth_data (cl, i))); } fo = gtkam_list_get_folder_from_iter (list, &list->priv->iter); fi = gtkam_list_get_name_from_iter (list, &list->priv->iter); gp_camera_file_get_info (camera->camera, fo, fi, &finfo, NULL); g_free (fo); g_free (fi); if (finfo.file.fields & GP_FILE_INFO_TYPE) { CORBA_exception_init (&ev); query = g_strconcat ("repo_ids.has ('IDL:Bonobo/Control:1.0') AND " "bonobo:supported_mime_types.has ('", finfo.file.type, "')", NULL); l = bonobo_activation_query (query, NULL, &ev); g_free (query); CORBA_exception_free (&ev); if (l && l->_length) { for (i = 0; i < l->_length; i++) { Bonobo_ServerInfo *si = &l->_buffer[i]; const gchar *n; if (!si->iid) continue; n = bonobo_server_info_prop_lookup (si, "name", NULL); if (!n) n = si->iid; item = gtk_menu_item_new_with_label (n); gtk_widget_show (item); gtk_menu_shell_append (GTK_MENU_SHELL (w), item); d = g_new0 (ViewAsData, 1); d->list = list; d->camera = camera; g_object_ref (G_OBJECT (d->camera)); d->folder = gtkam_list_get_folder_from_iter (list, &list->priv->iter); d->file = gtkam_list_get_name_from_iter (list, &list->priv->iter); d->iid = g_strdup (si->iid); g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (on_view_as_activate), d); g_signal_connect (G_OBJECT (item), "destroy", G_CALLBACK (on_menu_item_destroy), d); } } if (l) CORBA_free (l); } } #endif gtk_item_factory_popup (list->priv->factory, event->x_root, event->y_root, event->button, event->time); return (TRUE); default: return (FALSE); } }
GtkWidget *menu_create() { GtkWidget *menu, *menu_item, *file_menu, *edit_menu, *help_menu = NULL; menu = gtk_menu_bar_new(); /* BEGIN FILE MENU */ file_menu = gtk_menu_new(); menu_item = gtk_menu_item_new_with_mnemonic("_New"); gtk_menu_shell_append(GTK_MENU_SHELL(file_menu),menu_item); menu_item = gtk_menu_item_new_with_mnemonic("_Open"); gtk_menu_shell_append(GTK_MENU_SHELL(file_menu),menu_item); menu_item = gtk_menu_item_new_with_mnemonic("_Save"); gtk_menu_shell_append(GTK_MENU_SHELL(file_menu),menu_item); menu_item = gtk_menu_item_new_with_mnemonic("Save _As"); gtk_menu_shell_append(GTK_MENU_SHELL(file_menu),menu_item); menu_item = gtk_separator_menu_item_new(); gtk_menu_shell_append(GTK_MENU_SHELL(file_menu),menu_item); menu_item = gtk_menu_item_new_with_mnemonic("E_xit"); gtk_menu_shell_append(GTK_MENU_SHELL(file_menu),menu_item); /* END FILE MENU */ /* BEGIN EDIT MENU */ edit_menu = gtk_menu_new(); menu_item = gtk_menu_item_new_with_mnemonic("_Cup"); gtk_menu_shell_append(GTK_MENU_SHELL(edit_menu),menu_item); menu_item = gtk_menu_item_new_with_mnemonic("C_opy"); gtk_menu_shell_append(GTK_MENU_SHELL(edit_menu),menu_item); menu_item = gtk_menu_item_new_with_mnemonic("_Paste"); gtk_menu_shell_append(GTK_MENU_SHELL(edit_menu),menu_item); /* END EDIT MENU */ /* BEGIN HELP MENU */ help_menu = gtk_menu_new(); menu_item = gtk_menu_item_new_with_mnemonic("_Help"); gtk_menu_shell_append(GTK_MENU_SHELL(help_menu),menu_item); menu_item = gtk_menu_item_new_with_mnemonic("_About"); gtk_menu_shell_append(GTK_MENU_SHELL(help_menu),menu_item); g_signal_connect(G_OBJECT(menu_item),"activate",G_CALLBACK(about_show),NULL); /* END HELP MENU */ menu_item = gtk_menu_item_new_with_mnemonic("_File"); gtk_menu_shell_append(GTK_MENU_SHELL(menu),menu_item); gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item),file_menu); menu_item = gtk_menu_item_new_with_mnemonic("_Edit"); gtk_menu_shell_append(GTK_MENU_SHELL(menu),menu_item); gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item),edit_menu); menu_item = gtk_menu_item_new_with_mnemonic("_Help"); gtk_menu_shell_append(GTK_MENU_SHELL(menu),menu_item); gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item),help_menu); return menu; }
void ptk_menu_add_items_from_data( GtkWidget* menu, PtkMenuItemEntry* entries, gpointer cb_data, GtkAccelGroup* accel_group ) { PtkMenuItemEntry* ent; GtkWidget* menu_item = NULL; GtkWidget* sub_menu; GtkWidget* image; GSList* radio_group = NULL; const char* signal; for( ent = entries; ; ++ent ) { if( G_LIKELY( ent->label ) ) { /* Stock item */ signal = "activate"; if( G_UNLIKELY( PTK_IS_STOCK_ITEM(ent) ) ) { menu_item = gtk_image_menu_item_new_from_stock( ent->label, accel_group ); } else if( G_LIKELY(ent->stock_icon) ) { if( G_LIKELY( ent->stock_icon > (char *)2 ) ) { menu_item = gtk_image_menu_item_new_with_mnemonic(_(ent->label)); image = gtk_image_new_from_stock( ent->stock_icon, GTK_ICON_SIZE_MENU ); gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(menu_item), image ); } else if( G_UNLIKELY( PTK_IS_CHECK_MENU_ITEM(ent) ) ) { menu_item = gtk_check_menu_item_new_with_mnemonic(_(ent->label)); signal = "toggled"; } else if( G_UNLIKELY( PTK_IS_RADIO_MENU_ITEM(ent) ) ) { menu_item = gtk_radio_menu_item_new_with_mnemonic( radio_group, _(ent->label) ); if( G_LIKELY( PTK_IS_RADIO_MENU_ITEM( (ent + 1) ) ) ) radio_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(menu_item) ); else radio_group = NULL; signal = "toggled"; } } else { menu_item = gtk_menu_item_new_with_mnemonic(_(ent->label)); } if( G_LIKELY(accel_group) && ent->key ) { gtk_widget_add_accelerator (menu_item, "activate", accel_group, ent->key, ent->mod, GTK_ACCEL_VISIBLE); } if( G_LIKELY(ent->callback) ) { /* Callback */ g_signal_connect( menu_item, signal, ent->callback, cb_data); } if( G_UNLIKELY( ent->sub_menu ) ) { /* Sub menu */ sub_menu = ptk_menu_new_from_data( ent->sub_menu, cb_data, accel_group ); gtk_menu_item_set_submenu( GTK_MENU_ITEM(menu_item), sub_menu ); ent->menu = sub_menu; //MOD } } else { if( ! ent->stock_icon ) /* End of menu */ break; menu_item = gtk_separator_menu_item_new(); } gtk_menu_shell_append ( GTK_MENU_SHELL(menu), menu_item ); if( G_UNLIKELY(ent->ret) ) {// Return *ent->ret = menu_item; ent->ret = NULL; } } }
int main (int argc, char **argv) { GtkWidget *window; GtkWidget *vbox; GtkWidget *menubar; IgeMacMenuGroup *group; IgeMacDock *dock; GtkWidget *bbox; GtkWidget *button; gtk_init (&argc, &argv); dock = ige_mac_dock_get_default (); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size (GTK_WINDOW (window), 400, 300); g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); vbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), vbox); menubar = test_setup_menu (); gtk_box_pack_start (GTK_BOX (vbox), menubar, FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), gtk_label_new ("Some window content here"), FALSE, FALSE, 12); bbox = gtk_hbutton_box_new (); gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_CENTER); gtk_button_box_set_spacing (GTK_BUTTON_BOX (bbox), 12); gtk_box_pack_start (GTK_BOX (vbox), bbox, TRUE, TRUE, 0); button = gtk_button_new_with_label ("Bounce"); g_signal_connect (button, "clicked", G_CALLBACK (bounce_cb), dock); gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0); button = gtk_button_new_with_label ("Change Icon"); g_signal_connect (button, "clicked", G_CALLBACK (change_icon_cb), dock); gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0); button = gtk_button_new_with_label ("Change Menu"); g_signal_connect (button, "clicked", G_CALLBACK (change_menu_cb), NULL); gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0); gtk_widget_show_all (window); gtk_widget_hide (menubar); ige_mac_menu_set_menu_bar (GTK_MENU_SHELL (menubar)); ige_mac_menu_set_quit_menu_item (GTK_MENU_ITEM (quit_item)); group = ige_mac_menu_add_app_menu_group (); ige_mac_menu_add_app_menu_item (group, GTK_MENU_ITEM (about_item), NULL); group = ige_mac_menu_add_app_menu_group (); ige_mac_menu_add_app_menu_item (group, GTK_MENU_ITEM (preferences_item), NULL); dock = ige_mac_dock_new (); g_signal_connect (dock, "clicked", G_CALLBACK (dock_clicked_cb), window); g_signal_connect (dock, "quit-activate", G_CALLBACK (gtk_main_quit), window); gtk_main (); return 0; }
static void _context_menu_document(GHtml * ghtml, GtkWidget * menu) { GtkWidget * menuitem; GtkWidget * image; /* back */ menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_GO_BACK, NULL); if(!ghtml_can_go_back(ghtml->widget)) gtk_widget_set_sensitive(menuitem, FALSE); else g_signal_connect_swapped(menuitem, "activate", G_CALLBACK( surfer_go_back), ghtml->surfer); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); /* forward */ menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_GO_FORWARD, NULL); if(!ghtml_can_go_forward(ghtml->widget)) gtk_widget_set_sensitive(menuitem, FALSE); else g_signal_connect_swapped(menuitem, "activate", G_CALLBACK( surfer_go_forward), ghtml->surfer); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); /* refresh */ menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_REFRESH, NULL); g_signal_connect_swapped(menuitem, "activate", G_CALLBACK( surfer_refresh), ghtml->surfer); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); /* separator */ menuitem = gtk_separator_menu_item_new(); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); /* save page */ menuitem = gtk_image_menu_item_new_with_mnemonic( _("_Save page as...")); image = gtk_image_new_from_stock(GTK_STOCK_SAVE_AS, GTK_ICON_SIZE_MENU); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menuitem), image); g_signal_connect_swapped(menuitem, "activate", G_CALLBACK( surfer_save_dialog), ghtml->surfer); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); /* separator */ menuitem = gtk_separator_menu_item_new(); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); /* print */ menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_PRINT, NULL); g_signal_connect_swapped(menuitem, "activate", G_CALLBACK(surfer_print), ghtml->surfer); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); /* separator */ menuitem = gtk_separator_menu_item_new(); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); /* select all */ menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_SELECT_ALL, NULL); g_signal_connect_swapped(menuitem, "activate", G_CALLBACK( surfer_select_all), ghtml->surfer); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); /* separator */ menuitem = gtk_separator_menu_item_new(); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); /* view source */ menuitem = gtk_image_menu_item_new_with_mnemonic(_("View so_urce")); image = gtk_image_new_from_icon_name("surfer-view-html-source", GTK_ICON_SIZE_MENU); g_signal_connect_swapped(menuitem, "activate", G_CALLBACK( surfer_view_source), ghtml->surfer); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menuitem), image); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); #ifdef WITH_INSPECTOR /* inspect */ menuitem = gtk_image_menu_item_new_with_mnemonic( _("_Inspect this page")); g_signal_connect_swapped(menuitem, "activate", G_CALLBACK( _on_inspect_page), ghtml); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); #endif }
/* This is a _horrible_ hack to have this here. This needs to be added to the * GTK+ menuing code in some manner. */ static void drag_end_menu_cb (GtkWidget *widget, GdkDragContext *context) { GtkWidget *xgrab_shell; GtkWidget *parent; /* Find the last viewable ancestor, and make an X grab on it */ parent = gtk_widget_get_parent (widget); xgrab_shell = NULL; /* FIXME: workaround for a possible gtk+ bug * See bugs #92085(gtk+) and #91184(panel) for details. */ g_object_set (widget, "has-tooltip", TRUE, NULL); while (parent) { gboolean viewable = TRUE; GtkWidget *tmp = parent; while (tmp) { if (!gtk_widget_get_mapped (tmp)) { viewable = FALSE; break; } tmp = gtk_widget_get_parent (tmp); } if (viewable) xgrab_shell = parent; parent = gtk_menu_shell_get_parent_shell (GTK_MENU_SHELL (parent)); } if (xgrab_shell) { gboolean status; GdkDisplay *display; GdkDevice *pointer; GdkDevice *keyboard; GdkDeviceManager *device_manager; GdkWindow *window = gtk_widget_get_window (xgrab_shell); GdkCursor *cursor = gdk_cursor_new_for_display (gdk_display_get_default (), GDK_ARROW); display = gdk_window_get_display (window); device_manager = gdk_display_get_device_manager (display); pointer = gdk_device_manager_get_client_pointer (device_manager); keyboard = gdk_device_get_associated_device (pointer); /* FIXMEgpoo: Not sure if report to GDK_OWNERSHIP_WINDOW or GDK_OWNERSHIP_APPLICATION. Idem for the keyboard below */ status = gdk_device_grab (pointer, window, GDK_OWNERSHIP_WINDOW, TRUE, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_POINTER_MOTION_MASK, cursor, GDK_CURRENT_TIME); if (!status) { if (gdk_device_grab (keyboard, window, GDK_OWNERSHIP_WINDOW, TRUE, GDK_KEY_PRESS | GDK_KEY_RELEASE, NULL, GDK_CURRENT_TIME) == GDK_GRAB_SUCCESS) { /* FIXMEgpoo: We need either accessors or a workaround to grab the focus */ #if 0 GTK_MENU_SHELL (xgrab_shell)->GSEAL(have_xgrab) = TRUE; #endif } else { gdk_device_ungrab (pointer, GDK_CURRENT_TIME); } } g_object_unref (cursor); } }
GtkWidget *menu_create_main(void *accel_group, int bar, int away, int toplevel, GtkWidget **menu_widgets) { int i = 0; GtkWidget *item; GtkWidget *menu = 0; GtkWidget *menu_item = 0; GtkWidget *menu_bar; #if 0 GtkWidget *usermenu = 0; #endif GtkWidget *submenu = 0; int close_mask = GDK_CONTROL_MASK; int away_mask = GDK_MOD1_MASK; char *key_theme = NULL; GtkSettings *settings; GSList *group = NULL; if (bar) menu_bar = gtk_menu_bar_new(); else menu_bar = gtk_menu_new(); /* /MENU needs to know this later */ g_object_set_data(G_OBJECT(menu_bar), "accel", accel_group); #if GTK_CHECK_VERSION(2,4,0) g_signal_connect(G_OBJECT(menu_bar), "can-activate-accel", G_CALLBACK(menu_canacaccel), 0); #endif #if 0 /* set the initial state of toggles */ mymenu[MENUBAR_OFFSET].state = !prefs.hidemenu; mymenu[MENUBAR_OFFSET + 1].state = prefs.topicbar; mymenu[MENUBAR_OFFSET + 2].state = !prefs.hideuserlist; mymenu[MENUBAR_OFFSET + 3].state = prefs.userlistbuttons; mymenu[MENUBAR_OFFSET + 4].state = prefs.chanmodebuttons; mymenu[AWAY_OFFSET].state = away; #endif switch (tab_layout_config) { case 0: mymenu[TABS_OFFSET].state = 1; mymenu[TABS_OFFSET + 1].state = 0; break; default: mymenu[TABS_OFFSET].state = 0; mymenu[TABS_OFFSET + 1].state = 1; } /* change Close binding to ctrl-shift-w when using emacs keys */ settings = gtk_widget_get_settings(menu_bar); if (settings) { g_object_get(settings, "gtk-key-theme-name", &key_theme, NULL); if (key_theme) { if (!xstrcasecmp(key_theme, "Emacs")) { close_mask = GDK_SHIFT_MASK | GDK_CONTROL_MASK; mymenu[SEARCH_OFFSET].key = 0; } g_free(key_theme); } } /* Away binding to ctrl-alt-a if the _Help menu conflicts (FR/PT/IT) */ { char *help = _("_Help"); char *under = strchr(help, '_'); if (under && (under[1] == 'a' || under[1] == 'A')) away_mask = GDK_MOD1_MASK | GDK_CONTROL_MASK; } if (!toplevel) { mymenu[DETACH_OFFSET].text = N_("_Detach"); mymenu[CLOSE_OFFSET].text = N_("_Close"); } else { mymenu[DETACH_OFFSET].text = N_("_Attach"); mymenu[CLOSE_OFFSET].text = N_("_Close"); } while (1) { item = NULL; #if 0 if (mymenu[i].id == MENU_ID_USERMENU && !prefs.gui_usermenu) { i++; continue; } #endif switch (mymenu[i].type) { case M_NEWMENU: if (menu) gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item), menu); item = menu = gtk_menu_new(); #if 0 if (mymenu[i].id == MENU_ID_USERMENU) usermenu = menu; #endif menu_item = gtk_menu_item_new_with_mnemonic(_(mymenu[i].text)); /* record the English name for /menu */ g_object_set_data(G_OBJECT(menu_item), "name", mymenu[i].text); gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), menu_item); gtk_widget_show(menu_item); break; case M_MENUPIX: item = create_icon_menu(_(mymenu[i].text), mymenu[i].image, FALSE); goto normalitem; case M_MENUSTOCK: item = create_icon_menu(_(mymenu[i].text), mymenu[i].image, TRUE); goto normalitem; case M_MENUITEM: item = gtk_menu_item_new_with_mnemonic(_(mymenu[i].text)); normalitem: if (mymenu[i].key != 0) gtk_widget_add_accelerator(item, "activate", accel_group, mymenu[i].key, mymenu[i].key == GDK_F1 ? 0 : mymenu[i].key == GDK_w ? close_mask : GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); if (mymenu[i].callback) g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(mymenu[i].callback), 0); if (submenu) gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item); else gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); gtk_widget_show(item); break; case M_MENUTOG: item = gtk_check_menu_item_new_with_mnemonic(_(mymenu[i].text)); togitem: /* must avoid callback for Radio buttons */ GTK_CHECK_MENU_ITEM(item)->active = mymenu[i].state; /*gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), mymenu[i].state); */ #if 0 if (mymenu[i].key != 0) gtk_widget_add_accelerator(item, "activate", accel_group, mymenu[i].key, mymenu[i].id == MENU_ID_AWAY ? away_mask : GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); #endif if (mymenu[i].callback) g_signal_connect(G_OBJECT(item), "toggled", G_CALLBACK(mymenu[i].callback), 0); if (submenu) gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item); else gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); gtk_widget_show(item); gtk_widget_set_sensitive(item, mymenu[i].sensitive); break; case M_MENURADIO: item = gtk_radio_menu_item_new_with_mnemonic(group, _(mymenu[i].text)); group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item)); goto togitem; case M_SEP: item = gtk_menu_item_new(); gtk_widget_set_sensitive(item, FALSE); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); gtk_widget_show(item); break; case M_MENUSUB: group = NULL; submenu = gtk_menu_new(); item = create_icon_menu(_(mymenu[i].text), mymenu[i].image, TRUE); /* record the English name for /menu */ g_object_set_data(G_OBJECT(item), "name", mymenu[i].text); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); gtk_widget_show(item); break; /*case M_END: */ default: if (!submenu) { if (menu) { gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item), menu); menu_add_plugin_mainmenu_items(menu_bar); } #if 0 if (usermenu) usermenu_create(usermenu); #endif return (menu_bar); } submenu = NULL; } /* record this GtkWidget * so it's state might be changed later */ if (mymenu[i].id != 0 && menu_widgets) /* this ends up in sess->gui->menu_item[MENU_ID_XXX] */ menu_widgets[mymenu[i].id] = item; i++; } }
static gboolean _on_icon_button_press(GtkWidget * widget, GdkEventButton * event, gpointer data) { DesktopIcon * desktopicon = data; GtkWidget * menu; GtkWidget * menuitem; if(event->state & GDK_CONTROL_MASK) desktopicon_set_selected(desktopicon, !desktopicon_get_selected( desktopicon)); else { desktop_unselect_all(desktopicon->desktop); desktopicon_set_selected(desktopicon, TRUE); } /* single click open for applications */ if(desktopicon->path == NULL && event->type == GDK_BUTTON_PRESS && event->button == 1) { if(desktopicon->isexec == TRUE) _on_icon_run(desktopicon); else if(desktopicon->callback != NULL) _on_icon_open(desktopicon); return FALSE; } if(event->type == GDK_2BUTTON_PRESS && event->button == 1) { if(desktopicon->isexec == TRUE) /* XXX slightly ugly */ _on_icon_run(desktopicon); else _on_icon_open(desktopicon); return FALSE; } if(event->type != GDK_BUTTON_PRESS || event->button != 3) return FALSE; /* popup menu */ menu = gtk_menu_new(); if(desktopicon->isdir == TRUE) _popup_directory(menu, desktopicon); else if(desktopicon->callback != NULL) _popup_callback(menu, desktopicon); else _popup_file(menu, desktopicon); if(desktopicon->immutable == FALSE) { menuitem = gtk_separator_menu_item_new(); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_DELETE, NULL); g_signal_connect_swapped(G_OBJECT(menuitem), "activate", G_CALLBACK(_on_icon_delete), desktopicon); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); } if(desktopicon->path != NULL) { menuitem = gtk_separator_menu_item_new(); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); menuitem = gtk_image_menu_item_new_from_stock( GTK_STOCK_PROPERTIES, NULL); g_signal_connect_swapped(G_OBJECT(menuitem), "activate", G_CALLBACK(_on_icon_properties), desktopicon); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); } gtk_widget_show_all(menu); gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, 3, event->time); return TRUE; }
void key_dialog_show () { GtkWidget *vbox, *hbox, *list, *vbox2, *wid, *wid2, *wid3, *hbox2; struct key_binding *kb; gchar *titles[] = { NULL, NULL, NULL, "1", "2" }; char temp[32]; int i; titles[0] = _("Mod"); titles[1] = _("Key"); titles[2] = _("Action"); if (key_dialog) { mg_bring_tofront (key_dialog); return; } key_dialog = mg_create_generic_tab ("editkeys", _(DISPLAY_NAME": Keyboard Shortcuts"), TRUE, FALSE, key_dialog_close, NULL, 560, 330, &vbox, 0); hbox = gtk_hbox_new (0, 2); gtk_box_pack_start (GTK_BOX (vbox), hbox, 1, 1, 0); list = gtkutil_clist_new (5, titles, hbox, 0, key_dialog_sel_row, 0, NULL, 0, GTK_SELECTION_SINGLE); gtk_widget_set_usize (list, 400, 0); key_dialog_kb_clist = list; gtk_widget_show (hbox); kb = keys_root; gtk_clist_set_column_width (GTK_CLIST (list), 1, 50); gtk_clist_set_column_width (GTK_CLIST (list), 2, 120); gtk_clist_set_column_width (GTK_CLIST (list), 3, 50); gtk_clist_set_column_width (GTK_CLIST (list), 4, 50); while (kb) { titles[0] = key_make_mod_str (kb->mod, temp); titles[1] = kb->keyname; if (kb->action < 0 || kb->action > KEY_MAX_ACTIONS) titles[2] = _("<none>"); else titles[2] = key_actions[kb->action].name; if (kb->data1) titles[3] = kb->data1; else titles[3] = _("<none>"); if (kb->data2) titles[4] = kb->data2; else titles[4] = _("<none>"); gtk_clist_set_row_data (GTK_CLIST (list), gtk_clist_append (GTK_CLIST (list), titles), kb); kb = kb->next; } vbox2 = gtk_vbox_new (0, 2); gtk_box_pack_end (GTK_BOX (hbox), vbox2, 1, 1, 0); wid = gtk_button_new_with_label (_("Add New")); gtk_box_pack_start (GTK_BOX (vbox2), wid, 0, 0, 0); gtk_signal_connect (GTK_OBJECT (wid), "clicked", GTK_SIGNAL_FUNC (key_dialog_add_new), list); gtk_widget_show (wid); wid = gtk_button_new_with_label (_("Delete")); gtk_box_pack_start (GTK_BOX (vbox2), wid, 0, 0, 0); gtk_signal_connect (GTK_OBJECT (wid), "clicked", GTK_SIGNAL_FUNC (key_dialog_delete), list); gtk_widget_show (wid); gtk_widget_show (vbox2); wid = gtk_option_menu_new (); wid2 = gtk_menu_new (); for (i = 0; i <= KEY_MAX_ACTIONS; i++) { wid3 = gtk_menu_item_new_with_label (_(key_actions[i].name)); gtk_widget_show (wid3); gtk_menu_shell_append (GTK_MENU_SHELL (wid2), wid3); gtk_signal_connect (GTK_OBJECT (wid3), "activate", GTK_SIGNAL_FUNC (key_dialog_sel_act), GINT_TO_POINTER (i)); } gtk_option_menu_set_menu (GTK_OPTION_MENU (wid), wid2); gtk_option_menu_set_history (GTK_OPTION_MENU (wid), 0); gtk_box_pack_end (GTK_BOX (vbox2), wid, 0, 0, 0); gtk_widget_show (wid); key_dialog_act_menu = wid; key_dialog_tog_s = key_dialog_make_toggle (_("Shift"), key_dialog_tog_key, (void *) STATE_SHIFT, vbox2); key_dialog_tog_a = key_dialog_make_toggle (_("Alt"), key_dialog_tog_key, (void *) STATE_ALT, vbox2); key_dialog_tog_c = key_dialog_make_toggle (_("Ctrl"), key_dialog_tog_key, (void *) STATE_CTRL, vbox2); key_dialog_ent_key = key_dialog_make_entry (_("Key"), "key_press_event", key_dialog_set_key, NULL, vbox2); key_dialog_ent_d1 = key_dialog_make_entry (_("Data 1"), "activate", key_dialog_set_data, NULL, vbox2); key_dialog_ent_d2 = key_dialog_make_entry (_("Data 2"), "activate", key_dialog_set_data, (void *) 1, vbox2); hbox2 = gtk_hbox_new (0, 2); gtk_box_pack_end (GTK_BOX (vbox), hbox2, 0, 0, 1); wid = gtk_xtext_new (colors, 0); gtk_xtext_set_tint (GTK_XTEXT (wid), prefs.tint_red, prefs.tint_green, prefs.tint_blue); gtk_xtext_set_background (GTK_XTEXT (wid), channelwin_pix, prefs.transparent); gtk_widget_set_usize (wid, 0, 75); gtk_box_pack_start (GTK_BOX (hbox2), wid, 1, 1, 1); gtk_xtext_set_font (GTK_XTEXT (wid), prefs.font_normal); gtk_widget_show (wid); wid2 = gtk_vscrollbar_new (GTK_XTEXT (wid)->adj); gtk_box_pack_start (GTK_BOX (hbox2), wid2, 0, 0, 0); gtk_widget_show (wid2); gtk_widget_show (hbox2); key_dialog_text = wid; gtk_widget_show_all (key_dialog); }
static void dt_gui_presets_popup_menu_show_internal(dt_dev_operation_t op, int32_t version, dt_iop_params_t *params, int32_t params_size, dt_develop_blend_params_t *bl_params, dt_iop_module_t *module, const dt_image_t *image, void (*pick_callback)(GtkMenuItem *, void *), void *callback_data) { GtkMenu *menu = darktable.gui->presets_popup_menu; if(menu) gtk_widget_destroy(GTK_WIDGET(menu)); darktable.gui->presets_popup_menu = GTK_MENU(gtk_menu_new()); menu = darktable.gui->presets_popup_menu; GtkWidget *mi; int active_preset = -1, cnt = 0, writeprotect = 0; //, selected_default = 0; sqlite3_stmt *stmt; // order: get shipped defaults first if(image) { // only matching if filter is on: DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "select name, op_params, writeprotect, description, blendop_params, " "op_version, enabled from presets where operation=?1 and " "(filter=0 or ( " "((?2 like model and ?3 like maker) or (?4 like model and ?5 like maker)) and " "?6 like lens and " "?7 between iso_min and iso_max and " "?8 between exposure_min and exposure_max and " "?9 between aperture_min and aperture_max and " "?10 between focal_length_min and focal_length_max and " "(format = 0 or format&?9!=0)" " ) )" "order by writeprotect desc, lower(name), rowid", -1, &stmt, NULL); DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, op, -1, SQLITE_TRANSIENT); DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, image->exif_model, -1, SQLITE_TRANSIENT); DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 3, image->exif_maker, -1, SQLITE_TRANSIENT); DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 4, image->camera_alias, -1, SQLITE_TRANSIENT); DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 5, image->camera_maker, -1, SQLITE_TRANSIENT); DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 6, image->exif_lens, -1, SQLITE_TRANSIENT); DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 7, image->exif_iso); DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 8, image->exif_exposure); DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 9, image->exif_aperture); DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 10, image->exif_focal_length); int ldr = dt_image_is_ldr(image) ? FOR_LDR : (dt_image_is_raw(image) ? FOR_RAW : FOR_HDR); DT_DEBUG_SQLITE3_BIND_INT(stmt, 9, ldr); } else { // don't know for which image. show all we got: DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "select name, op_params, writeprotect, " "description, blendop_params, op_version, " "enabled from presets where operation=?1 " "order by writeprotect desc, lower(name), rowid", -1, &stmt, NULL); DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, op, -1, SQLITE_TRANSIENT); } // collect all presets for op from db int found = 0; while(sqlite3_step(stmt) == SQLITE_ROW) { void *op_params = (void *)sqlite3_column_blob(stmt, 1); int32_t op_params_size = sqlite3_column_bytes(stmt, 1); void *blendop_params = (void *)sqlite3_column_blob(stmt, 4); int32_t bl_params_size = sqlite3_column_bytes(stmt, 4); int32_t preset_version = sqlite3_column_int(stmt, 5); int32_t enabled = sqlite3_column_int(stmt, 6); int32_t isdefault = 0; int32_t isdisabled = (preset_version == version ? 0 : 1); const char *name = (char *)sqlite3_column_text(stmt, 0); if(darktable.gui->last_preset && strcmp(darktable.gui->last_preset, name) == 0) found = 1; if(module && !memcmp(module->default_params, op_params, MIN(op_params_size, module->params_size)) && !memcmp(module->default_blendop_params, blendop_params, MIN(bl_params_size, sizeof(dt_develop_blend_params_t)))) isdefault = 1; if(module && !memcmp(params, op_params, MIN(op_params_size, params_size)) && !memcmp(bl_params, blendop_params, MIN(bl_params_size, sizeof(dt_develop_blend_params_t))) && module->enabled == enabled) { active_preset = cnt; writeprotect = sqlite3_column_int(stmt, 2); char *markup; mi = gtk_menu_item_new_with_label(""); if(isdefault) { markup = g_markup_printf_escaped("<span weight=\"bold\">%s %s</span>", name, _("(default)")); } else markup = g_markup_printf_escaped("<span weight=\"bold\">%s</span>", name); gtk_label_set_markup(GTK_LABEL(gtk_bin_get_child(GTK_BIN(mi))), markup); g_free(markup); } else { if(isdefault) { char *markup; mi = gtk_menu_item_new_with_label(""); markup = g_markup_printf_escaped("%s %s", name, _("(default)")); gtk_label_set_markup(GTK_LABEL(gtk_bin_get_child(GTK_BIN(mi))), markup); g_free(markup); } else mi = gtk_menu_item_new_with_label((const char *)name); } if(isdisabled) { gtk_widget_set_sensitive(mi, 0); gtk_widget_set_tooltip_text(mi, _("disabled: wrong module version")); } else { if(module) g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menuitem_pick_preset), module); else if(pick_callback) g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(pick_callback), callback_data); gtk_widget_set_tooltip_text(mi, (const char *)sqlite3_column_text(stmt, 3)); } gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi); cnt++; } sqlite3_finalize(stmt); if(cnt > 0) gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new()); if(module) { if(active_preset >= 0 && !writeprotect) { mi = gtk_menu_item_new_with_label(_("edit this preset..")); g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menuitem_edit_preset), module); gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi); mi = gtk_menu_item_new_with_label(_("delete this preset")); g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menuitem_delete_preset), module); gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi); } else { mi = gtk_menu_item_new_with_label(_("store new preset..")); g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menuitem_new_preset), module); gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi); if(darktable.gui->last_preset && found) { char *markup = g_markup_printf_escaped("%s <span weight=\"bold\">%s</span>", _("update preset"), darktable.gui->last_preset); mi = gtk_menu_item_new_with_label(""); gtk_label_set_markup(GTK_LABEL(gtk_bin_get_child(GTK_BIN(mi))), markup); g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menuitem_update_preset), module); gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi); g_free(markup); } } } }
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); }