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_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_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_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_label (GTK_TOOL_BUTTON (item), "Bold"); 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_label (GTK_TOOL_BUTTON (item), "Left"); 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_label (GTK_TOOL_BUTTON (item), "Center"); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-justify-center"); 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_label (GTK_TOOL_BUTTON (item), "Right"); 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); 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; }
WVselGtk::WVselGtk ( pwr_tStatus *status, void *wv_parent_ctx, GtkWidget *wv_parent_wid, const char *wv_name, ldh_tWBContext wv_wbctx, char *volumename, int (*bc_success)( void *, pwr_tVolumeId *, int), void (*bc_cancel)(), int (*bc_time_to_exit)( void *), int show_volumes, wb_eType wv_wb_type) : WVsel(status,wv_parent_ctx,wv_name,wv_wbctx,volumename,bc_success,bc_cancel, bc_time_to_exit,show_volumes,wv_wb_type), parent_wid(wv_parent_wid) { int sts; pwr_tVolumeId volid, *volume_ptr; pwr_tVolumeId volume; pwr_tClassId classid; char volname[80]; int size; int volume_count; int display_window; GtkCellRenderer *text_renderer; GtkTreeViewColumn *name_column; strcpy( volname, ""); if ( volumename != NULL && *volumename != 0 && !show_volumes) /* Start the navigater for this volume */ strcpy( volname, volumename); else if ( !show_volumes && wb_type != wb_eType_Buffer) { /* If there is only one volume in the db, select this volume */ volume_count = 0; sts = ldh_GetVolumeList( wbctx, &volume); while ( ODD(sts) ) { sts = ldh_GetVolumeClass( wbctx, volume, &classid); if (EVEN(sts)) { *status = sts; return; } if ( cdh_isClassVolumeClass( classid) || classid == pwr_eClass_WorkBenchVolume || volume == ldh_cRtVolume) { sts = ldh_GetNextVolume( wbctx, volume, &volume); continue; } sts = ldh_VolumeIdToName( wbctx, volume, volname, sizeof(volname), &size); if (EVEN(sts)) { *status = sts; return; } volume_count++; sts = ldh_GetNextVolume( wbctx, volume, &volume); } if ( volume_count != 1) strcpy( volname, ""); } // If volume name is supplied, find this volume and open the navigator. if ( strcmp( volname, "") && wb_type != wb_eType_Buffer) /* Check syntax, if new volumes is found, show the window */ sts = check_volumelist( 1, &display_window); if ( strcmp( volname, "") && !display_window) { sts = ldh_VolumeNameToId( wbctx, volname, &volid); WFoe::error_msg(sts); if ( ODD(sts)) { volume_ptr = (pwr_tVolumeId *) calloc( 1, sizeof( pwr_tVolumeId)); *volume_ptr = volid; (vsel_bc_success) ( (void *)this, volume_ptr, 1); if (vsel_bc_cancel != NULL) (vsel_bc_cancel) (); *status = LOGIN__SUCCESS; return; } else printf( "-- Unable to open volume '%s', volume doesn't exist\n", volname); } // Create the window widgets.toplevel = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW, "default-height", 400, "default-width", 500, "title", name, NULL); CoWowGtk::SetWindowIcon( widgets.toplevel); // Menu GtkAccelGroup *accel_g = (GtkAccelGroup *) g_object_new(GTK_TYPE_ACCEL_GROUP, NULL); gtk_window_add_accel_group(GTK_WINDOW(widgets.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(WVselGtk::activate_close), 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)); // Functions Entry GtkWidget *functions_showall = gtk_check_menu_item_new_with_mnemonic( "_Show All Volumes"); g_signal_connect( functions_showall, "activate", G_CALLBACK(WVselGtk::activate_showall), this); gtk_widget_add_accelerator( functions_showall, "activate", accel_g, 'a', GdkModifierType(GDK_CONTROL_MASK), GTK_ACCEL_VISIBLE); GtkMenu *functions_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL); gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_showall); 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)); // List widget store = gtk_list_store_new( 1, G_TYPE_STRING); widgets.volumelist = (GtkWidget *) g_object_new(GTK_TYPE_TREE_VIEW, "model", store, "rules-hint", TRUE, "headers-visible", FALSE, "reorderable", TRUE, "enable-search", TRUE, "search-column", 0, NULL); text_renderer = gtk_cell_renderer_text_new(); name_column = gtk_tree_view_column_new_with_attributes( NULL, text_renderer, "text", 0, NULL); g_object_set( name_column, "resizable", TRUE, "clickable", TRUE, NULL); gtk_tree_view_append_column( GTK_TREE_VIEW(widgets.volumelist), name_column); GtkWidget *ok_button = gtk_button_new_with_label( "Ok"); gtk_widget_set_size_request( ok_button, 70, 25); g_signal_connect( ok_button, "clicked", G_CALLBACK(activate_ok), this); GtkWidget *cancel_button = gtk_button_new_with_label( "Cancel"); gtk_widget_set_size_request( cancel_button, 70, 25); g_signal_connect( cancel_button, "clicked", G_CALLBACK(activate_cancel), this); GtkWidget *hboxbuttons = gtk_hbox_new( TRUE, 40); gtk_box_pack_start( GTK_BOX(hboxbuttons), ok_button, FALSE, FALSE, 20); gtk_box_pack_end( GTK_BOX(hboxbuttons), cancel_button, FALSE, FALSE, 20); GtkWidget *scrolled_window = gtk_scrolled_window_new( NULL, NULL); gtk_container_add( GTK_CONTAINER( scrolled_window), widgets.volumelist); 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), scrolled_window, TRUE, TRUE, 0); gtk_box_pack_end( GTK_BOX(vbox), hboxbuttons, FALSE, FALSE, 10); gtk_container_add( GTK_CONTAINER(widgets.toplevel), vbox); gtk_widget_show_all( widgets.toplevel); // GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(widgets.volumelist)); // gtk_tree_selection_set_mode( selection, GTK_SELECTION_SINGLE); sts = load_volumelist(); WFoe::error_msg(sts); // Set input focus to the scrolled list widget gtk_widget_grab_focus( widgets.volumelist); wow = new CoWowGtk( widgets.toplevel); if ( wb_type != wb_eType_Buffer) sts = check_volumelist( 0, &display_window); *status = LOGIN__SUCCESS; }
static void tree_menu (void) { GtkWidget *window, *widget; GtkWidget *menubar, *vbox; GtkCellArea *area; GtkTreeModel *store; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "GtkTreeMenu"); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4); gtk_widget_show (vbox); menubar = gtk_menu_bar_new (); gtk_widget_show (menubar); store = simple_tree_model (); area = create_cell_area (); #if _GTK_TREE_MENU_WAS_A_PUBLIC_CLASS_ menuitem = gtk_menu_item_new_with_label ("Grid"); menu = create_menu_grid_demo (); gtk_widget_show (menu); gtk_widget_show (menuitem); gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu); menuitem = gtk_menu_item_new_with_label ("Tree"); menu = simple_tree_menu (); gtk_widget_show (menu); gtk_widget_show (menuitem); gtk_menu_shell_prepend (GTK_MENU_SHELL (menubar), menuitem); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu); g_signal_connect (menu, "menu-activate", G_CALLBACK (menu_activated_cb), NULL); gtk_box_pack_start (GTK_BOX (vbox), menubar, FALSE, FALSE, 0); #endif /* Add a combo box with the same menu ! */ widget = gtk_combo_box_new_with_area (area); gtk_combo_box_set_model (GTK_COMBO_BOX (widget), store); gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0); gtk_widget_show (widget); gtk_box_pack_end (GTK_BOX (vbox), widget, FALSE, FALSE, 0); /* Now add some controls */ widget = gtk_combo_box_text_new (); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Horizontal"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Vertical"); gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (widget), "changed", G_CALLBACK (orientation_changed), area); widget = gtk_check_button_new_with_label ("Align 2nd Cell"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (widget), "toggled", G_CALLBACK (align_cell_2_toggled), area); widget = gtk_check_button_new_with_label ("Align 3rd Cell"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (widget), "toggled", G_CALLBACK (align_cell_3_toggled), area); widget = gtk_check_button_new_with_label ("Expand 1st Cell"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (widget), "toggled", G_CALLBACK (expand_cell_1_toggled), area); widget = gtk_check_button_new_with_label ("Expand 2nd Cell"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (widget), "toggled", G_CALLBACK (expand_cell_2_toggled), area); widget = gtk_check_button_new_with_label ("Expand 3rd Cell"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (widget), "toggled", G_CALLBACK (expand_cell_3_toggled), area); #if _GTK_TREE_MENU_WAS_A_PUBLIC_CLASS_ widget = gtk_check_button_new_with_label ("Submenu Headers"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (widget), "toggled", G_CALLBACK (submenu_headers_toggled), menu); widget = gtk_check_button_new_with_label ("Tearoff menu"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (widget), "toggled", G_CALLBACK (tearoff_toggled), menu); #endif gtk_container_add (GTK_CONTAINER (window), vbox); gtk_widget_show (window); }
static GtkWidget * glade_popup_create_menu (GladeWidget *widget, GladePlaceholder *placeholder, GladeProject *project, gboolean packing) { GtkWidget *popup_menu; GtkWidget *separator; gboolean sensitive; GladeWidgetAdaptor *adaptor; popup_menu = gtk_menu_new (); adaptor = glade_project_get_add_item (project); if (adaptor) { RootAddData *data = g_new (RootAddData, 1); data->adaptor = adaptor; data->project = project; data->parent = placeholder ? glade_placeholder_get_parent (placeholder) : widget; data->placeholder = placeholder; g_object_set_data_full (G_OBJECT (popup_menu), "root-data-destroy-me", data, (GDestroyNotify)g_free); glade_popup_append_item (popup_menu, _("_Add widget here"), data->parent != NULL, glade_popup_widget_add_cb, data); glade_popup_append_item (popup_menu, _("Add widget as _toplevel"), TRUE, glade_popup_root_add_cb, data); separator = gtk_separator_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), separator); gtk_widget_show (separator); } sensitive = (widget != NULL); glade_popup_append_item (popup_menu, _("_Select"), sensitive, glade_popup_select_cb, widget); glade_popup_append_item (popup_menu, _("Cu_t"), sensitive, glade_popup_cut_cb, widget); glade_popup_append_item (popup_menu, _("_Copy"), sensitive, glade_popup_copy_cb, widget); /* paste is placholder specific when the popup is on a placeholder */ sensitive = glade_clipboard_get_has_selection (glade_app_get_clipboard ()); if (placeholder) glade_popup_append_item (popup_menu, _("_Paste"), sensitive, glade_popup_placeholder_paste_cb, placeholder); else if (widget) glade_popup_append_item (popup_menu, _("_Paste"), sensitive, glade_popup_paste_cb, widget); else glade_popup_append_item (popup_menu, _("_Paste"), sensitive, glade_popup_paste_cb, NULL); glade_popup_append_item (popup_menu, _("_Delete"), (widget != NULL), glade_popup_delete_cb, widget); /* packing actions are a little different on placholders */ if (placeholder) { if (widget && glade_widget_get_actions (widget)) { GtkWidget *separator = gtk_separator_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), separator); gtk_widget_show (separator); glade_popup_action_populate_menu_real (popup_menu, widget, glade_widget_get_actions (widget), G_CALLBACK (glade_popup_menuitem_activated), widget); } if (glade_placeholder_packing_actions (placeholder)) { GtkWidget *separator = gtk_separator_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), separator); gtk_widget_show (separator); glade_popup_action_populate_menu_real (popup_menu, widget, glade_placeholder_packing_actions (placeholder), G_CALLBACK (glade_popup_menuitem_ph_packing_activated), placeholder); } } else if (widget && (glade_widget_get_actions (widget) || (packing && glade_widget_get_pack_actions (widget)))) { GtkWidget *separator = gtk_separator_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), separator); gtk_widget_show (separator); glade_popup_action_populate_menu (popup_menu, widget, NULL, packing); } return popup_menu; }
int main( int argc, char *argv[]) { GtkWidget *window; GtkWidget *vbox; GtkWidget *menubar; GtkWidget *filemenu, *item_file, *item_new, *item_open,*item_quit; GtkWidget *editmenu, *item_edit, *item_undo, *item_redo, *item_cut, *item_copy, *item_paste; GtkWidget *sep; GtkAccelGroup *accel_group = NULL; //定义快捷键组 gtk_init(&argc, &argv); window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); gtk_window_set_default_size(GTK_WINDOW(window), 250, 200); gtk_window_set_title(GTK_WINDOW(window), "menu better"); vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(window), vbox); menubar = gtk_menu_bar_new(); //菜单栏构件(menubar),实际上是一个menu shell filemenu = gtk_menu_new(); //菜单构件(menu),也是一个menu shell accel_group = gtk_accel_group_new(); gtk_window_add_accel_group(GTK_WINDOW(window), accel_group); item_file = gtk_menu_item_new_with_mnemonic("_File"); //替代 gtk_menu_item_new_with_label("File"); item_new = gtk_image_menu_item_new_from_stock(GTK_STOCK_NEW, NULL); //替代gtk_menu_item_new_with_label("New"); item_open = gtk_image_menu_item_new_from_stock(GTK_STOCK_OPEN, NULL);//替代gtk_menu_item_new_with_label("Open"); sep = gtk_separator_menu_item_new(); //生成一条分割线 item_quit = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT,accel_group);//替代gtk_menu_item_new_with_label("Quit"); gtk_widget_add_accelerator(item_quit, "activate", accel_group, GDK_q,GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_file), filemenu); gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), item_new); gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), item_open); gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), sep); //加入分割线到file菜单中 gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), item_quit); //把“quit”菜单选项被填加进file菜单中 gtk_menu_shell_append(GTK_MENU_SHELL(menubar), item_file); //把“file”菜单选项被填加进菜单中(menubar) /*这里构建Edit菜单,同上面的file菜单添加方法一样*/ editmenu = gtk_menu_new(); //菜单构件(menu),也是一个menu shell item_edit = gtk_menu_item_new_with_mnemonic("_Edit"); item_undo = gtk_image_menu_item_new_from_stock(GTK_STOCK_UNDO, NULL); item_redo = gtk_image_menu_item_new_from_stock(GTK_STOCK_REDO, NULL); sep = gtk_separator_menu_item_new(); item_cut = gtk_image_menu_item_new_from_stock(GTK_STOCK_CUT, NULL); item_copy = gtk_image_menu_item_new_from_stock(GTK_STOCK_COPY, NULL); item_paste = gtk_image_menu_item_new_from_stock(GTK_STOCK_PASTE, NULL); gtk_widget_add_accelerator(item_undo, "activate", accel_group, GDK_z,GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator(item_redo, "activate", accel_group, GDK_r,GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator(item_cut, "activate", accel_group, GDK_x,GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator(item_copy, "activate", accel_group, GDK_c,GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator(item_paste, "activate", accel_group, GDK_v,GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_edit), editmenu); gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), item_undo); gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), item_redo); gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), sep); gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), item_cut); gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), item_copy); gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), item_paste); gtk_menu_shell_append(GTK_MENU_SHELL(menubar), item_edit); //把“edit”菜单选项被填加进菜单中(menubar) /*这里把窗口分为了上中下3个区域,最上面是menubar*/ gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 3); g_signal_connect(G_OBJECT(item_quit), "activate",G_CALLBACK(gtk_main_quit), NULL); gtk_widget_show_all(window); gtk_main(); return 0; }
static void wnck_selector_insert_window (WnckSelector *selector, WnckWindow *window) { GtkWidget *item; WnckScreen *screen; WnckWorkspace *workspace; int workspace_n; int i; screen = wnck_selector_get_screen (selector); workspace = wnck_window_get_workspace (window); if (!workspace && !wnck_window_is_pinned (window)) return; item = wnck_selector_create_window (selector, window); if (!workspace || workspace == wnck_screen_get_active_workspace (screen)) { /* window is pinned or in the current workspace * => insert before the separator */ GList *l, *children; i = 0; children = gtk_container_get_children (GTK_CONTAINER (selector->priv->menu)); for (l = children; l; l = l->next) { if (GTK_IS_SEPARATOR_MENU_ITEM (l->data)) break; i++; } g_list_free (children); gtk_menu_shell_insert (GTK_MENU_SHELL (selector->priv->menu), item, i); } else { workspace_n = wnck_workspace_get_number (workspace); if (workspace_n == wnck_screen_get_workspace_count (screen) - 1) /* window is in last workspace => just append */ gtk_menu_shell_append (GTK_MENU_SHELL (selector->priv->menu), item); else { /* insert just before the next workspace item */ GList *l, *children; i = 0; children = gtk_container_get_children (GTK_CONTAINER (selector->priv->menu)); for (l = children; l; l = l->next) { int j; j = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (l->data), "wnck-selector-workspace-n")); if (j - 1 == workspace_n + 1) break; i++; } g_list_free (children); gtk_menu_shell_insert (GTK_MENU_SHELL (selector->priv->menu), item, i); } } }
static void remmina_icon_populate_extra_menu_item (GtkWidget *menu) { GtkWidget *menuitem; gboolean new_ontop; GHashTableIter iter; gchar *tmp; gint n; new_ontop = remmina_pref.applet_new_ontop; /* Iterate all discovered services from Avahi */ if (remmina_icon.avahi) { g_hash_table_iter_init (&iter, remmina_icon.avahi->discovered_services); while (g_hash_table_iter_next (&iter, NULL, (gpointer*) &tmp)) { menuitem = remmina_applet_menu_item_new (REMMINA_APPLET_MENU_ITEM_DISCOVERED, tmp); gtk_widget_show (menuitem); remmina_applet_menu_add_item ( REMMINA_APPLET_MENU (menu), REMMINA_APPLET_MENU_ITEM (menuitem)); } } /* Separator */ menuitem = gtk_separator_menu_item_new (); gtk_widget_show (menuitem); if (new_ontop) { gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menuitem); } else { gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); } /* New Connection */ menuitem = remmina_applet_menu_item_new (REMMINA_APPLET_MENU_ITEM_NEW); gtk_widget_show (menuitem); remmina_applet_menu_register_item ( REMMINA_APPLET_MENU (menu), REMMINA_APPLET_MENU_ITEM (menuitem)); if (new_ontop) { gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menuitem); } else { gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); } /* Existing window */ if (remmina_pref.minimize_to_tray) { n = remmina_widget_pool_foreach (remmina_icon_foreach_window, menu); if (n > 0) { /* Separator */ menuitem = gtk_separator_menu_item_new (); gtk_widget_show (menuitem); gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, n); } } g_signal_connect (G_OBJECT (menu), "launch-item", G_CALLBACK (remmina_icon_on_launch_item), NULL); g_signal_connect (G_OBJECT (menu), "edit-item", G_CALLBACK (remmina_icon_on_edit_item), NULL); }
/* * This function inherit from gnome-menus/util/test-menu-spec.c */ static void traverse_directory(GMenuTreeDirectory *dir, GtkWidget *parent) { GMenuTreeIter *iter = NULL; GtkWidget *dir_submenu = parent ? gtk_menu_new() : NULL; GtkWidget *entry_submenu = gtk_menu_new(); GIcon *icon = NULL; const char *text = NULL; GtkWidget *menuitem = NULL; iter = gmenu_tree_directory_iter(dir); while (TRUE) { gpointer item = NULL; switch (gmenu_tree_iter_next(iter)) { case GMENU_TREE_ITEM_INVALID: goto done; case GMENU_TREE_ITEM_ENTRY: item = gmenu_tree_iter_get_entry(iter); GDesktopAppInfo *appinfo = gmenu_tree_entry_get_app_info((GMenuTreeEntry *)item); icon = g_app_info_get_icon((GAppInfo *)appinfo); text = g_app_info_get_display_name((GAppInfo *)appinfo); menuitem = menu_item_new_with_icon_text(icon, text); gtk_menu_shell_append(GTK_MENU_SHELL(entry_submenu), menuitem); g_object_connect(G_OBJECT(menuitem), "signal::activate", G_CALLBACK(menu_item_activate), appinfo, NULL); break; case GMENU_TREE_ITEM_DIRECTORY: item = gmenu_tree_iter_get_directory(iter); icon = gmenu_tree_directory_get_icon((GMenuTreeDirectory *)item); text = gmenu_tree_directory_get_name((GMenuTreeDirectory *)item); menuitem = menu_item_new_with_icon_text(icon, text); gtk_menu_shell_append(dir_submenu ? GTK_MENU_SHELL(dir_submenu) : GTK_MENU_SHELL(popup), menuitem); traverse_directory(item, menuitem); break; } if (item) { gmenu_tree_item_unref(item); item = NULL; } continue; done: break; } if (parent) { if (dir_submenu) gtk_menu_item_set_submenu(GTK_MENU_ITEM(parent), dir_submenu); gtk_menu_item_set_submenu(GTK_MENU_ITEM(parent), entry_submenu); } if (iter) { gmenu_tree_iter_unref(iter); iter = NULL; } }
void on_trayicon_activate (GtkStatusIcon *status_icon, gpointer user_data) { GromitData *data = (GromitData *) user_data; if(data->debug) g_printerr("DEBUG: trayicon activated\n"); /* create the menu */ GtkWidget *menu = gtk_menu_new (); /* Create the menu items */ GtkWidget* toggle_paint_item = gtk_image_menu_item_new_with_label ("Toggle Painting"); GtkWidget* clear_item = gtk_image_menu_item_new_with_label ("Clear Screen"); GtkWidget* toggle_vis_item = gtk_image_menu_item_new_with_label ("Toggle Visibility"); GtkWidget* thicker_lines_item = gtk_image_menu_item_new_with_label ("Thicker Lines"); GtkWidget* thinner_lines_item = gtk_image_menu_item_new_with_label ("Thinner Lines"); GtkWidget* opacity_bigger_item = gtk_image_menu_item_new_with_label ("Bigger Opacity"); GtkWidget* opacity_lesser_item = gtk_image_menu_item_new_with_label ("Lesser Opacity"); GtkWidget* undo_item = gtk_image_menu_item_new_with_label ("Undo"); GtkWidget* redo_item = gtk_image_menu_item_new_with_label ("Redo"); /* Add them to the menu */ gtk_menu_shell_append (GTK_MENU_SHELL (menu), toggle_paint_item); gtk_menu_shell_append (GTK_MENU_SHELL (menu), clear_item); gtk_menu_shell_append (GTK_MENU_SHELL (menu), toggle_vis_item); gtk_menu_shell_append (GTK_MENU_SHELL (menu), thicker_lines_item); gtk_menu_shell_append (GTK_MENU_SHELL (menu), thinner_lines_item); gtk_menu_shell_append (GTK_MENU_SHELL (menu), opacity_bigger_item); gtk_menu_shell_append (GTK_MENU_SHELL (menu), opacity_lesser_item); gtk_menu_shell_append (GTK_MENU_SHELL (menu), undo_item); gtk_menu_shell_append (GTK_MENU_SHELL (menu), redo_item); /* Attach the callback functions to the respective activate signal */ // TODO add per-device submenu for toggle_paint_item g_signal_connect(G_OBJECT (clear_item), "activate", G_CALLBACK (on_clear), data); g_signal_connect(G_OBJECT (toggle_vis_item), "activate", G_CALLBACK (on_toggle_vis), data); g_signal_connect(G_OBJECT (thicker_lines_item), "activate", G_CALLBACK (on_thicker_lines), data); g_signal_connect(G_OBJECT (thinner_lines_item), "activate", G_CALLBACK (on_thinner_lines), data); g_signal_connect(G_OBJECT (opacity_bigger_item), "activate", G_CALLBACK (on_opacity_bigger), data); g_signal_connect(G_OBJECT (opacity_lesser_item), "activate", G_CALLBACK (on_opacity_lesser), data); g_signal_connect(G_OBJECT (undo_item), "activate", G_CALLBACK (on_undo), data); g_signal_connect(G_OBJECT (redo_item), "activate", G_CALLBACK (on_redo), data); /* We do need to show menu items */ gtk_widget_show (toggle_paint_item); gtk_widget_show (clear_item); gtk_widget_show (toggle_vis_item); gtk_widget_show (thicker_lines_item); gtk_widget_show (thinner_lines_item); gtk_widget_show (opacity_bigger_item); gtk_widget_show (opacity_lesser_item); gtk_widget_show (undo_item); gtk_widget_show (redo_item); /* show menu */ gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, 0, gtk_get_current_event_time()); }
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 awn_CPUicon_show_context_menu(AwnCPUicon *self) { AwnCPUiconPrivate *priv; AwnApplet *applet; GtkWidget *item; GtkWidget *submenu; gboolean render_bg; g_object_get (self, "render-bg", &render_bg, NULL); priv = AWN_CPUICON_GET_PRIVATE (self); if (priv->context_menu) { gtk_widget_destroy (priv->context_menu); } g_object_get (self, "applet",&applet, NULL); priv->context_menu = awn_applet_create_default_menu(applet); item = gtk_menu_item_new_with_label (_("Graph Type")); gtk_menu_shell_append(GTK_MENU_SHELL(priv->context_menu), item); submenu = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM(item),submenu); /* Translators: refers to a graph type */ item = gtk_menu_item_new_with_label (_("Area")); gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item); g_signal_connect_swapped (item, "activate", G_CALLBACK(change_to_area), self); item = gtk_menu_item_new_with_label (_("Circle")); gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item); g_signal_connect_swapped (item, "activate", G_CALLBACK(change_to_circle), self); item = gtk_menu_item_new_with_label (_("Bars")); gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item); g_signal_connect_swapped (item, "activate", G_CALLBACK(change_to_bars), self); item = gtk_menu_item_new_with_label (_("Default")); gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item); g_signal_connect_swapped (item, "activate", G_CALLBACK(change_to_default), self); /* item = gtk_menu_item_new_with_label ("Add Icon"); gtk_menu_shell_append(GTK_MENU_SHELL(priv->context_menu), item); submenu = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM(item),submenu); item = gtk_menu_item_new_with_label ("CPU"); gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item); */ /* item = gtk_menu_item_new_with_label ("Remove Icon"); gtk_menu_shell_append(GTK_MENU_SHELL(priv->context_menu), item); */ item = gtk_check_menu_item_new_with_label (_("Render Background")); gtk_check_menu_item_set_active ( GTK_CHECK_MENU_ITEM (item),render_bg); gtk_menu_shell_append(GTK_MENU_SHELL(priv->context_menu), item); g_signal_connect_swapped (item, "activate", G_CALLBACK(change_render_bg), self); item = awn_applet_create_about_item_simple (applet, "Copyright 2009 Rodney Cryderman <*****@*****.**>\n", AWN_APPLET_LICENSE_GPLV2, VERSION); gtk_menu_shell_append(GTK_MENU_SHELL(priv->context_menu), item); gtk_widget_show_all (priv->context_menu); awn_utils_show_menu_images (GTK_MENU(priv->context_menu)); awn_applet_popup_gtk_menu (applet, priv->context_menu, 0, gtk_get_current_event_time()); }
static void add_screen(xcb_randr_get_screen_info_reply_t *reply) { const gchar *title = "Display"; GtkWidget *item = gtk_menu_item_new_with_label(title); GtkMenuShell *menu = GTK_MENU_SHELL(app_menu); struct screen_info *info = g_malloc(sizeof *info); xcb_randr_rotation_t rotation = normalize_rotation(reply->rotation); xcb_randr_rotation_t rotations = reply->rotations; info->label_menu_item = item; info->rotation_menu_group = NULL; info->rotation = rotation; info->config_timestamp = reply->config_timestamp; info->root = reply->root; info->sizeID = reply->sizeID; info->rate = reply->rate; screens_info = g_slist_append(screens_info, info); gtk_widget_set_sensitive(item, FALSE); gtk_menu_shell_append(menu, item); #define R(rot, title) \ if (rotations & XCB_RANDR_ROTATION_##rot) \ add_screen_rotation(info, XCB_RANDR_ROTATION_##rot, title, \ XCB_RANDR_ROTATION_##rot & rotation) R(ROTATE_0, "Landscape"); R(ROTATE_90, "Portrait"); R(ROTATE_180, "Landscape Flipped"); R(ROTATE_270, "Portrait Flipped"); if (rotations & xcb_rotations_mask && rotations & xcb_reflections_mask) gtk_menu_shell_append(menu, gtk_separator_menu_item_new()); R(REFLECT_X, "Reflected X"); R(REFLECT_Y, "Reflected Y"); #undef R gtk_menu_shell_append(menu, gtk_separator_menu_item_new()); gtk_widget_show_all(app_menu); /* Get screen resources */ xcb_randr_get_screen_resources_current_cookie_t resources_cookie; xcb_randr_get_screen_resources_current_reply_t *resources_reply; xcb_generic_error_t *err = NULL; resources_cookie = xcb_randr_get_screen_resources_current(conn, info->root); resources_reply = xcb_randr_get_screen_resources_current_reply(conn, resources_cookie, &err); if (err) { g_warning("Get Screen Resources returned error %u\n", err->error_code); return; } /* Get screen outputs */ xcb_randr_output_t *outputs; guint i; gchar *output_name; outputs = xcb_randr_get_screen_resources_current_outputs(resources_reply); for (i = 0; i < resources_reply->num_outputs; i++) { xcb_randr_get_output_info_reply_t *output_info_reply; xcb_randr_get_output_info_cookie_t output_info_cookie = xcb_randr_get_output_info_unchecked(conn, outputs[i], resources_reply->config_timestamp); output_info_reply = xcb_randr_get_output_info_reply(conn, output_info_cookie, NULL); /* Show only if connected */ switch (output_info_reply->connection) { case XCB_RANDR_CONNECTION_DISCONNECTED: case XCB_RANDR_CONNECTION_UNKNOWN: continue; case XCB_RANDR_CONNECTION_CONNECTED: break; } output_name = get_output_name(output_info_reply); /* Put output names on the menu */ gtk_menu_item_set_label(GTK_MENU_ITEM(item), output_name); g_free(output_name); /* TODO: concatenate multiple names or pick them intelligently */ } }
int main (int argc, char *argv[]) { Reg *reg; reg = g_slice_new (Reg); if (reg == NULL) { fprintf (stderr, "Error: not engouh space\n"); exit (1); } reg->path = malloc (sizeof (char) * MAX_VALUE_NAME); if (reg->path == NULL) { fprintf (stderr, "Error: not engouh space\n"); exit (1); } GtkWidget *window; GtkWidget *vbox; GtkWidget *menubar; GtkWidget *sw; GtkWidget *hpaned; GtkWidget *treeview; GtkWidget *listview; GtkWidget *statusbar; GtkTreeSelection *selection; GtkWidget *file; GtkWidget *edit; GtkWidget *option; GtkWidget *filemenu; GtkWidget *file_quit; GtkWidget *editmenu; GtkWidget *edit_insert_reg_sz; GtkWidget *edit_delete_key; GtkWidget *optionmenu; GtkWidget *option_add_to_run; GtkWidget *option_bind_gateway; gtk_init (&argc, &argv); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "注册表编辑器"); gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER); gtk_window_set_default_size (GTK_WINDOW (window), 600, 400); vbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), vbox); menubar = gtk_menu_bar_new(); gtk_box_pack_start (GTK_BOX (vbox), menubar, FALSE, FALSE, 0); hpaned = gtk_hpaned_new (); gtk_box_pack_start (GTK_BOX (vbox), hpaned, TRUE, TRUE, 0); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_paned_add1 (GTK_PANED (hpaned), sw); treeview = create_tree_view_and_model(); gtk_container_add (GTK_CONTAINER (sw), treeview); gtk_widget_set_size_request (treeview, 150, 0); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_paned_add2 (GTK_PANED (hpaned), sw); listview = create_list_view_and_model(); gtk_container_add (GTK_CONTAINER (sw), listview); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (listview)); statusbar = gtk_statusbar_new(); gtk_box_pack_start (GTK_BOX (vbox), statusbar, FALSE, FALSE, 0); file = gtk_menu_item_new_with_mnemonic ("_File"); edit = gtk_menu_item_new_with_mnemonic ("_Edit"); option = gtk_menu_item_new_with_mnemonic ("_Option"); gtk_menu_shell_append (GTK_MENU_SHELL (menubar), file); gtk_menu_shell_append (GTK_MENU_SHELL (menubar), edit); gtk_menu_shell_append (GTK_MENU_SHELL (menubar), option); filemenu = gtk_menu_new(); editmenu = gtk_menu_new(); optionmenu = gtk_menu_new(); gtk_menu_item_set_submenu (GTK_MENU_ITEM (file), filemenu); gtk_menu_item_set_submenu (GTK_MENU_ITEM (edit), editmenu); gtk_menu_item_set_submenu (GTK_MENU_ITEM (option), optionmenu); file_quit = gtk_image_menu_item_new_from_stock (GTK_STOCK_QUIT, NULL); gtk_menu_shell_append (GTK_MENU_SHELL (filemenu), file_quit); edit_insert_reg_sz = gtk_menu_item_new_with_label ("插入键值(REG_SZ)"); edit_delete_key = gtk_menu_item_new_with_label ("删除选定键值"); gtk_menu_shell_append (GTK_MENU_SHELL (editmenu), edit_insert_reg_sz); gtk_menu_shell_append (GTK_MENU_SHELL (editmenu), edit_delete_key); option_add_to_run = gtk_menu_item_new_with_label ("加入启动项"); option_bind_gateway = gtk_menu_item_new_with_label ("绑定网关"); gtk_menu_shell_append (GTK_MENU_SHELL (optionmenu), option_add_to_run); gtk_menu_shell_append (GTK_MENU_SHELL (optionmenu), option_bind_gateway); reg->rootkey = HKEY_CLASSES_ROOT; reg->path[0] = '\0'; reg->treeview = treeview; reg->listview = listview; reg->selection = selection; reg->progname = argv[0]; gtk_widget_show_all (window); g_signal_connect_swapped (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), G_OBJECT (window)); g_signal_connect (GTK_TREE_VIEW (treeview), "row-activated", G_CALLBACK (on_tree_view_row_activated), reg); g_signal_connect (GTK_MENU_ITEM (file_quit), "activate", G_CALLBACK (gtk_main_quit), NULL); g_signal_connect (GTK_MENU_ITEM (edit_insert_reg_sz), "activate", G_CALLBACK (on_edit_insert_reg_sz_activate), reg); g_signal_connect (GTK_MENU_ITEM (edit_delete_key), "activate", G_CALLBACK (on_edit_delete_key_activate), reg); g_signal_connect (GTK_MENU_ITEM (option_add_to_run), "activate", G_CALLBACK (on_option_add_to_run_activate), reg); g_signal_connect (GTK_MENU_ITEM (option_bind_gateway), "activate", G_CALLBACK (on_option_bind_gateway_activate), reg); // g_signal_connect (selection, "changed", G_CALLBACK (on_changed), collection); gtk_main(); free (reg->path); g_slice_free (Reg, reg); return 0; }
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; } /* Set up theme and transparency support */ #if GTK_CHECK_VERSION (3, 0, 0) GtkWidget *toplevel = gtk_widget_get_toplevel (menu); /* 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 menu; }
int main (int argc, char **argv) { GtkWidget *window; GtkWidget *sw; GtkWidget *tv; GtkWidget *table; GtkWidget *om; GtkWidget *menu; GtkTreeModel *model; gint i; gtk_init (&argc, &argv); our_pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) book_closed_xpm); #if 0 models[MODEL_TYPES] = GTK_TREE_MODEL (gtk_tree_model_types_new ()); #endif models[MODEL_LIST] = create_list_model (); models[MODEL_TREE] = create_tree_model (); model = create_list_model (); models[MODEL_SORTED_LIST] = gtk_tree_model_sort_new_with_model (model); g_object_unref (model); model = create_tree_model (); models[MODEL_SORTED_TREE] = gtk_tree_model_sort_new_with_model (model); g_object_unref (model); models[MODEL_EMPTY_LIST] = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_INT)); models[MODEL_EMPTY_TREE] = GTK_TREE_MODEL (gtk_tree_store_new (1, G_TYPE_INT)); models[MODEL_NULL] = NULL; run_automated_tests (); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); gtk_window_set_default_size (GTK_WINDOW (window), 430, 400); table = gtk_table_new (3, 1, FALSE); gtk_container_add (GTK_CONTAINER (window), table); tv = gtk_tree_view_new_with_model (models[0]); gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (tv), GDK_BUTTON1_MASK, row_targets, G_N_ELEMENTS (row_targets), GDK_ACTION_MOVE | GDK_ACTION_COPY); gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (tv), row_targets, G_N_ELEMENTS (row_targets), GDK_ACTION_MOVE | GDK_ACTION_COPY); /* Model menu */ menu = gtk_menu_new (); i = 0; while (i < MODEL_LAST) { GtkWidget *mi; const char *name; name = model_names[i]; mi = gtk_menu_item_new_with_label (name); gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi); #if 0 window = create_prop_editor (G_OBJECT (models[i])); gtk_window_set_title (GTK_WINDOW (window), name); #endif ++i; } gtk_widget_show_all (menu); om = gtk_option_menu_new (); gtk_option_menu_set_menu (GTK_OPTION_MENU (om), menu); gtk_table_attach (GTK_TABLE (table), om, 0, 1, 0, 1, 0, 0, 0, 0); g_signal_connect (om, "changed", G_CALLBACK (model_selected), tv); /* Columns menu */ menu = gtk_menu_new (); i = 0; while (i < COLUMNS_LAST) { GtkWidget *mi; const char *name; name = column_type_names[i]; mi = gtk_menu_item_new_with_label (name); gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi); ++i; } gtk_widget_show_all (menu); om = gtk_option_menu_new (); gtk_option_menu_set_menu (GTK_OPTION_MENU (om), menu); gtk_table_attach (GTK_TABLE (table), om, 0, 1, 1, 2, 0, 0, 0, 0); set_columns_type (GTK_TREE_VIEW (tv), COLUMNS_LOTS); gtk_option_menu_set_history (GTK_OPTION_MENU (om), COLUMNS_LOTS); g_signal_connect (om, "changed", G_CALLBACK (columns_selected), tv); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_table_attach (GTK_TABLE (table), sw, 0, 1, 2, 3, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); gtk_container_add (GTK_CONTAINER (sw), tv); gtk_widget_show_all (window); gtk_main (); return 0; }
void populate_popup_cb(WebKitWebView *v, GtkMenu *m, void *c) { (void) c; GUI *g = &uzbl.gui; GtkWidget *item; MenuItem *mi; guint i=0; gint context, hit=0; if(!g->menu_items) return; /* check context */ if((context = get_click_context(NULL)) == -1) return; for(i=0; i < uzbl.gui.menu_items->len; i++) { hit = 0; mi = g_ptr_array_index(uzbl.gui.menu_items, i); if (mi->context & WEBKIT_HIT_TEST_RESULT_CONTEXT_IMAGE) { GdkEventButton ev; gint x, y; gdk_window_get_pointer(gtk_widget_get_window(GTK_WIDGET(v)), &x, &y, NULL); ev.x = x; ev.y = y; mi->hittest = webkit_web_view_get_hit_test_result(v, &ev); } if((mi->context > WEBKIT_HIT_TEST_RESULT_CONTEXT_DOCUMENT) && (context & mi->context)) { if(mi->issep) { item = gtk_separator_menu_item_new(); gtk_menu_shell_append(GTK_MENU_SHELL(m), item); gtk_widget_show(item); } else { item = gtk_menu_item_new_with_label(mi->name); g_signal_connect(item, "activate", G_CALLBACK(run_menu_command), mi); gtk_menu_shell_append(GTK_MENU_SHELL(m), item); gtk_widget_show(item); } hit++; } if((mi->context == WEBKIT_HIT_TEST_RESULT_CONTEXT_DOCUMENT) && (context <= WEBKIT_HIT_TEST_RESULT_CONTEXT_DOCUMENT) && !hit) { if(mi->issep) { item = gtk_separator_menu_item_new(); gtk_menu_shell_append(GTK_MENU_SHELL(m), item); gtk_widget_show(item); } else { item = gtk_menu_item_new_with_label(mi->name); g_signal_connect(item, "activate", G_CALLBACK(run_menu_command), mi); gtk_menu_shell_append(GTK_MENU_SHELL(m), item); gtk_widget_show(item); } } } }
WbExpWGtk::WbExpWGtk ( void *expw_parent_ctx, GtkWidget *expw_parent_wid, ldh_tSession expw_ldhses, const char *expw_name, int l_type, int l_editmode, pwr_tStatus *status) : WbExpW( expw_parent_ctx, expw_ldhses, expw_name, l_type, l_editmode, status), parent_wid(expw_parent_wid) { const int window_width = 1100; const int window_height = 600; toplevel = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW, "default-height", window_height, "default-width", window_width, "title", expw_name, 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(WbExpWGtk::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_close = gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, accel_g); g_signal_connect(file_close, "activate", G_CALLBACK(WbExpWGtk::activate_exit), this); file_export = gtk_menu_item_new_with_mnemonic( btext); g_signal_connect(file_export, "activate", G_CALLBACK(WbExpWGtk::activate_export), this); GtkMenu *file_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL); gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_export); 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)); // Edit menu GtkWidget *edit_update = gtk_menu_item_new_with_mnemonic( "_Update"); g_signal_connect(edit_update, "activate", G_CALLBACK(WbExpWGtk::activate_update), this); gtk_widget_add_accelerator( edit_update, "activate", accel_g, 'u', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); edit_check_all = gtk_menu_item_new_with_mnemonic( "_Check all"); g_signal_connect(edit_check_all, "activate", G_CALLBACK(WbExpWGtk::activate_check_all), this); edit_check_clear = gtk_menu_item_new_with_mnemonic( "C_heck clear"); g_signal_connect(edit_check_clear, "activate", G_CALLBACK(WbExpWGtk::activate_check_clear), this); edit_check_reset = gtk_menu_item_new_with_mnemonic( "Check _reset"); g_signal_connect(edit_check_reset, "activate", G_CALLBACK(WbExpWGtk::activate_check_reset), this); edit_show_all = gtk_check_menu_item_new_with_mnemonic( "_Show all"); g_signal_connect( edit_show_all, "activate", G_CALLBACK(activate_show_all), this); gtk_widget_add_accelerator( edit_show_all, "activate", accel_g, 'a', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); GtkMenu *edit_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL); gtk_menu_shell_append(GTK_MENU_SHELL(edit_menu), edit_update); gtk_menu_shell_append(GTK_MENU_SHELL(edit_menu), edit_check_all); gtk_menu_shell_append(GTK_MENU_SHELL(edit_menu), edit_check_clear); gtk_menu_shell_append(GTK_MENU_SHELL(edit_menu), edit_check_reset); gtk_menu_shell_append(GTK_MENU_SHELL(edit_menu), edit_show_all); GtkWidget *edit = gtk_menu_item_new_with_mnemonic("_Edit"); gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), edit); gtk_menu_item_set_submenu(GTK_MENU_ITEM(edit), GTK_WIDGET(edit_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(WbExpWGtk::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(WbExpWGtk::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(WbExpWGtk::activate_zoom_reset), 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); 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)); // 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(WbExpWGtk::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)); // Toolbar GtkToolbar *tools = (GtkToolbar *) g_object_new(GTK_TYPE_TOOLBAR, NULL); pwr_tFileName fname; GtkWidget *tools_export = gtk_button_new(); dcli_translate_filename( fname, "$pwr_exe/wb_export.png"); gtk_container_add( GTK_CONTAINER(tools_export), gtk_image_new_from_file( fname)); g_signal_connect(tools_export, "clicked", G_CALLBACK(activate_export), this); g_object_set( tools_export, "can-focus", FALSE, NULL); gtk_toolbar_append_widget( tools, tools_export, action, ""); GtkWidget *tools_update = gtk_button_new(); dcli_translate_filename( fname, "$pwr_exe/ge_update.png"); gtk_container_add( GTK_CONTAINER(tools_update), gtk_image_new_from_file( fname)); g_signal_connect(tools_update, "clicked", G_CALLBACK(activate_update), this); g_object_set( tools_update, "can-focus", FALSE, NULL); gtk_toolbar_append_widget( tools, tools_update, "Update", ""); 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(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(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(activate_zoom_reset), this); g_object_set( tools_zoom_reset, "can-focus", FALSE, NULL); gtk_toolbar_append_widget( tools, tools_zoom_reset, "Zoom reset", ""); form = gtk_vbox_new( FALSE, 0); // Create expwnav expwnav = new WbExpWNavGtk( this, form, expw_ldhses, l_type, l_editmode, &nav_widget); gtk_box_pack_start( GTK_BOX(form), GTK_WIDGET(menu_bar), FALSE, FALSE, 0); gtk_box_pack_start( GTK_BOX(form), GTK_WIDGET(tools), FALSE, FALSE, 0); gtk_box_pack_start( GTK_BOX(form), GTK_WIDGET(nav_widget), TRUE, TRUE, 0); gtk_container_add( GTK_CONTAINER(toplevel), form); gtk_widget_show_all( toplevel); wow = new CoWowGtk( toplevel); show(); // expwnav->check_all(); }
void switcher_button_init(SwitcherButton *self) { self->priv = SWITCHER_BUTTON_GET_PRIVATE(self); self->priv->osso = osso_initialize("layoutswitcher", VERSION, 0, 0); self->priv->model = tabletModel(); switch (self->priv->model) { case N800: printf("800\n"); break; case N810: printf("810\n"); break; case N900: printf("900\n"); break; case N770: printf("770\n"); break; } self->priv->locked = 0; self->priv->theme = gtk_icon_theme_get_default(); self->priv->lock = gtk_icon_theme_load_icon(self->priv->theme, "layoutswitcher-lock", 40, (GtkIconLookupFlags)0, 0); self->priv->icon0 = 0; self->priv->icon1 = 0; self->priv->gconfClient = gconf_client_get_default(); if (self->priv->model == N800 || self->priv->model == N810) { gconf_client_add_dir(self->priv->gconfClient, GCONF_DIR_2008, GCONF_CLIENT_PRELOAD_NONE, 0); self->priv->gconfNotifyCurrent = gconf_client_notify_add(self->priv->gconfClient, GCONF_CURRENT_2008, switcher_button_on_current_changed, self, 0, 0); self->priv->gconfNotifyLang0 = gconf_client_notify_add(self->priv->gconfClient, GCONF_LANG0_2008, switcher_button_on_language_changed, self, 0, 0); self->priv->gconfNotifyLang1 = gconf_client_notify_add(self->priv->gconfClient, GCONF_LANG1_2008, switcher_button_on_language_changed, self, 0, 0); } else if (self->priv->model == N770) { gconf_client_add_dir(self->priv->gconfClient, GCONF_DIR_2006, GCONF_CLIENT_PRELOAD_NONE, 0); self->priv->gconfNotifyCurrent = gconf_client_notify_add(self->priv->gconfClient, GCONF_CURRENT_2006, switcher_button_on_current_changed, self, 0, 0); self->priv->gconfNotifyLang0 = gconf_client_notify_add(self->priv->gconfClient, GCONF_LANG0_2006, switcher_button_on_language_changed, self, 0, 0); self->priv->gconfNotifyLang1 = gconf_client_notify_add(self->priv->gconfClient, GCONF_LANG1_2006, switcher_button_on_language_changed, self, 0, 0); } gconf_client_add_dir(self->priv->gconfClient, GCONF_LOCK_DIR, GCONF_CLIENT_PRELOAD_NONE, 0); self->priv->gconfNotifyLock = gconf_client_notify_add(self->priv->gconfClient, GCONF_LOCK_ENTRY, switcher_button_on_lock_changed, self, 0, 0); self->priv->menu = gtk_menu_new(); self->priv->menuItemCopy = gtk_menu_item_new_with_label("Copy text"); self->priv->menuItemBlock= gtk_check_menu_item_new_with_label("Block keyboard"); g_signal_connect(G_OBJECT(self->priv->menuItemCopy), "activate", G_CALLBACK(switcher_button_on_copy_menu), self); g_signal_connect(G_OBJECT(self->priv->menuItemBlock), "activate", G_CALLBACK(switcher_button_on_block_menu), self); gtk_menu_shell_append(GTK_MENU_SHELL(self->priv->menu), self->priv->menuItemCopy); gtk_menu_shell_append(GTK_MENU_SHELL(self->priv->menu), self->priv->menuItemBlock); gtk_widget_show_all(self->priv->menu); g_signal_connect(G_OBJECT(self), "clicked", G_CALLBACK(switcher_button_on_click), 0); if (self->priv->model == N770) { g_signal_connect(G_OBJECT(self), "tap-and-hold", G_CALLBACK(switcher_button_on_tap_and_hold), 0); gtk_widget_tap_and_hold_setup(GTK_WIDGET(self), 0, 0, 0); } else { // g_signal_connect(G_OBJECT(self), "tap-and-hold", G_CALLBACK(switcher_button_on_tap_and_hold), 0); gtk_widget_tap_and_hold_setup(GTK_WIDGET(self), self->priv->menu, 0, 0); } g_signal_connect_after(G_OBJECT(self), "expose-event", G_CALLBACK(switcher_button_on_expose), 0); switcher_button_update_languages(self); }
void PopupMenuGtk::show(const IntRect& rect, FrameView* view, int index) { ASSERT(client()); if (!m_popup) { m_popup = GTK_MENU(gtk_menu_new()); g_signal_connect(m_popup.get(), "unmap", G_CALLBACK(PopupMenuGtk::menuUnmapped), this); g_signal_connect(m_popup.get(), "key-press-event", G_CALLBACK(PopupMenuGtk::keyPressEventCallback), this); } else gtk_container_foreach(GTK_CONTAINER(m_popup.get()), reinterpret_cast<GtkCallback>(menuRemoveItem), this); int x = 0; int y = 0; GdkWindow* window = gtk_widget_get_window(GTK_WIDGET(view->hostWindow()->platformPageClient())); if (window) gdk_window_get_origin(window, &x, &y); m_menuPosition = view->contentsToWindow(rect.location()); m_menuPosition = IntPoint(m_menuPosition.x() + x, m_menuPosition.y() + y + rect.height()); m_indexMap.clear(); const int size = client()->listSize(); for (int i = 0; i < size; ++i) { GtkWidget* item; if (client()->itemIsSeparator(i)) item = gtk_separator_menu_item_new(); else item = gtk_menu_item_new_with_label(client()->itemText(i).utf8().data()); m_indexMap.add(item, i); g_signal_connect(item, "activate", G_CALLBACK(PopupMenuGtk::menuItemActivated), this); g_signal_connect(item, "select", G_CALLBACK(PopupMenuGtk::selectItemCallback), this); // FIXME: Apply the PopupMenuStyle from client()->itemStyle(i) gtk_widget_set_sensitive(item, client()->itemIsEnabled(i)); gtk_menu_shell_append(GTK_MENU_SHELL(m_popup.get()), item); gtk_widget_show(item); } gtk_menu_set_active(m_popup.get(), index); // The size calls are directly copied from gtkcombobox.c which is LGPL GtkRequisition requisition; gtk_widget_set_size_request(GTK_WIDGET(m_popup.get()), -1, -1); #ifdef GTK_API_VERSION_2 gtk_widget_size_request(GTK_WIDGET(m_popup.get()), &requisition); #else gtk_widget_get_preferred_size(GTK_WIDGET(m_popup.get()), &requisition, 0); #endif gtk_widget_set_size_request(GTK_WIDGET(m_popup.get()), std::max(rect.width(), requisition.width), -1); GList* children = gtk_container_get_children(GTK_CONTAINER(m_popup.get())); GList* p = children; if (size) { for (int i = 0; i < size; i++) { if (i > index) break; GtkWidget* item = reinterpret_cast<GtkWidget*>(p->data); GtkRequisition itemRequisition; #ifdef GTK_API_VERSION_2 gtk_widget_get_child_requisition(item, &itemRequisition); #else gtk_widget_get_preferred_size(item, &itemRequisition, 0); #endif m_menuPosition.setY(m_menuPosition.y() - itemRequisition.height); p = g_list_next(p); } } else { // Center vertically the empty popup in the combo box area m_menuPosition.setY(m_menuPosition.y() - rect.height() / 2); } g_list_free(children); gtk_menu_popup(m_popup.get(), 0, 0, reinterpret_cast<GtkMenuPositionFunc>(menuPositionFunction), this, 0, gtk_get_current_event_time()); }
GtkWidget* linphone_gtk_init_chatroom(LinphoneChatRoom *cr, const LinphoneAddress *with){ GtkWidget *chat_view=linphone_gtk_create_widget("chatroom_frame"); GtkWidget *main_window=linphone_gtk_get_main_window(); GtkNotebook *notebook=(GtkNotebook *)linphone_gtk_get_widget(main_window,"viewswitch"); GtkWidget *text=linphone_gtk_get_widget(chat_view,"textview"); GdkColor color_grey = {0, 32512, 32512, 32512}; GdkColor color_light_grey = {0, 56832, 60928, 61952}; GdkColor color_black = {0}; int idx; GtkWidget *button; GtkWidget *entry = linphone_gtk_get_widget(chat_view,"text_entry"); MSList *messages; GHashTable *table; GtkTextTag *tmp_tag; GtkWidget *link_ctx_menu = gtk_menu_new(); GtkWidget *link_ctx_menu_copy_item = gtk_menu_item_new_with_label(_("Copy")); gtk_notebook_append_page(notebook,chat_view,create_tab_chat_header(cr,with)); idx = gtk_notebook_page_num(notebook, chat_view); gtk_notebook_set_current_page(notebook, idx); gtk_widget_show(chat_view); table=g_hash_table_new_full(g_direct_hash,g_direct_equal,NULL,NULL); g_object_set_data(G_OBJECT(chat_view),"cr",cr); g_object_set_data(G_OBJECT(chat_view),"from_message",NULL); g_object_set_data_full(G_OBJECT(chat_view),"table",table,(GDestroyNotify)g_hash_table_destroy); gtk_text_buffer_create_tag( gtk_text_view_get_buffer(GTK_TEXT_VIEW(text)), "me", "foreground_gdk", &color_black, "paragraph-background-gdk", &color_light_grey, NULL); gtk_text_buffer_create_tag( gtk_text_view_get_buffer(GTK_TEXT_VIEW(text)), "from", "weight", PANGO_WEIGHT_BOLD, NULL); gtk_text_buffer_create_tag( gtk_text_view_get_buffer(GTK_TEXT_VIEW(text)), "body", "indent", 10, NULL); gtk_text_buffer_create_tag( gtk_text_view_get_buffer(GTK_TEXT_VIEW(text)), "status", "size-points", 9.0, "foreground_gdk", &color_grey, "style", PANGO_STYLE_ITALIC, "justification", GTK_JUSTIFY_RIGHT, NULL); tmp_tag = gtk_text_buffer_create_tag( gtk_text_view_get_buffer(GTK_TEXT_VIEW(text)), "link", "underline", PANGO_UNDERLINE_SINGLE, "foreground_gdk", _linphone_gtk_chatroom_get_link_color(chat_view), NULL); g_signal_connect(G_OBJECT(tmp_tag), "event", G_CALLBACK(link_event_handler), chat_view); g_signal_connect(G_OBJECT(text), "event", G_CALLBACK(chatroom_event), NULL); gtk_menu_shell_append(GTK_MENU_SHELL(link_ctx_menu), link_ctx_menu_copy_item); g_signal_connect(G_OBJECT(link_ctx_menu_copy_item), "activate", G_CALLBACK(copy_uri_into_clipboard_handler), NULL); gtk_widget_show_all(link_ctx_menu); g_object_set_data_full(G_OBJECT(text), "link_ctx_menu", link_ctx_menu, g_object_unref); g_object_ref_sink(G_OBJECT(link_ctx_menu)); messages = linphone_chat_room_get_history(cr,NB_MSG_HIST); display_history_message(chat_view,messages,with); button = linphone_gtk_get_widget(chat_view,"send"); g_signal_connect_swapped(G_OBJECT(button),"clicked",(GCallback)linphone_gtk_send_text,NULL); g_signal_connect_swapped(G_OBJECT(entry),"activate",(GCallback)linphone_gtk_send_text,NULL); g_signal_connect_swapped(G_OBJECT(entry),"changed",(GCallback)linphone_gtk_compose_text,NULL); g_signal_connect(G_OBJECT(notebook),"switch_page",(GCallback)linphone_gtk_notebook_tab_select,NULL); return chat_view; }
static void wnck_selector_on_show (GtkWidget *widget, WnckSelector *selector) { GtkWidget *separator; WnckScreen *screen; WnckWorkspace *workspace; int nb_workspace; int i; GList **windows_per_workspace; GList *windows; GList *l, *children; /* Remove existing items */ children = gtk_container_get_children (GTK_CONTAINER (selector->priv->menu)); for (l = children; l; l = l->next) gtk_container_remove (GTK_CONTAINER (selector->priv->menu), l->data); g_list_free (children); if (selector->priv->window_hash) g_hash_table_destroy (selector->priv->window_hash); selector->priv->window_hash = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, g_free); screen = wnck_selector_get_screen (selector); nb_workspace = wnck_screen_get_workspace_count (screen); windows_per_workspace = g_malloc0 (nb_workspace * sizeof (GList *)); /* Get windows ordered by workspaces */ windows = wnck_screen_get_windows (screen); windows = g_list_sort (windows, wnck_selector_windows_compare); for (l = windows; l; l = l->next) { workspace = wnck_window_get_workspace (l->data); if (!workspace && wnck_window_is_pinned (l->data)) workspace = wnck_screen_get_active_workspace (screen); if (!workspace) continue; i = wnck_workspace_get_number (workspace); windows_per_workspace[i] = g_list_prepend (windows_per_workspace[i], l->data); } /* Add windows from the current workspace */ workspace = wnck_screen_get_active_workspace (screen); if (workspace) { i = wnck_workspace_get_number (workspace); windows_per_workspace[i] = g_list_reverse (windows_per_workspace[i]); for (l = windows_per_workspace[i]; l; l = l->next) wnck_selector_append_window (selector, l->data); g_list_free (windows_per_workspace[i]); windows_per_workspace[i] = NULL; } /* Add separator */ separator = gtk_separator_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (selector->priv->menu), separator); /* Add windows from other workspaces */ for (i = 0; i < nb_workspace; i++) { wnck_selector_add_workspace (selector, screen, i); windows_per_workspace[i] = g_list_reverse (windows_per_workspace[i]); for (l = windows_per_workspace[i]; l; l = l->next) wnck_selector_append_window (selector, l->data); g_list_free (windows_per_workspace[i]); windows_per_workspace[i] = NULL; } g_free (windows_per_workspace); selector->priv->no_windows_item = wnck_selector_item_new (selector, _("No Windows Open"), NULL); gtk_widget_set_sensitive (selector->priv->no_windows_item, FALSE); gtk_menu_shell_append (GTK_MENU_SHELL (selector->priv->menu), selector->priv->no_windows_item); wnck_selector_make_menu_consistent (selector); }
void cd_switcher_build_windows_list (GtkWidget *pMenu) { GList *pWindowList = NULL; pWindowList = cairo_dock_get_current_applis_list (); pWindowList = g_list_sort (pWindowList, (GCompareFunc) _compare_icons_stack_order); // chaque bureau/viewport. int iNumDesktop=0, iNumViewportX=0, iNumViewportY=0; int k = 0, N = g_desktopGeometry.iNbDesktops * g_desktopGeometry.iNbViewportX * g_desktopGeometry.iNbViewportY; int iIndex = cd_switcher_compute_index_from_desktop (myData.switcher.iCurrentDesktop, myData.switcher.iCurrentViewportX, myData.switcher.iCurrentViewportY); GString *sDesktopName = g_string_new (""); int i, j; for (j = 0; j < myData.switcher.iNbLines; j ++) { for (i = 0; i < myData.switcher.iNbColumns; i ++) { // on ajoute le nom du bureau/viewport dans le menu. GtkWidget *pMenuItem = gtk_separator_menu_item_new (); gtk_menu_shell_append(GTK_MENU_SHELL (pMenu), pMenuItem); g_object_set (pMenuItem, "height-request", 3, NULL); if (k < myData.iNbNames) { if (k == iIndex) g_string_printf (sDesktopName, "<b>%s (%s)</b>", myData.cDesktopNames[k], D_("Current")); else g_string_printf (sDesktopName, "<b>%s</b>", myData.cDesktopNames[k]); } else { if (k == iIndex) g_string_printf (sDesktopName, "<b>%s %d (%s)</b>", D_("Desktop"), k+1, D_("Current")); else g_string_printf (sDesktopName, "<b>%s %d</b>", D_("Desktop"), k+1); } pMenuItem = gldi_menu_add_item (pMenu, sDesktopName->str, NULL, G_CALLBACK (_show_desktop), GINT_TO_POINTER (k)); GtkWidget *pLabel = gtk_bin_get_child (GTK_BIN(pMenuItem)); gtk_label_set_use_markup (GTK_LABEL (pLabel), TRUE); gtk_misc_set_alignment (GTK_MISC (pLabel), .5, .5); pMenuItem = gtk_separator_menu_item_new (); gtk_menu_shell_append(GTK_MENU_SHELL (pMenu), pMenuItem); g_object_set (pMenuItem, "height-request", 3, NULL); // on ajoute les fenetres du viewport au menu. cd_debug ("Windows' listing (%d;%d;%d) ...", iNumDesktop, iNumViewportX, iNumViewportY); cd_switcher_foreach_window_on_viewport (iNumDesktop, iNumViewportX, iNumViewportY, (CDSwitcherActionOnViewportFunc) _cd_switcher_add_window_on_viewport, pMenu); // on passe au viewport suivant. iNumViewportX ++; if (iNumViewportX == g_desktopGeometry.iNbViewportX) { iNumViewportX = 0; iNumViewportY ++; if (iNumViewportY == g_desktopGeometry.iNbViewportY) { iNumViewportY = 0; iNumDesktop ++; } } k ++; if (k == N) break ; } } g_string_free (sDesktopName, TRUE); }
static void build_sort_field_menu (gint start, gint end, gint index, GtkWidget *menu, SortFlowState *state, int used) { Sheet *sheet = state->sel->v_range.cell.a.sheet; GtkWidget *item; GtkWidget *submenu; int i; int this_end; char *str; char *str_start; char *str_end; AddSortFieldMenuState *menu_state; gint menu_size; menu_size = 1 + end - start; if (MAX_MENU_SIZE < menu_size - used) { gint submenu_size; gint balanced_submenu_size; submenu_size = (menu_size + MAX_MENU_SIZE - 1) / MAX_MENU_SIZE; balanced_submenu_size = sqrt((double) (menu_size + MAX_MENU_SIZE - 1)); if (balanced_submenu_size > submenu_size) submenu_size = balanced_submenu_size; for (i = start; i <= end; i+=submenu_size) { this_end = i + submenu_size - 1; if (this_end > end) this_end = end; /* See if there are any fields in this range that aren't already in the sort. */ if (range_already_in_sort_criteria(i, this_end, state)) continue; str_start = state->is_cols ? col_row_name (sheet, i, index, state->header, TRUE) : col_row_name (sheet, index, i, state->header, FALSE); str_end = state->is_cols ? col_row_name (sheet, this_end, index, state->header, TRUE) : col_row_name (sheet, index, this_end, state->header, FALSE); str = g_strdup_printf(_("%s to %s"), str_start, str_end); g_free(str_start); g_free(str_end); item = (GtkWidget *) gtk_menu_item_new_with_label(str); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); gtk_widget_show (item); menu_state = g_new(AddSortFieldMenuState, 1); menu_state->start = i; menu_state->end = this_end; menu_state->index = index; menu_state->state = state; menu_state->done_submenu = FALSE; submenu = gtk_menu_new(); gtk_menu_item_set_submenu(GTK_MENU_ITEM (item), submenu); g_signal_connect (item, "activate", G_CALLBACK (cb_sort_field_menu_activate), menu_state); } } else { for (i = start; i <= end; i++) { if (FALSE == already_in_sort_fields(i, state)) { str = state->is_cols ? col_row_name (sheet, i, index, state->header, TRUE) : col_row_name (sheet, index, i, state->header, FALSE); item = (GtkWidget *) gtk_menu_item_new_with_label(str); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); gtk_widget_show (item); menu_state = g_new(AddSortFieldMenuState, 1); menu_state->start = i; menu_state->end = i; menu_state->index = index; menu_state->state = state; menu_state->done_submenu = FALSE; g_signal_connect (item, "activate", G_CALLBACK (cb_sort_field_selection), menu_state); } } } }
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_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_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(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; }
/* * glade_popup_action_populate_menu: * @menu: a GtkMenu to put the actions menu items. * @widget: A #GladeWidget * @action: a @widget subaction or NULL to include all actions. * @packing: TRUE to include packing actions * * Populate a GtkMenu with widget's actions * * Returns the number of action appended to the menu. */ gint glade_popup_action_populate_menu (GtkWidget *menu, GladeWidget *widget, GladeWidgetAction *action, gboolean packing) { gint n; g_return_val_if_fail (GTK_IS_MENU (menu), 0); g_return_val_if_fail (GLADE_IS_WIDGET (widget), 0); g_return_val_if_fail (action == NULL || GLADE_IS_WIDGET_ACTION (action), 0); if (action) { GWActionClass *aclass = glade_widget_action_get_class (action); GList *children = glade_widget_action_get_children (action); if (glade_widget_get_action (widget, aclass->path) && glade_widget_action_get_visible (action)) return glade_popup_action_populate_menu_real (menu, widget, children, G_CALLBACK (glade_popup_menuitem_activated), widget); if (glade_widget_get_pack_action (widget, aclass->path) && glade_widget_action_get_visible (action)) return glade_popup_action_populate_menu_real (menu, glade_widget_get_parent (widget), children, G_CALLBACK (glade_popup_menuitem_packing_activated), widget); return 0; } n = glade_popup_action_populate_menu_real (menu, widget, glade_widget_get_actions (widget), G_CALLBACK (glade_popup_menuitem_activated), widget); if (packing && glade_widget_get_pack_actions (widget)) { if (n) { GtkWidget *separator = gtk_separator_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (menu), separator); gtk_widget_show (separator); } n += glade_popup_action_populate_menu_real (menu, glade_widget_get_parent (widget), glade_widget_get_pack_actions (widget), G_CALLBACK (glade_popup_menuitem_packing_activated), widget); } return n; }
void gtkui_create() { // Create the GTK+ Window gtkui_image_paths(); GdkPixbuf *icon = gdk_pixbuf_new_from_file(iconpath, NULL); char title[24]; snprintf(title, sizeof(title), "Nestopia UE %s", VERSION); gtkwindow = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_icon(GTK_WINDOW(gtkwindow), icon); gtk_window_set_title(GTK_WINDOW(gtkwindow), title); gtk_window_set_resizable(GTK_WINDOW(gtkwindow), FALSE); GtkWidget *box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_container_add(GTK_CONTAINER(gtkwindow), box); // Define the menubar and menus GtkWidget *menubar = gtk_menu_bar_new(); // Define the File menu GtkWidget *filemenu = gtk_menu_new(); GtkWidget *file = gtk_menu_item_new_with_mnemonic("_File"); GtkWidget *open = gtk_image_menu_item_new_from_stock(GTK_STOCK_OPEN, NULL); GtkWidget *recent = gtk_image_menu_item_new_with_label("Open Recent"); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(recent), gtk_image_new_from_stock(GTK_STOCK_OPEN, GTK_ICON_SIZE_MENU)); GtkWidget *sep_open = gtk_separator_menu_item_new(); GtkWidget *stateload = gtk_image_menu_item_new_with_mnemonic("_Load State..."); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(stateload), gtk_image_new_from_stock(GTK_STOCK_GO_BACK, GTK_ICON_SIZE_MENU)); GtkWidget *statesave = gtk_image_menu_item_new_with_mnemonic("_Save State..."); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(statesave), gtk_image_new_from_stock(GTK_STOCK_SAVE, GTK_ICON_SIZE_MENU)); GtkWidget *quickload = gtk_image_menu_item_new_with_label("Quick Load"); GtkWidget *qloadmenu = gtk_menu_new(); GtkWidget *qload0 = gtk_image_menu_item_new_with_label("0"); GtkWidget *qload1 = gtk_image_menu_item_new_with_label("1"); GtkWidget *qload2 = gtk_image_menu_item_new_with_label("2"); GtkWidget *qload3 = gtk_image_menu_item_new_with_label("3"); GtkWidget *qload4 = gtk_image_menu_item_new_with_label("4"); GtkWidget *quicksave = gtk_image_menu_item_new_with_label("Quick Save"); GtkWidget *qsavemenu = gtk_menu_new(); GtkWidget *qsave0 = gtk_image_menu_item_new_with_label("0"); GtkWidget *qsave1 = gtk_image_menu_item_new_with_label("1"); GtkWidget *qsave2 = gtk_image_menu_item_new_with_label("2"); GtkWidget *qsave3 = gtk_image_menu_item_new_with_label("3"); GtkWidget *qsave4 = gtk_image_menu_item_new_with_label("4"); GtkWidget *sep_state = gtk_separator_menu_item_new(); GtkWidget *screenshot = gtk_image_menu_item_new_with_mnemonic("S_creenshot..."); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(screenshot), gtk_image_new_from_stock(GTK_STOCK_SELECT_COLOR, GTK_ICON_SIZE_MENU)); GtkWidget *sep_screenshot = gtk_separator_menu_item_new(); GtkWidget *movieload = gtk_image_menu_item_new_with_label("Load Movie..."); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(movieload), gtk_image_new_from_stock(GTK_STOCK_OPEN, GTK_ICON_SIZE_MENU)); GtkWidget *moviesave = gtk_image_menu_item_new_with_label("Record Movie..."); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(moviesave), gtk_image_new_from_stock(GTK_STOCK_MEDIA_RECORD, GTK_ICON_SIZE_MENU)); GtkWidget *moviestop = gtk_image_menu_item_new_with_label("Stop Movie"); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(moviestop), gtk_image_new_from_stock(GTK_STOCK_MEDIA_STOP, GTK_ICON_SIZE_MENU)); GtkWidget *sep_movie = gtk_separator_menu_item_new(); GtkWidget *quit = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, NULL); // Set up the recently used items GtkWidget *recent_items = gtk_recent_chooser_menu_new(); GtkRecentFilter *recent_filter = gtk_recent_filter_new(); gtk_recent_filter_add_pattern(recent_filter, "*.nes"); gtk_recent_filter_add_pattern(recent_filter, "*.fds"); gtk_recent_filter_add_pattern(recent_filter, "*.unf"); gtk_recent_filter_add_pattern(recent_filter, "*.unif"); gtk_recent_filter_add_pattern(recent_filter, "*.nsf"); gtk_recent_filter_add_pattern(recent_filter, "*.zip"); gtk_recent_filter_add_pattern(recent_filter, "*.7z"); gtk_recent_filter_add_pattern(recent_filter, "*.txz"); gtk_recent_filter_add_pattern(recent_filter, "*.tar.xz"); gtk_recent_filter_add_pattern(recent_filter, "*.xz"); gtk_recent_filter_add_pattern(recent_filter, "*.tgz"); gtk_recent_filter_add_pattern(recent_filter, "*.tar.gz"); gtk_recent_filter_add_pattern(recent_filter, "*.gz"); gtk_recent_filter_add_pattern(recent_filter, "*.tbz"); gtk_recent_filter_add_pattern(recent_filter, "*.tar.bz2"); gtk_recent_filter_add_pattern(recent_filter, "*.bz2"); gtk_recent_chooser_add_filter(GTK_RECENT_CHOOSER(recent_items), recent_filter); // Populate the File menu 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), recent); gtk_menu_item_set_submenu(GTK_MENU_ITEM(recent), recent_items); gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), sep_open); gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), stateload); gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), statesave); gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), quickload); gtk_menu_item_set_submenu(GTK_MENU_ITEM(quickload), qloadmenu); gtk_menu_shell_append(GTK_MENU_SHELL(qloadmenu), qload0); gtk_menu_shell_append(GTK_MENU_SHELL(qloadmenu), qload1); gtk_menu_shell_append(GTK_MENU_SHELL(qloadmenu), qload2); gtk_menu_shell_append(GTK_MENU_SHELL(qloadmenu), qload3); gtk_menu_shell_append(GTK_MENU_SHELL(qloadmenu), qload4); gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), quicksave); gtk_menu_item_set_submenu(GTK_MENU_ITEM(quicksave), qsavemenu); gtk_menu_shell_append(GTK_MENU_SHELL(qsavemenu), qsave0); gtk_menu_shell_append(GTK_MENU_SHELL(qsavemenu), qsave1); gtk_menu_shell_append(GTK_MENU_SHELL(qsavemenu), qsave2); gtk_menu_shell_append(GTK_MENU_SHELL(qsavemenu), qsave3); gtk_menu_shell_append(GTK_MENU_SHELL(qsavemenu), qsave4); gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), sep_state); gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), screenshot); gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), sep_screenshot); gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), movieload); gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), moviesave); gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), moviestop); gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), sep_movie); gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), quit); // Define the Emulator menu GtkWidget *emulatormenu = gtk_menu_new(); GtkWidget *emu = gtk_menu_item_new_with_mnemonic("_Emulator"); GtkWidget *cont = gtk_image_menu_item_new_with_mnemonic("C_ontinue"); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(cont), gtk_image_new_from_stock(GTK_STOCK_MEDIA_PLAY, GTK_ICON_SIZE_MENU)); GtkWidget *pause = gtk_image_menu_item_new_from_stock(GTK_STOCK_MEDIA_PAUSE, NULL); GtkWidget *sep_pause = gtk_separator_menu_item_new(); GtkWidget *resetsoft = gtk_image_menu_item_new_with_mnemonic("_Reset (Soft)"); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(resetsoft), gtk_image_new_from_stock(GTK_STOCK_REFRESH, GTK_ICON_SIZE_MENU)); GtkWidget *resethard = gtk_image_menu_item_new_with_mnemonic("Reset (_Hard)"); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(resethard), gtk_image_new_from_stock(GTK_STOCK_REFRESH, GTK_ICON_SIZE_MENU)); GtkWidget *sep_reset = gtk_separator_menu_item_new(); GtkWidget *fullscreen = gtk_image_menu_item_new_from_stock(GTK_STOCK_FULLSCREEN, NULL); GtkWidget *sep_fullscreen = gtk_separator_menu_item_new(); GtkWidget *diskflip = gtk_image_menu_item_new_with_mnemonic("Flip FDS _Disk"); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(diskflip), gtk_image_new_from_stock(GTK_STOCK_FLOPPY, GTK_ICON_SIZE_MENU)); GtkWidget *diskswitch = gtk_image_menu_item_new_with_mnemonic("_Switch FDS Disk"); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(diskswitch), gtk_image_new_from_stock(GTK_STOCK_FLOPPY, GTK_ICON_SIZE_MENU)); GtkWidget *sep_disk = gtk_separator_menu_item_new(); GtkWidget *cheats = gtk_image_menu_item_new_with_mnemonic("Ch_eats..."); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(cheats), gtk_image_new_from_stock(GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_MENU)); GtkWidget *sep_cheats = gtk_separator_menu_item_new(); GtkWidget *configuration = gtk_image_menu_item_new_with_mnemonic("_Configuration..."); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(configuration), gtk_image_new_from_stock(GTK_STOCK_PREFERENCES, GTK_ICON_SIZE_MENU)); // Populate the Emulator menu gtk_menu_item_set_submenu(GTK_MENU_ITEM(emu), emulatormenu); gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), cont); gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), pause); gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), sep_pause); gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), resetsoft); gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), resethard); gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), sep_reset); gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), fullscreen); gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), sep_fullscreen); gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), diskflip); gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), diskswitch); gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), sep_disk); gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), cheats); gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), sep_cheats); gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), configuration); // Define the Help menu GtkWidget *helpmenu = gtk_menu_new(); GtkWidget *help = gtk_menu_item_new_with_mnemonic("_Help"); GtkWidget *about = gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT, NULL); // Populate the Help menu gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), helpmenu); gtk_menu_shell_append(GTK_MENU_SHELL(helpmenu), about); // Put the menus into the menubar gtk_menu_shell_append(GTK_MENU_SHELL(menubar), file); gtk_menu_shell_append(GTK_MENU_SHELL(menubar), emu); gtk_menu_shell_append(GTK_MENU_SHELL(menubar), help); // Create the DrawingArea/OpenGL context drawingarea = gtk_drawing_area_new(); //gtk_widget_set_double_buffered(drawingarea, FALSE); g_object_set_data(G_OBJECT(gtkwindow), "area", drawingarea); // Set the Drawing Area to be the size of the game output gtk_widget_set_size_request(drawingarea, rendersize.w, rendersize.h); // Create the statusbar GtkWidget *statusbar = gtk_statusbar_new(); // Pack the box with the menubar, drawingarea, and statusbar gtk_box_pack_start(GTK_BOX(box), menubar, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(box), drawingarea, TRUE, TRUE, 0); //gtk_box_pack_start(GTK_BOX(box), statusbar, FALSE, FALSE, 0); // Make it dark if there's a dark theme GtkSettings *gtksettings = gtk_settings_get_default(); g_object_set(G_OBJECT(gtksettings), "gtk-application-prefer-dark-theme", TRUE, NULL); // Set up the Drag and Drop target GtkTargetEntry target_entry[1]; target_entry[0].target = (gchar*)"text/uri-list"; target_entry[0].flags = 0; target_entry[0].info = 0; gtk_drag_dest_set(drawingarea, (GtkDestDefaults)(GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP), target_entry, sizeof(target_entry) / sizeof(GtkTargetEntry), (GdkDragAction)(GDK_ACTION_MOVE | GDK_ACTION_COPY)); // Connect the signals g_signal_connect(G_OBJECT(drawingarea), "drag-data-received", G_CALLBACK(gtkui_drag_data), NULL); g_signal_connect(G_OBJECT(gtkwindow), "delete_event", G_CALLBACK(nst_schedule_quit), NULL); // File menu g_signal_connect(G_OBJECT(open), "activate", G_CALLBACK(gtkui_file_open), NULL); g_signal_connect(G_OBJECT(recent_items), "item-activated", G_CALLBACK(gtkui_open_recent), NULL); g_signal_connect(G_OBJECT(stateload), "activate", G_CALLBACK(gtkui_state_load), NULL); g_signal_connect(G_OBJECT(statesave), "activate", G_CALLBACK(gtkui_state_save), NULL); g_signal_connect(G_OBJECT(qload0), "activate", G_CALLBACK(gtkui_state_quickload), gpointer(0)); g_signal_connect(G_OBJECT(qload1), "activate", G_CALLBACK(gtkui_state_quickload), gpointer(1)); g_signal_connect(G_OBJECT(qload2), "activate", G_CALLBACK(gtkui_state_quickload), gpointer(2)); g_signal_connect(G_OBJECT(qload3), "activate", G_CALLBACK(gtkui_state_quickload), gpointer(3)); g_signal_connect(G_OBJECT(qload4), "activate", G_CALLBACK(gtkui_state_quickload), gpointer(4)); g_signal_connect(G_OBJECT(qsave0), "activate", G_CALLBACK(gtkui_state_quicksave), gpointer(0)); g_signal_connect(G_OBJECT(qsave1), "activate", G_CALLBACK(gtkui_state_quicksave), gpointer(1)); g_signal_connect(G_OBJECT(qsave2), "activate", G_CALLBACK(gtkui_state_quicksave), gpointer(2)); g_signal_connect(G_OBJECT(qsave3), "activate", G_CALLBACK(gtkui_state_quicksave), gpointer(3)); g_signal_connect(G_OBJECT(qsave4), "activate", G_CALLBACK(gtkui_state_quicksave), gpointer(4)); g_signal_connect(G_OBJECT(statesave), "activate", G_CALLBACK(gtkui_state_save), NULL); g_signal_connect(G_OBJECT(screenshot), "activate", G_CALLBACK(gtkui_screenshot_save), NULL); g_signal_connect(G_OBJECT(moviesave), "activate", G_CALLBACK(gtkui_movie_save), NULL); g_signal_connect(G_OBJECT(movieload), "activate", G_CALLBACK(gtkui_movie_load), NULL); g_signal_connect(G_OBJECT(moviestop), "activate", G_CALLBACK(gtkui_movie_stop), NULL); g_signal_connect(G_OBJECT(quit), "activate", G_CALLBACK(nst_schedule_quit), NULL); // Emulator menu g_signal_connect(G_OBJECT(cont), "activate", G_CALLBACK(nst_play), NULL); g_signal_connect(G_OBJECT(pause), "activate", G_CALLBACK(nst_pause), NULL); g_signal_connect(G_OBJECT(resetsoft), "activate", G_CALLBACK(gtkui_cb_reset), gpointer(0)); g_signal_connect(G_OBJECT(resethard), "activate", G_CALLBACK(gtkui_cb_reset), gpointer(1)); g_signal_connect(G_OBJECT(fullscreen), "activate", G_CALLBACK(video_toggle_fullscreen), NULL); g_signal_connect(G_OBJECT(diskflip), "activate", G_CALLBACK(nst_flip_disk), NULL); g_signal_connect(G_OBJECT(diskswitch), "activate", G_CALLBACK(nst_switch_disk), NULL); g_signal_connect(G_OBJECT(cheats), "activate", G_CALLBACK(gtkui_cheats), NULL); g_signal_connect(G_OBJECT(configuration), "activate", G_CALLBACK(gtkui_config), NULL); // Help menu g_signal_connect(G_OBJECT(about), "activate", G_CALLBACK(gtkui_about), NULL); // Key translation g_signal_connect(G_OBJECT(gtkwindow), "key-press-event", G_CALLBACK(gtkui_cb_convert_key), NULL); g_signal_connect(G_OBJECT(gtkwindow), "key-release-event", G_CALLBACK(gtkui_cb_convert_key), NULL); // Mouse translation gtk_widget_add_events(GTK_WIDGET(drawingarea), GDK_BUTTON_PRESS_MASK); gtk_widget_add_events(GTK_WIDGET(drawingarea), GDK_BUTTON_RELEASE_MASK); g_signal_connect(G_OBJECT(drawingarea), "button-press-event", G_CALLBACK(gtkui_cb_convert_mouse), NULL); g_signal_connect(G_OBJECT(drawingarea), "button-release-event", G_CALLBACK(gtkui_cb_convert_mouse), NULL); gtk_widget_show_all(gtkwindow); }
void menu_setup(GtkBuilder *toplevel) { GtkWidget *bar = NULL; GtkWidget *vbox = NULL; GtkWidget *menubar = NULL; GtkWidget *menu = NULL; GtkWidget *item = NULL; GtkWidget *image = NULL; vbox = GTK_WIDGET (gtk_builder_get_object(toplevel,"menu_vbox")); menubar = gtk_menu_bar_new(); gtk_box_pack_end(GTK_BOX(vbox),menubar,FALSE,FALSE,0); item = gtk_menu_item_new_with_label("File"); menu = gtk_menu_new(); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),menu); gtk_menu_shell_append(GTK_MENU_SHELL(menubar),item); /* File Menu */ item = gtk_image_menu_item_new_with_mnemonic("_New Gauge"); OBJ_SET(toplevel,"new_gauge_menuitem",item); image = gtk_image_new_from_stock("gtk-new",GTK_ICON_SIZE_MENU); g_object_set(item,"image",image,NULL); if (gtk_minor_version >= 16) g_object_set(item,"always-show-image",TRUE,NULL); g_signal_connect(G_OBJECT(item),"activate",G_CALLBACK(create_new_gauge),NULL); gtk_menu_shell_append(GTK_MENU_SHELL(menu),item); item = gtk_image_menu_item_new_with_mnemonic("_Load Gauge"); OBJ_SET(toplevel,"load_gauge_menuitem",item); image = gtk_image_new_from_stock("gtk-open",GTK_ICON_SIZE_MENU); g_object_set(item,"image",image,NULL); if (gtk_minor_version >= 16) g_object_set(item,"always-show-image",TRUE,NULL); g_signal_connect(G_OBJECT(item),"activate",G_CALLBACK(load_handler),NULL); gtk_menu_shell_append(GTK_MENU_SHELL(menu),item); item = gtk_image_menu_item_new_with_mnemonic("_Close"); OBJ_SET(toplevel,"close_gauge_menuitem",item); image = gtk_image_new_from_stock("gtk-close",GTK_ICON_SIZE_MENU); g_object_set(item,"image",image,NULL); if (gtk_minor_version >= 16) g_object_set(item,"always-show-image",TRUE,NULL); g_signal_connect(G_OBJECT(item),"activate",G_CALLBACK(close_current_gauge),NULL); gtk_menu_shell_append(GTK_MENU_SHELL(menu),item); item = gtk_image_menu_item_new_with_mnemonic("S_ave Gauge"); OBJ_SET(toplevel,"save_gauge_menuitem",item); image = gtk_image_new_from_stock("gtk-save",GTK_ICON_SIZE_MENU); g_object_set(item,"image",image,NULL); if (gtk_minor_version >= 16) g_object_set(item,"always-show-image",TRUE,NULL); g_signal_connect(G_OBJECT(item),"activate",G_CALLBACK(save_handler),NULL); gtk_menu_shell_append(GTK_MENU_SHELL(menu),item); item = gtk_image_menu_item_new_with_mnemonic("S_ave Gauge As"); OBJ_SET(toplevel,"save_as_menuitem",item); image = gtk_image_new_from_stock("gtk-save-as",GTK_ICON_SIZE_MENU); g_object_set(item,"image",image,NULL); if (gtk_minor_version >= 16) g_object_set(item,"always-show-image",TRUE,NULL); g_signal_connect(G_OBJECT(item),"activate",G_CALLBACK(save_as_handler),NULL); gtk_menu_shell_append(GTK_MENU_SHELL(menu),item); item = gtk_image_menu_item_new_with_mnemonic("_Quit"); image = gtk_image_new_from_stock("gtk-quit",GTK_ICON_SIZE_MENU); g_object_set(item,"image",image,NULL); if (gtk_minor_version >= 16) g_object_set(item,"always-show-image",TRUE,NULL); g_signal_connect(G_OBJECT(item),"activate",G_CALLBACK(quit_gaugedesigner),NULL); gtk_menu_shell_append(GTK_MENU_SHELL(menu),item); gtk_widget_show_all(menu); /* Edit Menu */ item = gtk_menu_item_new_with_label("Edit"); menu = gtk_menu_new(); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),menu); gtk_menu_shell_append(GTK_MENU_SHELL(menubar),item); item = gtk_image_menu_item_new_with_mnemonic("_General Attributes"); image = gtk_image_new_from_stock("gtk-select-color",GTK_ICON_SIZE_MENU); g_object_set(item,"image",image,NULL); if (gtk_minor_version >= 16) g_object_set(item,"always-show-image",TRUE,NULL); g_signal_connect(G_OBJECT(item),"activate",G_CALLBACK(general_attributes_menu_handler),NULL); gtk_menu_shell_append(GTK_MENU_SHELL(menu),item); item = gtk_image_menu_item_new_with_mnemonic("Gauge Te_xt"); image = gtk_image_new_from_stock("gtk-italic",GTK_ICON_SIZE_MENU); g_object_set(item,"image",image,NULL); if (gtk_minor_version >= 16) g_object_set(item,"always-show-image",TRUE,NULL); g_signal_connect(G_OBJECT(item),"activate",G_CALLBACK(text_attributes_menu_handler),NULL); gtk_menu_shell_append(GTK_MENU_SHELL(menu),item); item = gtk_image_menu_item_new_with_mnemonic("Gauge _Tickmarks"); image = gtk_image_new_from_stock("gtk-preferences",GTK_ICON_SIZE_MENU); g_object_set(item,"image",image,NULL); if (gtk_minor_version >= 16) g_object_set(item,"always-show-image",TRUE,NULL); g_signal_connect(G_OBJECT(item),"activate",G_CALLBACK(tick_groups_menu_handler),NULL); gtk_menu_shell_append(GTK_MENU_SHELL(menu),item); item = gtk_image_menu_item_new_with_mnemonic("Gauge _Warning Thresholds"); image = gtk_image_new_from_stock("gtk-properties",GTK_ICON_SIZE_MENU); g_object_set(item,"image",image,NULL); if (gtk_minor_version >= 16) g_object_set(item,"always-show-image",TRUE,NULL); g_signal_connect(G_OBJECT(item),"activate",G_CALLBACK(warning_ranges_menu_handler),NULL); gtk_menu_shell_append(GTK_MENU_SHELL(menu),item); item = gtk_image_menu_item_new_with_mnemonic("Gauge _Alert Thresholds"); image = gtk_image_new_from_stock("gtk-dialog-warning",GTK_ICON_SIZE_MENU); g_object_set(item,"image",image,NULL); if (gtk_minor_version >= 16) g_object_set(item,"always-show-image",TRUE,NULL); g_signal_connect(G_OBJECT(item),"activate",G_CALLBACK(alert_ranges_menu_handler),NULL); gtk_menu_shell_append(GTK_MENU_SHELL(menu),item); item = gtk_image_menu_item_new_with_mnemonic("Gauge _Advanced Graphics"); image = gtk_image_new_from_stock("gtk-zoom-in",GTK_ICON_SIZE_MENU); g_object_set(item,"image",image,NULL); if (gtk_minor_version >= 16) g_object_set(item,"always-show-image",TRUE,NULL); g_signal_connect(G_OBJECT(item),"activate",G_CALLBACK(polygon_menu_handler),NULL); gtk_menu_shell_append(GTK_MENU_SHELL(menu),item); gtk_widget_show_all(menu); /* Help Menu */ item = gtk_menu_item_new_with_label("Help"); menu = gtk_menu_new(); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),menu); gtk_menu_shell_append(GTK_MENU_SHELL(menubar),item); item = gtk_image_menu_item_new_with_mnemonic("_About GaugeDesigner"); image = gtk_image_new_from_stock("gtk-about",GTK_ICON_SIZE_MENU); g_object_set(item,"image",image,NULL); if (gtk_minor_version >= 16) g_object_set(item,"always-show-image",TRUE,NULL); g_signal_connect(G_OBJECT(item),"activate",G_CALLBACK(about_menu_handler),NULL); gtk_menu_shell_append(GTK_MENU_SHELL(menu),item); return; }
void plugin_init(G_GNUC_UNUSED GeanyData *data) { GeanyKeyGroup *group; GtkWidget *menu, *item; fmt_prefs_init(); #define CONNECT(sig, cb) \ plugin_signal_connect(geany_plugin, NULL, sig, TRUE, G_CALLBACK(cb), NULL) CONNECT("editor-notify", on_editor_notify); CONNECT("project-dialog-open", on_project_dialog_open); CONNECT("project-dialog-close", on_project_dialog_close); CONNECT("project-dialog-confirmed", on_project_dialog_confirmed); CONNECT("project-open", on_project_open); CONNECT("project-close", on_project_close); CONNECT("project-save", on_project_save); CONNECT("document-before-save", on_document_before_save); #undef CONNECT group = plugin_set_key_group(geany_plugin, _("Code Formatting"), 3, (GeanyKeyGroupCallback)on_key_binding); main_menu_item = gtk_menu_item_new_with_label(_("Code Format")); ui_add_document_sensitive(main_menu_item); g_signal_connect(main_menu_item, "map", G_CALLBACK(on_tools_item_map), NULL); menu = gtk_menu_new(); gtk_menu_item_set_submenu(GTK_MENU_ITEM(main_menu_item), menu); item = gtk_check_menu_item_new_with_label(_("Auto-Formatting")); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); g_signal_connect(item, "toggled", G_CALLBACK(on_auto_format_item_toggled), NULL); g_signal_connect(item, "map", G_CALLBACK(on_auto_format_item_map), NULL); item = gtk_separator_menu_item_new(); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); item = gtk_menu_item_new_with_label(_("Current Line or Selection")); g_signal_connect(item, "activate", G_CALLBACK(on_menu_item_activate), GINT_TO_POINTER(FORMAT_KEY_REGION)); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); keybindings_set_item(group, FORMAT_KEY_REGION, NULL, 0, 0, "format_region", _("Format current line or selection"), item); item = gtk_menu_item_new_with_label(_("Entire Document")); g_signal_connect(item, "activate", G_CALLBACK(on_menu_item_activate), GINT_TO_POINTER(FORMAT_KEY_DOCUMENT)); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); keybindings_set_item(group, FORMAT_KEY_DOCUMENT, NULL, 0, 0, "format_document", _("Format entire document"), item); item = gtk_menu_item_new_with_label(_("Entire Session")); g_signal_connect(item, "activate", G_CALLBACK(on_menu_item_activate), GINT_TO_POINTER(FORMAT_KEY_SESSION)); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); keybindings_set_item(group, FORMAT_KEY_SESSION, NULL, 0, 0, "format_session", _("Format entire session"), item); item = gtk_separator_menu_item_new(); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); item = gtk_menu_item_new_with_label(_("Open Configuration File")); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); g_signal_connect(item, "activate", G_CALLBACK(on_open_config_file), NULL); g_signal_connect(item, "map", G_CALLBACK(on_open_config_item_map), NULL); gtk_widget_show_all(main_menu_item); gtk_menu_shell_append(GTK_MENU_SHELL(geany_data->main_widgets->tools_menu), main_menu_item); }
static void notebook_popup_menu_show (CajaNavigationWindowPane *pane, GdkEventButton *event) { GtkWidget *popup; GtkWidget *item; GtkWidget *image; int button, event_time; gboolean can_move_left, can_move_right; CajaNotebook *notebook; notebook = CAJA_NOTEBOOK (pane->notebook); can_move_left = caja_notebook_can_reorder_current_child_relative (notebook, -1); can_move_right = caja_notebook_can_reorder_current_child_relative (notebook, 1); popup = gtk_menu_new(); item = gtk_menu_item_new_with_mnemonic (_("_New Tab")); g_signal_connect (item, "activate", G_CALLBACK (notebook_popup_menu_new_tab_cb), pane); gtk_menu_shell_append (GTK_MENU_SHELL (popup), item); gtk_menu_shell_append (GTK_MENU_SHELL (popup), gtk_separator_menu_item_new ()); item = gtk_menu_item_new_with_mnemonic (_("Move Tab _Left")); g_signal_connect (item, "activate", G_CALLBACK (notebook_popup_menu_move_left_cb), pane); gtk_menu_shell_append (GTK_MENU_SHELL (popup), item); gtk_widget_set_sensitive (item, can_move_left); item = gtk_menu_item_new_with_mnemonic (_("Move Tab _Right")); g_signal_connect (item, "activate", G_CALLBACK (notebook_popup_menu_move_right_cb), pane); gtk_menu_shell_append (GTK_MENU_SHELL (popup), item); gtk_widget_set_sensitive (item, can_move_right); gtk_menu_shell_append (GTK_MENU_SHELL (popup), gtk_separator_menu_item_new ()); item = gtk_image_menu_item_new_with_mnemonic (_("_Close Tab")); image = gtk_image_new_from_stock (GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image); g_signal_connect (item, "activate", G_CALLBACK (notebook_popup_menu_close_cb), pane); gtk_menu_shell_append (GTK_MENU_SHELL (popup), item); gtk_widget_show_all (popup); if (event) { button = event->button; event_time = event->time; } else { button = 0; event_time = gtk_get_current_event_time (); } /* TODO is this correct? */ gtk_menu_attach_to_widget (GTK_MENU (popup), pane->notebook, NULL); gtk_menu_popup (GTK_MENU (popup), NULL, NULL, NULL, NULL, button, event_time); }
static void create_popup_menu (ViewerCbInfo * info) { GtkWidget *popup_menu; GtkWidget *menu_item; GtkWidget *stock; popup_menu = gtk_menu_new (); gtk_menu_set_accel_group (GTK_MENU (popup_menu), info->accel_group); if (info->base_uri) { menu_item = gtk_image_menu_item_new_with_label (_("Copy SVG location")); stock = gtk_image_new_from_stock (GTK_STOCK_COPY, GTK_ICON_SIZE_MENU); gtk_widget_show (stock); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item), stock); g_signal_connect (menu_item, "activate", G_CALLBACK (copy_svg_location), info); gtk_widget_show (menu_item); gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), menu_item); gtk_widget_add_accelerator (menu_item, "activate", info->accel_group, GDK_C, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); } menu_item = gtk_image_menu_item_new_from_stock (GTK_STOCK_SAVE, NULL); g_signal_connect (menu_item, "activate", G_CALLBACK (save_svg), info); gtk_widget_show (menu_item); gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), menu_item); gtk_widget_add_accelerator (menu_item, "activate", info->accel_group, GDK_S, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); menu_item = gtk_image_menu_item_new_with_label (_("Save as PNG")); stock = gtk_image_new_from_stock (GTK_STOCK_SAVE_AS, GTK_ICON_SIZE_MENU); gtk_widget_show (stock); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item), stock); g_signal_connect (menu_item, "activate", G_CALLBACK (save_pixbuf), info); gtk_widget_show (menu_item); gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), menu_item); gtk_widget_add_accelerator (menu_item, "activate", info->accel_group, GDK_S, GDK_CONTROL_MASK | GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE); #if GTK_CHECK_VERSION(2,10,0) menu_item = gtk_image_menu_item_new_from_stock (GTK_STOCK_PRINT, NULL); g_signal_connect (menu_item, "activate", G_CALLBACK (print_pixbuf), info); gtk_widget_show (menu_item); gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), menu_item); gtk_widget_add_accelerator (menu_item, "activate", info->accel_group, GDK_P, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); #endif menu_item = gtk_image_menu_item_new_from_stock (GTK_STOCK_ZOOM_IN, NULL); g_signal_connect (menu_item, "activate", G_CALLBACK (zoom_in), info); gtk_widget_show (menu_item); gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), menu_item); gtk_widget_add_accelerator (menu_item, "activate", info->accel_group, GDK_plus, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); menu_item = gtk_image_menu_item_new_from_stock (GTK_STOCK_ZOOM_OUT, NULL); g_signal_connect (menu_item, "activate", G_CALLBACK (zoom_out), info); gtk_widget_show (menu_item); gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), menu_item); gtk_widget_add_accelerator (menu_item, "activate", info->accel_group, GDK_minus, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); info->popup_menu = popup_menu; }