extern void set_compatibility_menu(gtk_widgets_t *data, char *version) { GSList *g = NULL; version_e v = parse_version(version); for (version_e i = VERSION_CURRENT; i > VERSION_UNKNOWN; i--) { const char *t = get_version_string(i); GtkWidget *m = gtk_radio_menu_item_new_with_label(g, t); g = gtk_radio_menu_item_get_group((GtkRadioMenuItem *)m); gtk_menu_shell_append((GtkMenuShell *)data->compat_menu, m); g_signal_connect(G_OBJECT(m), "toggled", G_CALLBACK(on_compatibility_change), data); gtk_widget_show(m); if (i == v || i == VERSION_CURRENT) { gtk_check_menu_item_set_active((GtkCheckMenuItem *)m, TRUE); _version = i; } } return; }
static GtkWidget * menu_radio_item (char *label, GtkWidget *menu, void *callback, void *userdata, int state, char *groupname) { GtkWidget *item; GtkMenuItem *parent; GSList *grouplist = NULL; parent = menu_find_item (menu, groupname); if (parent) grouplist = gtk_radio_menu_item_get_group ((GtkRadioMenuItem *)parent); item = gtk_radio_menu_item_new_with_label (grouplist, label); gtk_check_menu_item_set_active ((GtkCheckMenuItem*)item, state); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (callback), userdata); gtk_widget_show (item); return item; }
GtkWidget* systray_add_radio_item(menu_info_t* mi, const char* desc, const char* tooltip) { GtkWidget* item = gtk_radio_menu_item_new_with_label(mi->group, desc); if(tooltip) systray_set_tooltip(item, tooltip); mi->group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item)); /* if this is the first item, remove the "none" placeholder label */ if(g_hash_table_size(mi->items) == 0) { GList* children = gtk_container_get_children(GTK_CONTAINER(mi->menu)); if(children) gtk_container_remove(GTK_CONTAINER(mi->menu), GTK_WIDGET(children->data)); } gtk_menu_shell_append(mi->menu, item); gtk_widget_show(item); return item; }
GtkWidget* create_toolbar_button_menu () { GtkWidget *menu = gtk_menu_new (); GSList *group = NULL; gint i = 0; ToolBarButtonMenuItemStruct *item = &items_array[i]; while (item->menu_item_label != NULL) { GtkRadioMenuItem *radio_item; radio_item = GTK_RADIO_MENU_ITEM (gtk_radio_menu_item_new_with_label (group, item->menu_item_label)); g_object_set_data (G_OBJECT (radio_item), TOOL_BAR_MENU_ITEM_STRUCT_PTR, item); group = gtk_radio_menu_item_get_group (radio_item); gtk_menu_shell_append (GTK_MENU_SHELL (menu), GTK_WIDGET (radio_item)); item = &items_array[++i]; }; gtk_widget_show_all (menu); return menu; }
static GtkWidget * create_menu (gint depth, gboolean tearoff) { GtkWidget *menu; GtkWidget *menuitem; GSList *group; char buf[32]; int i, j; if (depth < 1) return NULL; menu = gtk_menu_new (); group = NULL; if (tearoff) { menuitem = gtk_tearoff_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); gtk_widget_show (menuitem); } for (i = 0, j = 1; i < 5; i++, j++) { sprintf (buf, "item %2d - %d", depth, j); menuitem = gtk_radio_menu_item_new_with_label (group, buf); group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (menuitem)); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); gtk_widget_show (menuitem); if (i == 3) gtk_widget_set_sensitive (menuitem, FALSE); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (depth - 1, TRUE)); } return menu; }
static GtkRadioMenuItem * create_zoom_menu_item (NautilusZoomControl *zoom_control, GtkMenu *menu, NautilusZoomLevel zoom_level, GtkRadioMenuItem *previous_radio_item) { GtkWidget *menu_item; char *item_text; GSList *radio_item_group; int percent; /* Set flag so that callback isn't activated when set_active called * to set toggle state of other radio items. */ zoom_control->details->marking_menu_items = TRUE; percent = floor ((100.0 * nautilus_get_relative_icon_size_for_zoom_level (zoom_level)) + .5); item_text = g_strdup_printf ("%d%%", percent); radio_item_group = previous_radio_item == NULL ? NULL : gtk_radio_menu_item_get_group (previous_radio_item); menu_item = gtk_radio_menu_item_new_with_label (radio_item_group, item_text); g_free (item_text); gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item), zoom_level == zoom_control->details->zoom_level); g_object_set_data (G_OBJECT (menu_item), "zoom_level", GINT_TO_POINTER (zoom_level)); g_signal_connect_object (menu_item, "activate", G_CALLBACK (zoom_menu_callback), zoom_control, 0); gtk_widget_show (menu_item); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item); zoom_control->details->marking_menu_items = FALSE; return GTK_RADIO_MENU_ITEM (menu_item); }
/* * CreateMenuRadio * * Create a menu radio * * menu - container menu * szName - name of the menu * func - Call back function. * data - call back function data * * returns new menuitem */ GtkWidget *CreateMenuRadio (GtkWidget *menu, char *szName, GSList **group, GtkSignalFunc func, gpointer data) { GtkWidget *menuitem; /* --- Create menu item --- */ menuitem = gtk_radio_menu_item_new_with_label (*group, szName); *group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem)); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem), FALSE); /* --- Add it to the menu --- */ gtk_menu_append (GTK_MENU (menu), menuitem); gtk_widget_show (menuitem); /* --- Listen for "toggled" messages --- */ gtk_signal_connect (GTK_OBJECT (menuitem), "toggled", GTK_SIGNAL_FUNC(func), data); return (menuitem); }
static void create_single_menu_item( GCallback toggleCb, int val, GtkWidget* menu, EgeAdjustmentAction* act, GtkWidget** dst, GSList** group, gdouble num, gboolean active ) { char* str = 0; EgeAdjustmentDescr* marker = 0; GList* cur = act->private_data->descriptions; while ( cur ) { EgeAdjustmentDescr* descr = (EgeAdjustmentDescr*)cur->data; gdouble delta = num - descr->value; if ( delta < 0.0 ) { delta = -delta; } if ( delta < act->private_data->epsilon ) { marker = descr; break; } cur = g_list_next( cur ); } str = g_strdup_printf( act->private_data->format, num, ((marker && marker->descr) ? ": " : ""), ((marker && marker->descr) ? marker->descr : "")); *dst = gtk_radio_menu_item_new_with_label( *group, str ); if ( !*group) { *group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(*dst) ); } if ( active ) { gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(*dst), TRUE ); } gtk_menu_shell_append( GTK_MENU_SHELL(menu), *dst ); g_object_set_qdata( G_OBJECT(*dst), gDataName, act ); g_signal_connect( G_OBJECT(*dst), "toggled", toggleCb, GINT_TO_POINTER(val) ); g_free(str); }
static void add_screen_rotation(struct screen_info *screen_info, xcb_randr_rotation_t rotation, const gchar *label, gboolean is_active) { GtkMenuShell *menu = GTK_MENU_SHELL(app_menu); gboolean is_reflection = rotation & (XCB_RANDR_ROTATION_REFLECT_X | XCB_RANDR_ROTATION_REFLECT_Y); GtkWidget *item = is_reflection ? gtk_check_menu_item_new_with_label(label) : gtk_radio_menu_item_new_with_label( screen_info->rotation_menu_group, label); if (!is_reflection) screen_info->rotation_menu_group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item)); screen_info->rotation_menu_items[rotation] = item; if (is_active) gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE); g_object_set_data(G_OBJECT(item), "rotation", GUINT_TO_POINTER(rotation)); g_signal_connect(item, "activate", G_CALLBACK(menu_on_item), screen_info); gtk_menu_shell_append(menu, item); }
void xslt_dialog_create(void) { GtkWidget *box, *vbox; GtkWidget *omenu, *menu, *menuitem; GSList *group; GtkWidget *label; fromxsl_t *cur_f = froms; toxsl_t *cur_to = NULL; g_return_if_fail(froms != NULL); dialog = gtk_dialog_new_with_buttons( _("Export through XSLT"), NULL, 0, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response (GTK_DIALOG(dialog), GTK_RESPONSE_OK); box = gtk_dialog_get_content_area(GTK_DIALOG(dialog)); vbox = gtk_vbox_new(FALSE, 5); gtk_container_set_border_width (GTK_CONTAINER (vbox), 5); gtk_container_set_border_width (GTK_CONTAINER (box), 10); label = gtk_label_new(_("From:")); omenu = gtk_option_menu_new (); menu = gtk_menu_new (); group = NULL; while(cur_f != NULL) { menuitem = gtk_radio_menu_item_new_with_label (group, cur_f->name); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (from_activate), cur_f); group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (menuitem)); gtk_menu_append (GTK_MENU (menu), menuitem); gtk_widget_show (menuitem); cur_f = cur_f->next; } gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu); gtk_widget_show(menu); gtk_widget_show(omenu); gtk_widget_show(label); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), omenu, FALSE, TRUE, 0); gtk_widget_show_all(vbox); gtk_box_pack_start (GTK_BOX (box), vbox, FALSE, TRUE, 0); cur_f = froms; vbox = gtk_vbox_new(FALSE, 5); gtk_container_set_border_width (GTK_CONTAINER (vbox), 5); gtk_container_set_border_width (GTK_CONTAINER (box), 10); label = gtk_label_new(_("To:")); omenu = gtk_option_menu_new (); menu = gtk_menu_new (); group = NULL; while(cur_f != NULL) { cur_to = cur_f->xsls; while(cur_to != NULL) { menuitem = gtk_radio_menu_item_new_with_label (group, cur_to->name); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (to_update), cur_to ); group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (menuitem)); gtk_menu_append (GTK_MENU (menu), menuitem); gtk_widget_show (menuitem); cur_to->item = menuitem; cur_to = cur_to->next; } cur_f = cur_f->next; } gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu); gtk_widget_show(menu); gtk_widget_show(omenu); gtk_widget_show(label); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), omenu, FALSE, TRUE, 0); gtk_widget_show_all(vbox); gtk_box_pack_start (GTK_BOX (box), vbox, FALSE, TRUE, 0); gtk_widget_show_all(box); g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(xslt_dialog_respond), NULL); g_signal_connect(G_OBJECT(dialog), "delete_event", G_CALLBACK(gtk_widget_hide), NULL); gtk_widget_show(dialog); cur_f = froms->next; while(cur_f != NULL) { from_deactivate(cur_f); cur_f = cur_f->next; } }
static void *gtk_thread(void *arg) { struct gtk_mod *mod = arg; GtkMenuShell *app_menu; GtkWidget *item; GError *err = NULL; struct le *le; gdk_threads_init(); gtk_init(0, NULL); g_set_application_name("baresip"); mod->app = g_application_new ("com.creytiv.baresip", G_APPLICATION_FLAGS_NONE); g_application_register (G_APPLICATION (mod->app), NULL, &err); if (err != NULL) { warning ("Unable to register GApplication: %s", err->message); g_error_free (err); err = NULL; } #ifdef USE_LIBNOTIFY notify_init("baresip"); #endif mod->status_icon = gtk_status_icon_new_from_icon_name("call-start"); gtk_status_icon_set_tooltip_text (mod->status_icon, "baresip"); g_signal_connect(G_OBJECT(mod->status_icon), "button_press_event", G_CALLBACK(status_icon_on_button_press), mod); gtk_status_icon_set_visible(mod->status_icon, TRUE); mod->contacts_inited = false; mod->dial_dialog = NULL; mod->call_windows = NULL; mod->incoming_call_menus = NULL; /* App menu */ mod->app_menu = gtk_menu_new(); app_menu = GTK_MENU_SHELL(mod->app_menu); /* Account submenu */ mod->accounts_menu = gtk_menu_new(); mod->accounts_menu_group = NULL; item = gtk_menu_item_new_with_mnemonic("_Account"); gtk_menu_shell_append(app_menu, item); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), mod->accounts_menu); /* Add accounts to submenu */ for (le = list_head(uag_list()); le; le = le->next) { struct ua *ua = le->data; accounts_menu_add_item(mod, ua); } /* Status submenu */ mod->status_menu = gtk_menu_new(); item = gtk_menu_item_new_with_mnemonic("_Status"); gtk_menu_shell_append(GTK_MENU_SHELL(app_menu), item); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), mod->status_menu); /* Open */ item = gtk_radio_menu_item_new_with_label(NULL, "Open"); g_object_set_data(G_OBJECT(item), "presence", GINT_TO_POINTER(PRESENCE_OPEN)); g_signal_connect(item, "activate", G_CALLBACK(menu_on_presence_set), mod); gtk_menu_shell_append(GTK_MENU_SHELL(mod->status_menu), item); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE); /* Closed */ item = gtk_radio_menu_item_new_with_label_from_widget( GTK_RADIO_MENU_ITEM(item), "Closed"); g_object_set_data(G_OBJECT(item), "presence", GINT_TO_POINTER(PRESENCE_CLOSED)); g_signal_connect(item, "activate", G_CALLBACK(menu_on_presence_set), mod); gtk_menu_shell_append(GTK_MENU_SHELL(mod->status_menu), item); gtk_menu_shell_append(app_menu, gtk_separator_menu_item_new()); /* Dial */ item = gtk_menu_item_new_with_mnemonic("_Dial..."); gtk_menu_shell_append(app_menu, item); g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(menu_on_dial), mod); /* Dial contact */ mod->contacts_menu = gtk_menu_new(); item = gtk_menu_item_new_with_mnemonic("Dial _contact"); gtk_menu_shell_append(app_menu, item); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), mod->contacts_menu); gtk_menu_shell_append(app_menu, gtk_separator_menu_item_new()); /* About */ item = gtk_menu_item_new_with_mnemonic("A_bout"); g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(menu_on_about), mod); gtk_menu_shell_append(app_menu, item); gtk_menu_shell_append(app_menu, gtk_separator_menu_item_new()); /* Quit */ item = gtk_menu_item_new_with_mnemonic("_Quit"); g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(menu_on_quit), mod); gtk_menu_shell_append(app_menu, item); g_action_map_add_action_entries(G_ACTION_MAP(mod->app), app_entries, G_N_ELEMENTS(app_entries), mod); info("gtk_menu starting\n"); uag_event_register( ua_event_handler, mod ); mod->run = true; gtk_main(); mod->run = false; uag_event_unregister(ua_event_handler); if (mod->dial_dialog) { mem_deref(mod->dial_dialog); mod->dial_dialog = NULL; } return NULL; }
int main (int argc, char ** argv) { GtkWidget *menu = NULL; AppIndicator *ci = NULL; gtk_init (&argc, &argv); ci = app_indicator_new ("example-simple-client", "indicator-messages", APP_INDICATOR_CATEGORY_APPLICATION_STATUS); g_assert (IS_APP_INDICATOR (ci)); g_assert (G_IS_OBJECT (ci)); app_indicator_set_status (ci, APP_INDICATOR_STATUS_ACTIVE); app_indicator_set_attention_icon_full(ci, "indicator-messages-new", "System Messages Icon Highlighted"); app_indicator_set_label (ci, "1%", "100%"); app_indicator_set_title (ci, "Test Inidcator"); g_signal_connect (ci, "act", G_CALLBACK (scroll_event_cb), NULL); g_timeout_add_seconds(1, percent_change, ci); menu = gtk_menu_new (); GtkWidget *item = gtk_check_menu_item_new_with_label ("1"); g_signal_connect (item, "activate", G_CALLBACK (item_clicked_cb), "1"); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); gtk_widget_show (item); item = gtk_radio_menu_item_new_with_label (NULL, "2"); g_signal_connect (item, "activate", G_CALLBACK (item_clicked_cb), "2"); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); gtk_widget_show (item); item = gtk_menu_item_new_with_label ("3"); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); append_submenu (item); gtk_widget_show (item); GtkWidget *toggle_item = gtk_menu_item_new_with_label ("Toggle 3"); g_signal_connect (toggle_item, "activate", G_CALLBACK (toggle_sensitivity_cb), item); gtk_menu_shell_append (GTK_MENU_SHELL (menu), toggle_item); gtk_widget_show(toggle_item); item = gtk_image_menu_item_new_from_stock (GTK_STOCK_NEW, NULL); g_signal_connect (item, "activate", G_CALLBACK (image_clicked_cb), NULL); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); gtk_widget_show(item); item = gtk_menu_item_new_with_label ("Get Attention"); g_signal_connect (item, "activate", G_CALLBACK (activate_clicked_cb), ci); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); gtk_widget_show(item); app_indicator_set_secondary_activate_target(ci, item); item = gtk_menu_item_new_with_label ("Show label"); label_toggle_cb(item, ci); g_signal_connect (item, "activate", G_CALLBACK (label_toggle_cb), ci); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); gtk_widget_show(item); item = gtk_check_menu_item_new_with_label ("Set Local Icon"); g_signal_connect (item, "activate", G_CALLBACK (local_icon_toggle_cb), ci); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); gtk_widget_show(item); app_indicator_set_menu (ci, GTK_MENU (menu)); mainloop = g_main_loop_new(NULL, FALSE); g_main_loop_run(mainloop); return 0; }
/* * mainline.. */ void searchbox(char *title, GtkSignalFunc func) { int i; GtkWidget *menu, *menuitem, *optionmenu; GSList *group; GtkWidget *small_hbox; GtkWidget *scrolled_win; GtkWidget *vbox1, *hbox, *hbox0; GtkWidget *button1, *button2, *button3, *button3a, *button4, *button5, *button6, *button7; GtkWidget *label; gchar *titles[]={"Matches"}; GtkWidget *frame1, *frame2, *frameh, *frameh0; GtkWidget *table; GtkTooltips *tooltips; GtkAdjustment *adj; GtkWidget *align; if(is_active) { gdk_window_raise(window->window); return; } is_active=1; cleanup=func; num_rows=selected_rows=0; /* create a new modal window */ window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW (window), title); gtk_signal_connect(GTK_OBJECT (window), "delete_event", (GtkSignalFunc) destroy_callback, NULL); tooltips=gtk_tooltips_new_2(); table = gtk_table_new (256, 1, FALSE); gtk_widget_show (table); vbox1 = gtk_vbox_new (FALSE, 0); gtk_container_border_width (GTK_CONTAINER (vbox1), 3); gtk_widget_show (vbox1); frame1 = gtk_frame_new (NULL); gtk_container_border_width (GTK_CONTAINER (frame1), 3); gtk_widget_show(frame1); gtk_table_attach (GTK_TABLE (table), frame1, 0, 1, 0, 1, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 1, 1); label=gtk_label_new("Signal Search Expression"); gtk_widget_show(label); gtk_box_pack_start (GTK_BOX (vbox1), label, TRUE, TRUE, 0); entry = gtk_entry_new_with_max_length (256); gtk_signal_connect(GTK_OBJECT(entry), "activate", GTK_SIGNAL_FUNC(enter_callback), entry); gtk_entry_set_text (GTK_ENTRY (entry), searchbox_text); gtk_entry_select_region (GTK_ENTRY (entry), 0, GTK_ENTRY(entry)->text_length); gtk_widget_show (entry); gtk_tooltips_set_tip_2(tooltips, entry, "Enter search expression here. POSIX Wildcards are allowed. Note that you may also " "modify the search criteria by selecting ``[W]Range'', ``[W]Strand'', or ``None'' for suffix " "matching.",NULL); gtk_box_pack_start (GTK_BOX (vbox1), entry, TRUE, TRUE, 0); /* Allocate memory for the data that is used later */ pdata = calloc_2(1, sizeof(SearchProgressData) ); pdata->value = pdata->oldvalue = 0.0; /* Create a centering alignment object */ align = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_widget_show(align); /* Create a Adjustment object to hold the range of the * progress bar */ adj = (GtkAdjustment *) gtk_adjustment_new (0.0, 0.0, (gfloat)((numfacs>1)?numfacs-1:1), 0, 0, 0); pdata->adj = adj; /* Create the GtkProgressBar using the adjustment */ pdata->pbar = gtk_progress_bar_new_with_adjustment (adj); /* Set the format of the string that can be displayed in the * trough of the progress bar: * %p - percentage * %v - value * %l - lower range value * %u - upper range value */ gtk_progress_set_format_string (GTK_PROGRESS (pdata->pbar), "(%p%%)"); gtk_progress_set_show_text (GTK_PROGRESS (pdata->pbar), TRUE); gtk_widget_show(pdata->pbar); gtk_box_pack_start (GTK_BOX (vbox1), pdata->pbar, TRUE, TRUE, 0); gtk_container_add (GTK_CONTAINER (frame1), vbox1); frame2 = gtk_frame_new (NULL); gtk_container_border_width (GTK_CONTAINER (frame2), 3); gtk_widget_show(frame2); gtk_table_attach (GTK_TABLE (table), frame2, 0, 1, 1, 254, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 1, 1); clist=gtk_clist_new_with_titles(1,titles); gtk_clist_column_titles_passive(GTK_CLIST(clist)); gtk_clist_set_selection_mode(GTK_CLIST(clist), GTK_SELECTION_EXTENDED); gtk_signal_connect_object (GTK_OBJECT (clist), "select_row", GTK_SIGNAL_FUNC(select_row_callback), NULL); gtk_signal_connect_object (GTK_OBJECT (clist), "unselect_row", GTK_SIGNAL_FUNC(unselect_row_callback), NULL); gtk_widget_show (clist); scrolled_win = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_usize( GTK_WIDGET (scrolled_win), -1, 300); gtk_widget_show(scrolled_win); /* gtk_scrolled_window_add_with_viewport doesn't seen to work right here.. */ gtk_container_add (GTK_CONTAINER (scrolled_win), clist); gtk_container_add (GTK_CONTAINER (frame2), scrolled_win); frameh0 = gtk_frame_new (NULL); gtk_container_border_width (GTK_CONTAINER (frameh0), 3); gtk_widget_show(frameh0); gtk_table_attach (GTK_TABLE (table), frameh0, 0, 1, 254, 255, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 1, 1); hbox0 = gtk_hbox_new (FALSE, 1); gtk_widget_show (hbox0); button6 = gtk_button_new_with_label (" Select All "); gtk_container_border_width (GTK_CONTAINER (button6), 3); gtk_signal_connect_object (GTK_OBJECT (button6), "clicked", GTK_SIGNAL_FUNC(select_all_callback), GTK_OBJECT (window)); gtk_widget_show (button6); gtk_tooltips_set_tip_2(tooltips, button6, "Highlight all signals listed in the match window.",NULL); gtk_box_pack_start (GTK_BOX (hbox0), button6, TRUE, FALSE, 0); menu = gtk_menu_new (); group=NULL; small_hbox = gtk_hbox_new (TRUE, 0); gtk_widget_show (small_hbox); for(i=0;i<5;i++) { menuitem = gtk_radio_menu_item_new_with_label (group, regex_name[i]); group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem)); gtk_menu_append (GTK_MENU (menu), menuitem); gtk_widget_show (menuitem); gtk_signal_connect(GTK_OBJECT (menuitem), "activate", GTK_SIGNAL_FUNC(regex_clicked), ®ex_mutex[i]); regex_mutex[i]=0; } regex_mutex[0]=1; /* "range" */ optionmenu = gtk_option_menu_new (); gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu), menu); gtk_box_pack_start (GTK_BOX (small_hbox), optionmenu, TRUE, FALSE, 0); gtk_widget_show (optionmenu); gtk_tooltips_set_tip_2(tooltips, optionmenu, "You may " "modify the search criteria by selecting ``Range'', ``Strand'', or ``None'' for suffix " "matching. This optionally matches the string you enter in the search string above with a Verilog " "format range (signal[7:0]), a strand (signal.1, signal.0), or with no suffix. " "The ``W'' modifier for ``Range'' and ``Strand'' explicitly matches on word boundaries. " "(addr matches unit.freezeaddr[63:0] for ``Range'' but only unit.addr[63:0] for ``WRange'' since addr has to be on a word boundary. " "Note that when ``None'' " "is selected, the search string may be located anywhere in the signal name.",NULL); gtk_box_pack_start (GTK_BOX (hbox0), small_hbox, FALSE, FALSE, 0); button7 = gtk_button_new_with_label (" Unselect All "); gtk_container_border_width (GTK_CONTAINER (button7), 3); gtk_signal_connect_object (GTK_OBJECT (button7), "clicked", GTK_SIGNAL_FUNC(unselect_all_callback), GTK_OBJECT (window)); gtk_widget_show (button7); gtk_tooltips_set_tip_2(tooltips, button7, "Unhighlight all signals listed in the match window.",NULL); gtk_box_pack_start (GTK_BOX (hbox0), button7, TRUE, FALSE, 0); gtk_container_add (GTK_CONTAINER (frameh0), hbox0); frameh = gtk_frame_new (NULL); gtk_container_border_width (GTK_CONTAINER (frameh), 3); gtk_widget_show(frameh); gtk_table_attach (GTK_TABLE (table), frameh, 0, 1, 255, 256, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 1, 1); hbox = gtk_hbox_new (FALSE, 1); gtk_widget_show (hbox); button1 = gtk_button_new_with_label ("Append"); gtk_container_border_width (GTK_CONTAINER (button1), 3); gtk_signal_connect_object (GTK_OBJECT (button1), "clicked", GTK_SIGNAL_FUNC(ok_callback), GTK_OBJECT (window)); gtk_widget_show (button1); gtk_tooltips_set_tip_2(tooltips, button1, "Add selected signals to end of the display on the main window.",NULL); gtk_box_pack_start (GTK_BOX (hbox), button1, TRUE, FALSE, 0); button2 = gtk_button_new_with_label (" Insert "); gtk_container_border_width (GTK_CONTAINER (button2), 3); gtk_signal_connect_object (GTK_OBJECT (button2), "clicked", GTK_SIGNAL_FUNC(insert_callback), GTK_OBJECT (window)); gtk_widget_show (button2); gtk_tooltips_set_tip_2(tooltips, button2, "Add selected signals after last highlighted signal on the main window.",NULL); gtk_box_pack_start (GTK_BOX (hbox), button2, TRUE, FALSE, 0); if(vcd_explicit_zero_subscripts>=0) { button3 = gtk_button_new_with_label (" Bundle Up "); gtk_container_border_width (GTK_CONTAINER (button3), 3); gtk_signal_connect_object (GTK_OBJECT (button3), "clicked", GTK_SIGNAL_FUNC(bundle_callback_up), GTK_OBJECT (window)); gtk_widget_show (button3); gtk_tooltips_set_tip_2(tooltips, button3, "Bundle selected signals into a single bit vector with the topmost selected signal as the LSB and the lowest as the MSB.",NULL); gtk_box_pack_start (GTK_BOX (hbox), button3, TRUE, FALSE, 0); button3a = gtk_button_new_with_label (" Bundle Down "); gtk_container_border_width (GTK_CONTAINER (button3a), 3); gtk_signal_connect_object (GTK_OBJECT (button3a), "clicked", GTK_SIGNAL_FUNC(bundle_callback_down), GTK_OBJECT (window)); gtk_widget_show (button3a); gtk_tooltips_set_tip_2(tooltips, button3a, "Bundle selected signals into a single bit vector with the topmost selected signal as the MSB and the lowest as the LSB.",NULL); gtk_box_pack_start (GTK_BOX (hbox), button3a, TRUE, FALSE, 0); } button4 = gtk_button_new_with_label (" Replace "); gtk_container_border_width (GTK_CONTAINER (button4), 3); gtk_signal_connect_object (GTK_OBJECT (button4), "clicked", GTK_SIGNAL_FUNC(replace_callback), GTK_OBJECT (window)); gtk_widget_show (button4); gtk_tooltips_set_tip_2(tooltips, button4, "Replace highlighted signals on the main window with signals selected above.",NULL); gtk_box_pack_start (GTK_BOX (hbox), button4, TRUE, FALSE, 0); button5 = gtk_button_new_with_label (" Exit "); gtk_container_border_width (GTK_CONTAINER (button5), 3); gtk_signal_connect_object (GTK_OBJECT (button5), "clicked", GTK_SIGNAL_FUNC(destroy_callback), GTK_OBJECT (window)); gtk_tooltips_set_tip_2(tooltips, button5, "Do nothing and return to the main window.",NULL); gtk_widget_show (button5); gtk_box_pack_start (GTK_BOX (hbox), button5, TRUE, FALSE, 0); gtk_container_add (GTK_CONTAINER (frameh), hbox); gtk_container_add (GTK_CONTAINER (window), table); gtk_widget_show(window); if(strlen(searchbox_text)) enter_callback(entry,NULL); }
void dev_select_rescan(GtkAction *action, GtkWindow *parent) { GtkComboBox *dev = g_object_get_data(G_OBJECT(parent), "devcombo"); g_return_if_fail(dev != NULL); GtkListStore *devlist = GTK_LIST_STORE(gtk_combo_box_get_model(dev)); GtkTreeIter iter; struct sr_device *device; struct sr_device_instance *sdi; gchar *sdevname = NULL; GSList *devices, *l; GtkUIManager *ui = g_object_get_data(G_OBJECT(parent), "ui_manager"); GtkWidget *menuitem = gtk_ui_manager_get_widget(ui, "/menubar/DevMenu/DevSelectMenu"); GtkMenuShell *devmenu = GTK_MENU_SHELL(gtk_menu_item_get_submenu(GTK_MENU_ITEM(menuitem))); GSList *radiolist = NULL; (void)action; /* Make a copy of the selected device's short name for comparison. * We wish to select the same device after the refresh if possible. */ if (gtk_combo_box_get_active_iter(dev, &iter)) { gtk_tree_model_get(GTK_TREE_MODEL(devlist), &iter, 1, &device, -1); /* FIXME: Use something other than device->plugin->name */ sdevname = g_strdup(device->plugin->name); } /* Destroy the old menu items */ if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(devlist), &iter)) do { GtkMenuItem *item; gtk_tree_model_get(GTK_TREE_MODEL(devlist), &iter, 2, &item, -1); gtk_object_destroy(GTK_OBJECT(item)); } while (gtk_tree_model_iter_next(GTK_TREE_MODEL(devlist), &iter)); gtk_list_store_clear(devlist); /* Scan for new devices and update our list */ /* TODO: Fix this in libsigrok first. */ /*sr_device_scan();*/ devices = sr_device_list(); for (l = devices; l; l = l->next) { device = l->data; sdi = GET_DEVICE_INSTANCE(device); gchar *name = sdi->model ? sdi->model : sdi->vendor; if (!name) name = "(unknown)"; menuitem = gtk_radio_menu_item_new_with_label(radiolist, name); gtk_widget_show(GTK_WIDGET(menuitem)); if (!radiolist) radiolist = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(menuitem)); g_signal_connect(menuitem, "toggled", G_CALLBACK(dev_menuitem_toggled), dev); gtk_menu_shell_prepend(devmenu, menuitem); gtk_list_store_append(devlist, &iter); gtk_list_store_set(devlist, &iter, 0, name, 1, device, 2, menuitem, -1); if (sdevname && g_str_equal(sdevname, device->plugin->name)) gtk_combo_box_set_active_iter(dev, &iter); } if (sdevname) g_free(sdevname); /* Select a default if nothing selected */ if (!gtk_combo_box_get_active_iter(dev, &iter)) { if (!gtk_tree_model_get_iter_first(GTK_TREE_MODEL(devlist), &iter)) return; /* Skip demo if there's another available */ GtkTreeIter first = iter; if (gtk_tree_model_iter_next(GTK_TREE_MODEL(devlist), &iter)) gtk_combo_box_set_active_iter(dev, &iter); else gtk_combo_box_set_active_iter(dev, &first); } }
void MainWindow::initToolbarAndMenu() { XOJ_CHECK_TYPE(MainWindow); GtkMenuShell * menubar = GTK_MENU_SHELL(get("menuViewToolbar")); g_return_if_fail(menubar != NULL); ListIterator<ToolbarData *> it = this->toolbar->getModel()->iterator(); GtkWidget * item = NULL; GtkWidget * selectedItem = NULL; ToolbarData * selectedData = NULL; Settings * settings = control->getSettings(); String selectedId = settings->getSelectedToolbar(); bool predefined = true; int menuPos = 0; while (it.hasNext()) { ToolbarData * d = it.next(); if (selectedData == NULL) { selectedData = d; selectedItem = item; } item = gtk_radio_menu_item_new_with_label(this->toolbarGroup, d->getName().c_str()); this->toolbarGroup = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item)); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), false); MenuSelectToolbarData * data = new MenuSelectToolbarData(this, item, d); this->toolbarMenuData = g_list_append(this->toolbarMenuData, data); if (selectedId == d->getId()) { selectedData = d; selectedItem = item; } g_signal_connect(item, "activate", G_CALLBACK(tbSelectMenuitemActivated), data); gtk_widget_show(item); if (predefined && !d->isPredefined()) { GtkWidget * separator = gtk_separator_menu_item_new(); gtk_widget_show(separator); gtk_menu_shell_insert(menubar, separator, menuPos++); predefined = false; this->toolbarMenuitems = g_list_append(this->toolbarMenuitems, separator); } gtk_menu_shell_insert(menubar, item, menuPos++); this->toolbarMenuitems = g_list_append(this->toolbarMenuitems, item); } if (selectedData) { gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(selectedItem), TRUE); this->toolbarIntialized = true; toolbarSelected(selectedData); } this->control->getScheduler()->unblockRerenderZoom(); }
GtkWidget * menu_new(GtkWindow * main_window, MapArea * map_area, Config * config) { Menu * menubar = g_object_new(GOSM_TYPE_MENU, NULL); menubar -> main_window = main_window; menubar -> map_area = map_area; menubar -> config = config; /******************************************************************************************** * the following part is autogenerated; to regenerate, type: * :r !./misc/menu_gen.py 2 misc/Menu.txt ********************************************************************************************/ GtkWidget *item_1 = gtk_menu_item_new_with_label("File"); GtkWidget *menu_1 = gtk_menu_new(); GtkWidget *item_1_1 = gtk_menu_item_new_with_label("Quit"); GtkWidget *item_2 = gtk_menu_item_new_with_label("View"); GtkWidget *menu_2 = gtk_menu_new(); GtkWidget *item_2_1 = gtk_check_menu_item_new_with_label("Fullscreen"); GtkWidget *item_2_2 = gtk_menu_item_new_with_label("Control"); GtkWidget *menu_2_2 = gtk_menu_new(); GtkWidget *item_2_2_1 = gtk_menu_item_new_with_label("Zoom In"); GtkWidget *item_2_2_2 = gtk_menu_item_new_with_label("Zoom Out"); GtkWidget *item_2_2_3 = gtk_menu_item_new_with_label("Move Up"); GtkWidget *item_2_2_4 = gtk_menu_item_new_with_label("Move Down"); GtkWidget *item_2_2_5 = gtk_menu_item_new_with_label("Move Left"); GtkWidget *item_2_2_6 = gtk_menu_item_new_with_label("Move Right"); GtkWidget *item_2_3 = gtk_menu_item_new_with_label("Tiles"); GtkWidget *menu_2_3 = gtk_menu_new(); GtkWidget *item_2_3_1 = gtk_radio_menu_item_new_with_label(NULL, "Mapnik"); GtkWidget *item_2_3_2 = gtk_radio_menu_item_new_with_label(gtk_radio_menu_item_get_group((GtkRadioMenuItem*)item_2_3_1), "Osmarender"); GtkWidget *item_2_3_3 = gtk_radio_menu_item_new_with_label(gtk_radio_menu_item_get_group((GtkRadioMenuItem*)item_2_3_1), "OpenAerial"); GtkWidget *item_2_3_4 = gtk_radio_menu_item_new_with_label(gtk_radio_menu_item_get_group((GtkRadioMenuItem*)item_2_3_1), "Google"); GtkWidget *item_2_3_5 = gtk_radio_menu_item_new_with_label(gtk_radio_menu_item_get_group((GtkRadioMenuItem*)item_2_3_1), "Yahoo"); GtkWidget *item_3 = gtk_menu_item_new_with_label("Selection"); GtkWidget *menu_3 = gtk_menu_new(); GtkWidget *item_3_1 = gtk_check_menu_item_new_with_label("Snap to Map"); GtkWidget *item_3_2 = gtk_check_menu_item_new_with_label("Hide"); GtkWidget *item_3_3 = gtk_menu_item_new_with_label("Export"); GtkWidget *item_3_4 = gtk_menu_item_new_with_label("Download"); GtkWidget *item_4 = gtk_menu_item_new_with_label("Options"); GtkWidget *menu_4 = gtk_menu_new(); GtkWidget *item_4_1 = gtk_menu_item_new_with_label("Preferences"); GtkWidget *item_5 = gtk_menu_item_new_with_label("Help"); GtkWidget *menu_5 = gtk_menu_new(); GtkWidget *item_5_1 = gtk_menu_item_new_with_label("Manual"); GtkWidget *item_5_2 = gtk_menu_item_new_with_label("About GOsmView"); GtkWidget *item_5_3 = gtk_menu_item_new_with_label("About OpenStreetMap"); GtkWidget *item_5_4 = gtk_menu_item_new_with_label("About Namefinder"); GtkWidget *item_5_5 = gtk_menu_item_new_with_label("License"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_1), menu_1); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_2), menu_2); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_2_2), menu_2_2); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_2_3), menu_2_3); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_3), menu_3); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_4), menu_4); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_5), menu_5); gtk_menu_shell_append(GTK_MENU_SHELL(menubar), item_1); gtk_menu_shell_append(GTK_MENU_SHELL(menu_1), item_1_1); gtk_menu_shell_append(GTK_MENU_SHELL(menubar), item_2); gtk_menu_shell_append(GTK_MENU_SHELL(menu_2), item_2_1); gtk_menu_shell_append(GTK_MENU_SHELL(menu_2), item_2_2); gtk_menu_shell_append(GTK_MENU_SHELL(menu_2_2), item_2_2_1); gtk_menu_shell_append(GTK_MENU_SHELL(menu_2_2), item_2_2_2); gtk_menu_shell_append(GTK_MENU_SHELL(menu_2_2), item_2_2_3); gtk_menu_shell_append(GTK_MENU_SHELL(menu_2_2), item_2_2_4); gtk_menu_shell_append(GTK_MENU_SHELL(menu_2_2), item_2_2_5); gtk_menu_shell_append(GTK_MENU_SHELL(menu_2_2), item_2_2_6); gtk_menu_shell_append(GTK_MENU_SHELL(menu_2), item_2_3); gtk_menu_shell_append(GTK_MENU_SHELL(menu_2_3), item_2_3_1); gtk_menu_shell_append(GTK_MENU_SHELL(menu_2_3), item_2_3_2); gtk_menu_shell_append(GTK_MENU_SHELL(menu_2_3), item_2_3_3); gtk_menu_shell_append(GTK_MENU_SHELL(menu_2_3), item_2_3_4); gtk_menu_shell_append(GTK_MENU_SHELL(menu_2_3), item_2_3_5); gtk_menu_shell_append(GTK_MENU_SHELL(menubar), item_3); gtk_menu_shell_append(GTK_MENU_SHELL(menu_3), item_3_1); gtk_menu_shell_append(GTK_MENU_SHELL(menu_3), item_3_2); gtk_menu_shell_append(GTK_MENU_SHELL(menu_3), item_3_3); gtk_menu_shell_append(GTK_MENU_SHELL(menu_3), item_3_4); gtk_menu_shell_append(GTK_MENU_SHELL(menubar), item_4); gtk_menu_shell_append(GTK_MENU_SHELL(menu_4), item_4_1); gtk_menu_shell_append(GTK_MENU_SHELL(menubar), item_5); gtk_menu_shell_append(GTK_MENU_SHELL(menu_5), item_5_1); gtk_menu_shell_append(GTK_MENU_SHELL(menu_5), item_5_2); gtk_menu_shell_append(GTK_MENU_SHELL(menu_5), item_5_3); gtk_menu_shell_append(GTK_MENU_SHELL(menu_5), item_5_4); gtk_menu_shell_append(GTK_MENU_SHELL(menu_5), item_5_5); menubar -> menu_file_quit = item_1_1; menubar -> menu_view_fullscreen = item_2_1; menubar -> menu_control_zoom_in = item_2_2_1; menubar -> menu_control_zoom_out = item_2_2_2; menubar -> menu_control_move_up = item_2_2_3; menubar -> menu_control_move_down = item_2_2_4; menubar -> menu_control_move_left = item_2_2_5; menubar -> menu_control_move_right = item_2_2_6; menubar -> menu_tiles_mapnik = item_2_3_1; menubar -> menu_tiles_osmarender = item_2_3_2; menubar -> menu_tiles_openaerial = item_2_3_3; menubar -> menu_tiles_google = item_2_3_4; menubar -> menu_tiles_yahoo = item_2_3_5; menubar -> menu_selection_snap = item_3_1; menubar -> menu_selection_show = item_3_2; menubar -> menu_selection_export = item_3_3; menubar -> menu_selection_download = item_3_4; menubar -> menu_options_preferences = item_4_1; menubar -> menu_help_manual = item_5_1; menubar -> menu_help_about_gosm = item_5_2; menubar -> menu_help_about_osm = item_5_3; menubar -> menu_help_about_nf = item_5_4; menubar -> menu_help_license = item_5_5; /******************************************************************************************** * end auto-generated part ********************************************************************************************/ gtk_widget_set_sensitive(menubar -> menu_tiles_osmarender, FALSE); gtk_widget_set_sensitive(menubar -> menu_tiles_openaerial, FALSE); gtk_widget_set_sensitive(menubar -> menu_tiles_google, FALSE); gtk_widget_set_sensitive(menubar -> menu_tiles_yahoo, FALSE); /******************************************************************************************** * signals ********************************************************************************************/ g_signal_connect( G_OBJECT(menubar -> menu_file_quit), "activate", G_CALLBACK(exit_cb), (gpointer)menubar); g_signal_connect( G_OBJECT(menubar -> menu_options_preferences), "activate", G_CALLBACK(show_preferences_cb), (gpointer)menubar); g_signal_connect( G_OBJECT(menubar -> menu_help_manual), "activate", G_CALLBACK(show_manual_cb), (gpointer)menubar); g_signal_connect( G_OBJECT(menubar -> menu_help_about_gosm), "activate", G_CALLBACK(show_about_gosm_cb), (gpointer)menubar); g_signal_connect( G_OBJECT(menubar -> menu_help_about_osm), "activate", G_CALLBACK(show_about_osm_cb), (gpointer)menubar); g_signal_connect( G_OBJECT(menubar -> menu_help_about_nf), "activate", G_CALLBACK(show_about_nf_cb), (gpointer)menubar); g_signal_connect( G_OBJECT(menubar -> menu_help_license), "activate", G_CALLBACK(show_about_license_cb), (gpointer)menubar); g_signal_connect( G_OBJECT(menubar -> menu_control_zoom_in), "activate", G_CALLBACK(button_zoom_in_cb), (gpointer)menubar); g_signal_connect( G_OBJECT(menubar -> menu_control_zoom_out), "activate", G_CALLBACK(button_zoom_out_cb), (gpointer)menubar); g_signal_connect( G_OBJECT(menubar -> menu_control_move_up), "activate", G_CALLBACK(button_move_up_cb), (gpointer)menubar); g_signal_connect( G_OBJECT(menubar -> menu_control_move_down), "activate", G_CALLBACK(button_move_down_cb), (gpointer)menubar); g_signal_connect( G_OBJECT(menubar -> menu_control_move_left), "activate", G_CALLBACK(button_move_left_cb), (gpointer)menubar); g_signal_connect( G_OBJECT(menubar -> menu_control_move_right), "activate", G_CALLBACK(button_move_right_cb), (gpointer)menubar); g_signal_connect( G_OBJECT(menubar -> menu_view_fullscreen), "toggled", G_CALLBACK(menubar_fullscreen_cb), (gpointer)menubar); /* notice when window is being fullscreened */ g_signal_connect( G_OBJECT(main_window), "window-state-event", G_CALLBACK(window_event_cb), (gpointer)menubar); return GTK_WIDGET(menubar); }
void encodings_init(void) { GtkWidget *item, *menu[2], *submenu, *menu_westeuro, *menu_easteuro, *menu_eastasian, *menu_asian, *menu_utf8, *menu_middleeast, *item_westeuro, *item_easteuro, *item_eastasian, *item_asian, *item_utf8, *item_middleeast; GCallback cb_func[2]; GSList *group = NULL; gchar *label; gint order, group_size; guint i, j, k; init_encodings(); if (! pregs_loaded) { regex_compile(&pregs[0], PATTERN_HTMLMETA); regex_compile(&pregs[1], PATTERN_CODING); pregs_loaded = TRUE; } /* create encodings submenu in document menu */ menu[0] = ui_lookup_widget(main_widgets.window, "set_encoding1_menu"); menu[1] = ui_lookup_widget(main_widgets.window, "menu_reload_as1_menu"); cb_func[0] = G_CALLBACK(encodings_radio_item_change_cb); cb_func[1] = G_CALLBACK(on_reload_as_activate); for (k = 0; k < 2; k++) { menu_westeuro = gtk_menu_new(); item_westeuro = gtk_menu_item_new_with_mnemonic(_("_West European")); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_westeuro), menu_westeuro); gtk_container_add(GTK_CONTAINER(menu[k]), item_westeuro); gtk_widget_show_all(item_westeuro); menu_easteuro = gtk_menu_new(); item_easteuro = gtk_menu_item_new_with_mnemonic(_("_East European")); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_easteuro), menu_easteuro); gtk_container_add(GTK_CONTAINER(menu[k]), item_easteuro); gtk_widget_show_all(item_easteuro); menu_eastasian = gtk_menu_new(); item_eastasian = gtk_menu_item_new_with_mnemonic(_("East _Asian")); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_eastasian), menu_eastasian); gtk_container_add(GTK_CONTAINER(menu[k]), item_eastasian); gtk_widget_show_all(item_eastasian); menu_asian = gtk_menu_new(); item_asian = gtk_menu_item_new_with_mnemonic(_("_SE & SW Asian")); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_asian), menu_asian); gtk_container_add(GTK_CONTAINER(menu[k]), item_asian); gtk_widget_show_all(item_asian); menu_middleeast = gtk_menu_new(); item_middleeast = gtk_menu_item_new_with_mnemonic(_("_Middle Eastern")); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_middleeast), menu_middleeast); gtk_container_add(GTK_CONTAINER(menu[k]), item_middleeast); gtk_widget_show_all(item_middleeast); menu_utf8 = gtk_menu_new(); item_utf8 = gtk_menu_item_new_with_mnemonic(_("_Unicode")); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_utf8), menu_utf8); gtk_container_add(GTK_CONTAINER(menu[k]), item_utf8); gtk_widget_show_all(item_utf8); /** TODO can it be optimized? ATM 3782 runs at line "if (encodings[j].group ...)" */ for (i = 0; i < GEANY_ENCODING_GROUPS_MAX; i++) { order = 0; switch (i) { case WESTEUROPEAN: submenu = menu_westeuro; group_size = 9; break; case EASTEUROPEAN: submenu = menu_easteuro; group_size = 14; break; case EASTASIAN: submenu = menu_eastasian; group_size = 14; break; case ASIAN: submenu = menu_asian; group_size = 9; break; case MIDDLEEASTERN: submenu = menu_middleeast; group_size = 7; break; case UNICODE: submenu = menu_utf8; group_size = 8; break; default: submenu = menu[k]; group_size = 1; } while (order < group_size) /* the biggest group has 13 elements */ { for (j = 0; j < GEANY_ENCODINGS_MAX; j++) { if (encodings[j].group == i && encodings[j].order == order) { label = encodings_to_string(&encodings[j]); if (k == 0) { item = gtk_radio_menu_item_new_with_label(group, label); group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item)); radio_items[j] = item; } else item = gtk_menu_item_new_with_label(label); gtk_widget_show(item); gtk_container_add(GTK_CONTAINER(submenu), item); g_signal_connect(item, "activate", cb_func[k], GINT_TO_POINTER(encodings[j].idx)); g_free(label); break; } } order++; } } } }
bool wxMenu::GtkAppend(wxMenuItem *mitem, int pos) { GtkWidget *menuItem; GtkWidget* prevRadio = m_prevRadio; m_prevRadio = NULL; switch (mitem->GetKind()) { case wxITEM_SEPARATOR: menuItem = gtk_separator_menu_item_new(); break; case wxITEM_CHECK: menuItem = gtk_check_menu_item_new_with_label(""); break; case wxITEM_RADIO: { GSList* group = NULL; if (prevRadio) group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(prevRadio)); menuItem = gtk_radio_menu_item_new_with_label(group, ""); m_prevRadio = menuItem; } break; default: wxFAIL_MSG("unexpected menu item kind"); // fall through case wxITEM_NORMAL: const wxBitmap& bitmap = mitem->GetBitmap(); const char* stockid; if (bitmap.IsOk()) { // always use pixbuf, because pixmap mask does not // work with disabled images in some themes GtkWidget* image = gtk_image_new_from_pixbuf(bitmap.GetPixbuf()); menuItem = gtk_image_menu_item_new_with_label(""); gtk_widget_show(image); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menuItem), image); } else if ((stockid = wxGetStockGtkID(mitem->GetId())) != NULL) // use stock bitmap for this item if available on the assumption // that it never hurts to follow GTK+ conventions more closely menuItem = gtk_image_menu_item_new_from_stock(stockid, NULL); else menuItem = gtk_menu_item_new_with_label(""); break; } mitem->SetMenuItem(menuItem); gtk_menu_shell_insert(GTK_MENU_SHELL(m_menu), menuItem, pos); gtk_widget_show( menuItem ); if ( !mitem->IsSeparator() ) { mitem->SetGtkLabel(); g_signal_connect (menuItem, "select", G_CALLBACK(menuitem_select), mitem); g_signal_connect (menuItem, "deselect", G_CALLBACK(menuitem_deselect), mitem); if ( mitem->IsSubMenu() && mitem->GetKind() != wxITEM_RADIO && mitem->GetKind() != wxITEM_CHECK ) { gtk_menu_item_set_submenu( GTK_MENU_ITEM(menuItem), mitem->GetSubMenu()->m_menu ); gtk_widget_show( mitem->GetSubMenu()->m_menu ); } else { g_signal_connect(menuItem, "can_activate_accel", G_CALLBACK(can_activate_accel), this); g_signal_connect (menuItem, "activate", G_CALLBACK(menuitem_activate), mitem); } } return true; }
int main(int argc, char *argv[]) { printf("%s \nPlease report any bug to %s\n", PACKAGE_STRING, PACKAGE_BUGREPORT); //printf("number of arg = %d, argv = %s\n", argc, argv[1]); /*printf("argc = %d\n", argc); if (argv[1] != NULL) { if (strstr (argv[1],"debug") != NULL) { debug = TRUE; printf("debug = TRUE\n"); } } DEBUG("debug is true\n");*/ gchar *filename; int i = 0; gint initialWindowHeight = 170; guint timeoutEvent, intervalDisplaySpectro; GtkWidget *pVBox[4], *pHBox[13], *menuBar, *menu, *submenu, *menuItem, *submenuItem, *button, *frame, *image, *label, *widget; GdkColor color; Spectrum3dGui spectrum3dGui; GSList *radio_menu_group; GError **error; #if defined (GTKGLEXT3) || defined (GTKGLEXT1) GdkGLConfig *glconfig; #endif gst_init (NULL, NULL); gtk_init (&argc, &argv); get_saved_values(); intervalDisplaySpectro = (guint)spectrum3d.interval_display; #if defined (GTKGLEXT3) || defined (GTKGLEXT1) gtk_gl_init(NULL, NULL); glconfig = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGB | GDK_GL_MODE_DEPTH | GDK_GL_MODE_DOUBLE); if (glconfig == NULL) { g_print ("\n*** Cannot find the double-buffered visual.\n"); g_print ("\n*** Trying single-buffered visual.\n"); /* Try single-buffered visual */ glconfig = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGB | GDK_GL_MODE_DEPTH); if (glconfig == NULL) { g_print ("*** No appropriate OpenGL-capable visual found.\n"); exit (1); } } #endif initGstreamer(); init_audio_values(); init_display_values(&spectrum3dGui); spectrum3dGui.mainWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_widget_set_size_request (spectrum3dGui.mainWindow, 700, initialWindowHeight); gtk_widget_realize(spectrum3dGui.mainWindow); gtk_window_set_title(GTK_WINDOW(spectrum3dGui.mainWindow), PACKAGE_NAME); filename = g_build_filename (G_DIR_SEPARATOR_S, DATADIR, "icons", "spectrum3d.png", NULL); gtk_window_set_icon(GTK_WINDOW(spectrum3dGui.mainWindow), gdk_pixbuf_new_from_file (filename, error)); g_signal_connect (G_OBJECT (spectrum3dGui.mainWindow), "destroy", G_CALLBACK (quit_spectrum3d), NULL); #ifdef GTK3 gtk_container_set_reallocate_redraws (GTK_CONTAINER (spectrum3dGui.mainWindow), TRUE); #endif #ifdef GTK3 for (i = 0; i < 4; i++) { pVBox[i] = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); } pHBox[0] = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); for (i = 1; i < 12; i++) { pHBox[i] = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); } pHBox[12] = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); #elif defined GTK2 for (i = 0; i < 4; i++) { pVBox[i] = gtk_vbox_new(FALSE, 0); } pHBox[0] = gtk_hbox_new(TRUE, 0); for (i = 1; i < 12; i++) { pHBox[i] = gtk_hbox_new(FALSE, 0); } pHBox[12] = gtk_hbox_new(TRUE, 0); #endif gtk_container_add(GTK_CONTAINER(spectrum3dGui.mainWindow), pVBox[1]); gtk_box_pack_start(GTK_BOX(pVBox[1]), pHBox[0], FALSE, FALSE, 0); /* Menu */ menuBar = gtk_menu_bar_new(); menu = gtk_menu_new(); // 'Quit' submenu menuItem = gtk_menu_item_new_with_label("Quit"); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem); g_signal_connect(G_OBJECT(menuItem), "activate", G_CALLBACK(gtk_main_quit), NULL); menuItem = gtk_menu_item_new_with_label("Quit"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuItem), menu); gtk_menu_shell_append(GTK_MENU_SHELL(menuBar), menuItem); menu = gtk_menu_new(); // 'Edit' submenu menuItem = gtk_menu_item_new_with_label("Preferences"); g_signal_connect(G_OBJECT(menuItem), "activate", G_CALLBACK(onPreferences), &spectrum3dGui); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem); menuItem = gtk_menu_item_new_with_label("Edit"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuItem), menu); gtk_menu_shell_append(GTK_MENU_SHELL(menuBar), menuItem); menu = gtk_menu_new(); // 'Sound' submenu menuItem = gtk_menu_item_new_with_label("Sound"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuItem), menu); gtk_menu_shell_append(GTK_MENU_SHELL(menuBar), menuItem); submenu = gtk_menu_new();// 'Play test sound' sub-submenu spectrum3dGui.checkMenuTestSound = gtk_check_menu_item_new_with_label("Test Sound"); gtk_menu_shell_append(GTK_MENU_SHELL(menu), spectrum3dGui.checkMenuTestSound); g_signal_connect(G_OBJECT(spectrum3dGui.checkMenuTestSound), "activate", G_CALLBACK(menu_check_test_sound), &spectrum3dGui); menu = gtk_menu_new(); // 'View' submenu menuItem = gtk_menu_item_new_with_label("View"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuItem), menu); gtk_menu_shell_append(GTK_MENU_SHELL(menuBar), menuItem); submenu = gtk_menu_new();// 'viewType' sub-submenu menuItem = gtk_menu_item_new_with_label("Perspective"); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuItem), submenu); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem); spectrum3dGui.radio3D = gtk_radio_menu_item_new_with_label(NULL, "3D (D)"); radio_menu_group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(spectrum3dGui.radio3D)); g_signal_connect(G_OBJECT(spectrum3dGui.radio3D), "toggled", G_CALLBACK(change_perspective), spectrum3dGui.radio3D); gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.radio3D); spectrum3dGui.radio3Dflat = gtk_radio_menu_item_new_with_label(radio_menu_group, "3D flat (F)"); radio_menu_group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(spectrum3dGui.radio3Dflat)); g_signal_connect(G_OBJECT(spectrum3dGui.radio3Dflat), "toggled", G_CALLBACK(change_perspective), spectrum3dGui.radio3Dflat); gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.radio3Dflat); spectrum3dGui.radio2D = gtk_radio_menu_item_new_with_label(radio_menu_group, "2D (D)"); radio_menu_group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(spectrum3dGui.radio2D)); g_signal_connect(G_OBJECT(spectrum3dGui.radio2D), "toggled", G_CALLBACK(change_perspective), spectrum3dGui.radio2D); gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.radio2D); submenu = gtk_menu_new();// 'Scale' sub-submenu menuItem = gtk_menu_item_new_with_label("Scale"); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuItem), submenu); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem); spectrum3dGui.checkMenuText = gtk_check_menu_item_new_with_label("Text (T)"); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(spectrum3dGui.checkMenuText), TRUE); g_signal_connect(G_OBJECT(spectrum3dGui.checkMenuText), "activate", G_CALLBACK(check_menu_text), &spectrum3dGui); gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.checkMenuText); spectrum3dGui.checkMenuLines = gtk_check_menu_item_new_with_label("Lines (L)"); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(spectrum3dGui.checkMenuLines), TRUE); g_signal_connect(G_OBJECT(spectrum3dGui.checkMenuLines), "activate", G_CALLBACK(check_menu_lines), &spectrum3dGui); gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.checkMenuLines); spectrum3dGui.checkMenuPointer = gtk_check_menu_item_new_with_label("Pointer (P)"); g_signal_connect(G_OBJECT(spectrum3dGui.checkMenuPointer), "activate", G_CALLBACK(check_menu_pointer), &spectrum3dGui); gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.checkMenuPointer); submenu = gtk_menu_new();// 'Change/reset view' sub-submenu menuItem = gtk_menu_item_new_with_label("Change/reset view"); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuItem), submenu); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem); spectrum3dGui.reset = gtk_menu_item_new_with_label("Reset view (R)"); gtk_widget_set_tooltip_text (spectrum3dGui.reset, "Reset the view as if Spectrum3d was just started"); g_signal_connect(G_OBJECT(spectrum3dGui.reset), "activate", G_CALLBACK(reset_view), spectrum3dGui.reset); gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.reset); spectrum3dGui.front = gtk_menu_item_new_with_label("Front view (O)"); gtk_widget_set_tooltip_text (spectrum3dGui.front, "2D view showing frequency versus intensity of the sound; shows a snapshot of the harmonics at a given time"); g_signal_connect(G_OBJECT(spectrum3dGui.front), "activate", G_CALLBACK(front_view), spectrum3dGui.front); gtk_menu_shell_append(GTK_MENU_SHELL(submenu), spectrum3dGui.front); submenuItem = gtk_menu_item_new_with_label("Preset view"); gtk_widget_set_tooltip_text (submenuItem, "Set the view with the chosen preset values"); g_signal_connect(G_OBJECT(submenuItem), "activate", G_CALLBACK(set_view_from_preset), submenuItem); gtk_menu_shell_append(GTK_MENU_SHELL(submenu), submenuItem); menu = gtk_menu_new(); // 'Help...' submenu menuItem = gtk_menu_item_new_with_label("Shortcuts"); g_signal_connect(G_OBJECT(menuItem), "activate", G_CALLBACK(onShortcuts), (GtkWidget*) spectrum3dGui.mainWindow); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem); #ifdef HAVE_LIBGEIS menuItem = gtk_menu_item_new_with_label("Gestures Shortcuts"); g_signal_connect(G_OBJECT(menuItem), "activate", G_CALLBACK(onGesturesShortcuts), (GtkWidget*) spectrum3dGui.mainWindow); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem); #endif menuItem = gtk_menu_item_new_with_label("About..."); g_signal_connect(G_OBJECT(menuItem), "activate", G_CALLBACK(onAbout), (GtkWidget*) spectrum3dGui.mainWindow); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem); menuItem = gtk_menu_item_new_with_label("Quick start"); g_signal_connect(G_OBJECT(menuItem), "activate", G_CALLBACK(onQuickStart), (GtkWidget*) spectrum3dGui.mainWindow); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem); menuItem = gtk_menu_item_new_with_label("Help"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuItem), menu); gtk_menu_shell_append(GTK_MENU_SHELL(menuBar), menuItem); gtk_box_pack_start(GTK_BOX(pHBox[0]), menuBar, FALSE, TRUE, 0); /* SourceButtons to set type of source (none, audio file, microphone) */ spectrum3dGui.stop = gtk_button_new(); filename = g_build_filename (G_DIR_SEPARATOR_S, DATADIR, "icons", "stop.png", NULL); image = gtk_image_new_from_file(filename); gtk_button_set_image(GTK_BUTTON(spectrum3dGui.stop),image); gdk_color_parse ("gold",&color); gtk_widget_set_name(spectrum3dGui.stop, "stop"); gtk_widget_modify_bg(GTK_WIDGET(spectrum3dGui.stop), GTK_STATE_NORMAL, &color); gtk_widget_modify_bg(GTK_WIDGET(spectrum3dGui.stop), GTK_STATE_PRELIGHT, &color); gtk_widget_set_tooltip_text (spectrum3dGui.stop, "Stop playing everything; no source of playing"); gtk_box_pack_start(GTK_BOX(pVBox[1]), pHBox[1], FALSE, TRUE, 2); gtk_box_pack_start(GTK_BOX(pHBox[1]), spectrum3dGui.stop, FALSE, TRUE, 2); g_signal_connect(G_OBJECT(spectrum3dGui.stop), "clicked", G_CALLBACK(change_source_button), &spectrum3dGui); filename = g_build_filename (G_DIR_SEPARATOR_S, DATADIR, "icons", "microphone_grey.png", NULL); image = gtk_image_new_from_file(filename); spectrum3dGui.mic = gtk_button_new(); gtk_button_set_image (GTK_BUTTON(spectrum3dGui.mic), image); gtk_widget_set_name(spectrum3dGui.mic, "mic"); gtk_widget_set_tooltip_text (spectrum3dGui.mic, "Source is microphone; select this to record something and then load it"); gtk_box_pack_start(GTK_BOX(pHBox[1]), spectrum3dGui.mic, FALSE, TRUE, 2); g_signal_connect(G_OBJECT(spectrum3dGui.mic), "clicked", G_CALLBACK(change_source_button), &spectrum3dGui); spectrum3dGui.file = gtk_button_new(); filename = g_build_filename (G_DIR_SEPARATOR_S, DATADIR, "icons", "file_grey.png", NULL); image = gtk_image_new_from_file(filename); gtk_button_set_image(GTK_BUTTON(spectrum3dGui.file),image); gtk_widget_set_name(spectrum3dGui.file, "file"); gtk_widget_set_tooltip_text (spectrum3dGui.file, "Source is an audio file"); gtk_box_pack_start(GTK_BOX(pHBox[1]), spectrum3dGui.file, FALSE, FALSE, 2); g_signal_connect(G_OBJECT(spectrum3dGui.file), "clicked", G_CALLBACK(change_source_button), &spectrum3dGui); spectrum3dGui.reload = gtk_button_new(); image = gtk_image_new_from_stock (GTK_STOCK_REFRESH, GTK_ICON_SIZE_LARGE_TOOLBAR); gtk_button_set_image(GTK_BUTTON(spectrum3dGui.reload),image); gtk_widget_set_sensitive (spectrum3dGui.reload, FALSE); gtk_widget_set_tooltip_text (spectrum3dGui.reload, "Reload audio file (usefull if some audio parameters like equalizer or filters have been changed)"); gtk_box_pack_start(GTK_BOX(pHBox[1]), spectrum3dGui.reload, FALSE, FALSE, 2); g_signal_connect(G_OBJECT(spectrum3dGui.reload), "clicked", G_CALLBACK(load_audio_file), NULL); widget = gtk_check_button_new_with_label("Analyse in\nrealtime"); gtk_widget_set_tooltip_text (GTK_WIDGET(widget), "If checked, harmonics will be analysed and displayed at the same time; if unchecked, harmonics will be analysed first, then displayed for the whole audio file, then it can be played afterwards"); gtk_box_pack_start(GTK_BOX(pHBox[1]), widget, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(widget), TRUE); g_signal_connect(G_OBJECT(widget), "toggled", G_CALLBACK(set_analyse_in_rt), &spectrum3dGui); /* separator */ #ifdef GTK3 widget = gtk_separator_new(GTK_ORIENTATION_VERTICAL); #elif defined GTK2 widget = gtk_vseparator_new(); #endif gtk_box_pack_start(GTK_BOX(pHBox[1]), widget, FALSE, FALSE, 5); /* "Play/Pause" button */ playButton = gtk_button_new(); gtk_widget_set_tooltip_text (playButton, "Play/Pause the audio stream"); setPlayButtonIcon(); gtk_widget_set_size_request (playButton, 50, 20); gtk_box_pack_start(GTK_BOX(pHBox[1]), playButton, FALSE, FALSE, 2); g_signal_connect(G_OBJECT(playButton), "clicked", G_CALLBACK(playFromSource), "NO_MESSAGE"); /* "Stop" button */ button = gtk_button_new(); gtk_widget_set_tooltip_text (button, "Stop playing audio stream"); image = gtk_image_new_from_stock (GTK_STOCK_MEDIA_STOP, GTK_ICON_SIZE_SMALL_TOOLBAR); gtk_button_set_image(GTK_BUTTON(button),image); gtk_box_pack_start(GTK_BOX(pHBox[1]), button, FALSE, FALSE, 2); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(on_stop), NULL); /* "Record" button */ spectrum3dGui.record = gtk_button_new(); gtk_widget_set_tooltip_text (spectrum3dGui.record, "Record from microphone"); image = gtk_image_new_from_stock (GTK_STOCK_MEDIA_RECORD, GTK_ICON_SIZE_SMALL_TOOLBAR); gtk_button_set_image(GTK_BUTTON(spectrum3dGui.record),image); gtk_widget_set_sensitive (spectrum3dGui.record, FALSE); gtk_box_pack_start(GTK_BOX(pHBox[1]), spectrum3dGui.record, FALSE, FALSE, 2); g_signal_connect(G_OBJECT(spectrum3dGui.record), "clicked", G_CALLBACK(record_window), NULL); /* separator */ #ifdef GTK3 widget = gtk_separator_new(GTK_ORIENTATION_VERTICAL); #elif defined GTK2 widget = gtk_vseparator_new(); #endif gtk_box_pack_start(GTK_BOX(pHBox[1]), widget, FALSE, FALSE, 5); /* JACK check button */ filename = g_build_filename (G_DIR_SEPARATOR_S, DATADIR, "icons", "qjackctl.png", NULL); image = gtk_image_new_from_file(filename); widget = gtk_check_button_new (); gtk_button_set_image (GTK_BUTTON(widget), image); gtk_widget_set_tooltip_text (widget, "Use Jack-Audio-Connection-Kit (JACK)"); gtk_box_pack_start(GTK_BOX(pHBox[1]), widget, FALSE, FALSE, 2); g_signal_connect(G_OBJECT(widget), "toggled", G_CALLBACK(use_jack), &spectrum3dGui); /* separator */ #ifdef GTK3 widget = gtk_separator_new(GTK_ORIENTATION_VERTICAL); #elif defined GTK2 widget = gtk_vseparator_new(); #endif gtk_box_pack_start(GTK_BOX(pHBox[1]), widget, FALSE, FALSE, 5); /* Button to open the Filter and Equalizer window */ // create effectsWindow first without showing it effects_window(&spectrum3dGui); // then create a button that will call its display when clicked filename = g_build_filename (G_DIR_SEPARATOR_S, DATADIR, "icons", "equalizer.png", NULL); image = gtk_image_new_from_file(filename); widget = gtk_button_new(); gtk_button_set_image (GTK_BUTTON(widget), image); gtk_widget_set_tooltip_text (widget, "Show/Hide the filter and equalizer window"); gtk_box_pack_start(GTK_BOX(pHBox[1]), widget, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(show_effects_window), &spectrum3dGui); /* Time label */ label=gtk_label_new("Time : "); gtk_box_pack_start(GTK_BOX(pHBox[5]), label, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(pVBox[1]), pHBox[5], FALSE, FALSE, 2); /* Progress & seek scale */ #ifdef GTK3 scaleSeek = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0.0, 100.0, 1); #elif defined GTK2 scaleSeek = gtk_hscale_new_with_range (0.0, 100.0, 1); #endif gtk_scale_set_draw_value (GTK_SCALE (scaleSeek), FALSE); //gtk_scale_set_value_pos (GTK_SCALE (pScaleSeek), GTK_POS_TOP); gtk_range_set_value (GTK_RANGE (scaleSeek), 0); gtk_widget_set_size_request (scaleSeek, 500, 20); gtk_box_pack_start(GTK_BOX(pHBox[5]), scaleSeek, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(scaleSeek), "value-changed", G_CALLBACK(on_seek), NULL); timeLabel=gtk_label_new(" 0:00 / 0:00 "); gtk_box_pack_start(GTK_BOX(pHBox[5]), timeLabel, FALSE, FALSE, 0); /* Create drawing area */ if (externalWindow == FALSE){ /* Resize spectrum3dGui.mainWindow to contain drawing_area; using gtk_window_set_defaut() allows to shrink the window (gtk_widget_set_size_request() does not allow to shrink the window below the requested size); */ gtk_window_set_default_size (GTK_WINDOW(spectrum3dGui.mainWindow), (gint)spectrum3d.width, initialWindowHeight + (gint)spectrum3d.height); //gtk_widget_realize(spectrum3dGui.mainWindow); spectrum3dGui.drawing_area = gtk_drawing_area_new (); #if defined (GTKGLEXT3) || defined (GTKGLEXT1) /* Set OpenGL-capability to the widget */ gtk_widget_set_gl_capability (spectrum3dGui.drawing_area, glconfig, NULL, TRUE, GDK_GL_RGBA_TYPE); #endif /* drawing_area has to be put in vBox AFTER the call to gtk_widget_set_gl_capability() (if GtkGlExt is used) and BEFORE the call to the sdl-gtk hack (if sdl is used)*/ gtk_box_pack_start (GTK_BOX (pVBox[1]), spectrum3dGui.drawing_area, TRUE, TRUE, 0); #ifdef HAVE_LIBSDL /* Hack to get SDL to use GTK window */ { char SDL_windowhack[32]; sprintf(SDL_windowhack,"SDL_WINDOWID=%ld", GDK_WINDOW_XID(gtk_widget_get_window(spectrum3dGui.drawing_area))); // GDK_WINDOW_XID( spectrum3dGui.drawing_area->window))); pour GTK2?? putenv(SDL_windowhack); printf("%s\n", SDL_windowhack); } if (SDL_Init(SDL_INIT_VIDEO) < 0) { fprintf(stderr, "Unable to init SDL: %s\n", SDL_GetError()); exit(1); } #endif g_signal_connect (spectrum3dGui.mainWindow, "key-press-event", G_CALLBACK (on_key_press), &spectrum3dGui); g_signal_connect (spectrum3dGui.mainWindow, "key-release-event", G_CALLBACK (on_key_release), &spectrum3dGui); g_signal_connect (spectrum3dGui.mainWindow, "motion-notify-event", G_CALLBACK (on_mouse_motion), NULL); g_signal_connect (spectrum3dGui.mainWindow, "scroll-event", G_CALLBACK (on_mouse_scroll), NULL); g_signal_connect (G_OBJECT (spectrum3dGui.drawing_area), "configure_event", G_CALLBACK (configure_event), NULL); gtk_widget_add_events (spectrum3dGui.mainWindow, gtk_widget_get_events (spectrum3dGui.mainWindow) | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_SCROLL_MASK); } else { create_external_window_drawing_area(&spectrum3dGui); } /* Starting value of the display */ frame = gtk_frame_new("Start value of display (in Hz)"); gtk_widget_set_tooltip_text (frame, "The lower displayed frequency (in herz)"); spectrum3dGui.adjustStart = gtk_adjustment_new(0, 0, 9000, ((gdouble)hzStep * (gdouble)zoomFactor), (((gdouble)hzStep * (gdouble)zoomFactor) * 10), 0); #ifdef GTK3 pScaleStart = gtk_scale_new(GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT(spectrum3dGui.adjustStart)); #elif defined GTK2 pScaleStart = gtk_hscale_new(GTK_ADJUSTMENT(spectrum3dGui.adjustStart)); #endif gtk_scale_set_digits (GTK_SCALE(pScaleStart), 0); gtk_scale_set_value_pos(GTK_SCALE(pScaleStart), GTK_POS_RIGHT); gtk_box_pack_start(GTK_BOX(pVBox[1]), pHBox[11], FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(pHBox[11]), frame, FALSE, FALSE, 0); gtk_container_add(GTK_CONTAINER(frame), pScaleStart); g_signal_connect(G_OBJECT(pScaleStart), "value-changed", G_CALLBACK(change_start), &spectrum3dGui); g_signal_connect(G_OBJECT(pScaleStart), "format-value", G_CALLBACK(format_value_start), NULL); g_signal_connect(G_OBJECT(pScaleStart), "value-changed", G_CALLBACK(getTextDisplayLabel), &spectrum3dGui); /* Range of display */ frame = gtk_frame_new("Range of display (in Hz)"); gtk_widget_set_tooltip_text (frame, "The range of the displayed frequency (in herz)"); spectrum3dGui.adjustBands = gtk_adjustment_new(1000, 20, 1000, 10, 50, 0); #ifdef GTK3 spectrum3dGui.scaleBands = gtk_scale_new(GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT(spectrum3dGui.adjustBands)); #elif defined GTK2 spectrum3dGui.scaleBands = gtk_hscale_new(GTK_ADJUSTMENT(spectrum3dGui.adjustBands)); #endif gtk_scale_set_digits (GTK_SCALE(spectrum3dGui.scaleBands), 0); gtk_scale_set_value_pos(GTK_SCALE(spectrum3dGui.scaleBands), GTK_POS_RIGHT); gtk_container_add(GTK_CONTAINER(frame), spectrum3dGui.scaleBands); gtk_box_pack_start(GTK_BOX(pHBox[11]), frame, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(spectrum3dGui.scaleBands), "value-changed", G_CALLBACK(change_bands), &spectrum3dGui); g_signal_connect(G_OBJECT(spectrum3dGui.scaleBands), "format-value", G_CALLBACK(format_value_bands), NULL); g_signal_connect(G_OBJECT(spectrum3dGui.scaleBands), "value-changed", G_CALLBACK(getTextDisplayLabel), &spectrum3dGui); /* "x" label */ label=gtk_label_new("x"); gtk_container_add(GTK_CONTAINER(pHBox[11]), label); /* Factor that multiplies the range of display */ frame = gtk_frame_new(""); gtk_widget_set_tooltip_text (frame, "Factor that multiplies the frequency range, to make it larger"); spectrum3dGui.cbRange = gtk_combo_box_text_new(); gtk_container_add(GTK_CONTAINER(frame), spectrum3dGui.cbRange); gtk_box_pack_start(GTK_BOX(pHBox[11]), frame, FALSE, FALSE, 0); for (i = 1; i <= 20; i++){ gchar text[4]; sprintf(text, "%d", i); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(spectrum3dGui.cbRange), text); } gtk_combo_box_set_active(GTK_COMBO_BOX(spectrum3dGui.cbRange), 0); g_signal_connect( G_OBJECT(spectrum3dGui.cbRange), "changed", G_CALLBACK( cb_range_changed ), &spectrum3dGui ); g_signal_connect( G_OBJECT(spectrum3dGui.cbRange), "changed", G_CALLBACK(getTextDisplayLabel), &spectrum3dGui ); /* Label that shows starting value, ending value and range of display */ frame = gtk_frame_new("Values displayed"); gtk_widget_set_tooltip_text (frame, "The lower and the highest displayed value (in herz), and their range"); displayLabel=gtk_label_new(""); gtk_container_add(GTK_CONTAINER(frame), displayLabel); getTextDisplayLabel(NULL, &spectrum3dGui); gtk_box_pack_start(GTK_BOX(pHBox[11]), frame, FALSE, FALSE, 0); /* 'Gain' Gtk Scale */ frame = gtk_frame_new("Display Gain"); gtk_box_pack_start(GTK_BOX(pHBox[11]), frame, FALSE, FALSE, 10); filename = g_build_filename (G_DIR_SEPARATOR_S, DATADIR, "icons", "gain.png", NULL); image = gtk_image_new_from_file(filename); spectrum3dGui.scaleGain = gtk_scale_button_new (GTK_ICON_SIZE_LARGE_TOOLBAR, 0, 1, 0.01, NULL); gtk_button_set_image(GTK_BUTTON(spectrum3dGui.scaleGain),image); //gtk_button_set_label (GTK_BUTTON(spectrum3dGui.scaleGain), "GAIN"); gtk_container_add(GTK_CONTAINER(frame), spectrum3dGui.scaleGain); //gtk_box_pack_start(GTK_BOX(pHBox[11]), pScaleGain, FALSE, FALSE, 0); //gtk_widget_set_size_request (pScaleGain, 200, 20); //gtk_scale_set_value_pos(GTK_SCALE(pScaleGain), GTK_POS_RIGHT); gtk_widget_set_tooltip_text (spectrum3dGui.scaleGain, "Adjust the displayed level of the intensity of the sound"); gtk_scale_button_set_value(GTK_SCALE_BUTTON(spectrum3dGui.scaleGain), 0.2); // FIXME error message here with the previous line : gtk_image_set_from_stock: assertion `GTK_IS_IMAGE (image)' failed; it could be a bug in Gtk //g_object_set (pScaleGain, "update-policy", GTK_UPDATE_DISCONTINUOUS, NULL); g_signal_connect(G_OBJECT(spectrum3dGui.scaleGain), "value-changed", G_CALLBACK(change_gain), NULL); #ifdef HAVE_LIBGEIS setupGeis(); #endif gtk_widget_show_all (spectrum3dGui.mainWindow); //timeoutEvent = g_timeout_add (100, (GSourceFunc)sdl_event, &spectrum3dGui); spectrum3d.timeoutExpose = g_timeout_add (intervalDisplaySpectro, (GSourceFunc)display_spectro, &spectrum3dGui); printf("Showing Gtk GUI\n"); gtk_main (); /* Quit everything */ #ifdef HAVE_LIBGEIS geisQuit(); #endif on_stop(); g_source_remove(spectrum3d.timeoutExpose); #ifdef HAVE_LIBSDL //g_source_remove(timeoutEvent); SDL_Quit(); #endif print_rc_file(); printf("Quit everything\nGood Bye!\n"); return 0; }
void wxMenu::GtkAppend(wxMenuItem* mitem, int pos) { GtkWidget *menuItem; switch (mitem->GetKind()) { case wxITEM_SEPARATOR: menuItem = gtk_separator_menu_item_new(); break; case wxITEM_CHECK: menuItem = gtk_check_menu_item_new_with_label(""); break; case wxITEM_RADIO: { // See if we need to create a new radio group for this item or // add it to an existing one. wxMenuItem* radioGroupItem = NULL; const size_t numItems = GetMenuItemCount(); const size_t n = pos == -1 ? numItems - 1 : size_t(pos); if (n != 0) { wxMenuItem* const itemPrev = FindItemByPosition(n - 1); if ( itemPrev->GetKind() == wxITEM_RADIO ) { // Appending an item after an existing radio item puts // it into the same radio group. radioGroupItem = itemPrev; } } if (radioGroupItem == NULL && n != numItems - 1) { wxMenuItem* const itemNext = FindItemByPosition(n + 1); if ( itemNext->GetKind() == wxITEM_RADIO ) { // Inserting an item before an existing radio item // also puts it into the existing radio group. radioGroupItem = itemNext; } } GSList* group = NULL; if ( radioGroupItem ) { group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(radioGroupItem->GetMenuItem()) ); } menuItem = gtk_radio_menu_item_new_with_label(group, ""); } break; default: wxFAIL_MSG("unexpected menu item kind"); // fall through case wxITEM_NORMAL: const wxBitmap& bitmap = mitem->GetBitmap(); const char* stockid; if (bitmap.IsOk()) { // always use pixbuf, because pixmap mask does not // work with disabled images in some themes GtkWidget* image = gtk_image_new_from_pixbuf(bitmap.GetPixbuf()); menuItem = gtk_image_menu_item_new_with_label(""); gtk_widget_show(image); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menuItem), image); } else if ((stockid = wxGetStockGtkID(mitem->GetId())) != NULL) // use stock bitmap for this item if available on the assumption // that it never hurts to follow GTK+ conventions more closely menuItem = gtk_image_menu_item_new_from_stock(stockid, NULL); else menuItem = gtk_menu_item_new_with_label(""); break; } mitem->SetMenuItem(menuItem); gtk_menu_shell_insert(GTK_MENU_SHELL(m_menu), menuItem, pos); gtk_widget_show( menuItem ); if ( !mitem->IsSeparator() ) { mitem->SetGtkLabel(); g_signal_connect (menuItem, "select", G_CALLBACK(menuitem_select), mitem); g_signal_connect (menuItem, "deselect", G_CALLBACK(menuitem_deselect), mitem); if ( mitem->IsSubMenu() && mitem->GetKind() != wxITEM_RADIO && mitem->GetKind() != wxITEM_CHECK ) { gtk_menu_item_set_submenu( GTK_MENU_ITEM(menuItem), mitem->GetSubMenu()->m_menu ); gtk_widget_show( mitem->GetSubMenu()->m_menu ); } else { g_signal_connect(menuItem, "can_activate_accel", G_CALLBACK(can_activate_accel), this); g_signal_connect (menuItem, "activate", G_CALLBACK(menuitem_activate), mitem); } } }
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 int VGUI_init(void) { GtkWidget *box1; GtkWidget *menubar, *submenu, *menuitem; GtkWidget *topitem; GSList *colorgroup; #ifdef USE_THREADING block_thread=g_cond_new(); #endif //printf("VGUI_init\n"); gdk_threads_enter(); Keyboard_Buffer_init(); VGUI.window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (VGUI.window), "posplot"); if (VGUI.width==0) { /* This means that we're executed for the first time */ gtk_window_set_default_size(GTK_WINDOW(VGUI.window), FRAME_SIZE_X, FRAME_SIZE_Y); } else { gtk_window_set_default_size(GTK_WINDOW(VGUI.window), VGUI.width, VGUI.height); } g_signal_connect_object (G_OBJECT (VGUI.window), "delete_event", G_CALLBACK(window_destroy_event), G_OBJECT(VGUI.window), G_CONNECT_SWAPPED); g_signal_connect (G_OBJECT (VGUI.window), "configure_event", G_CALLBACK (window_configure_event), NULL); box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_add (GTK_CONTAINER (VGUI.window), box1); gtk_widget_show (box1); menubar = gtk_menu_bar_new (); gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0); gtk_widget_show (menubar); /* Dataset menu */ submenu=gtk_menu_new(); menuitem=gtk_menu_item_new(); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("quit, accept epoch (q)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"q"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Quit, reject epoch (Q)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"Q"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Quit, reject epoch+stop iterated queue (V)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"V"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Stop (X)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"X"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); /* Separator: */ menuitem=gtk_menu_item_new(); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("About"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(posplot_about), NULL); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); topitem= gtk_menu_item_new_with_label("Quitting"); gtk_menu_item_set_submenu (GTK_MENU_ITEM (topitem), submenu); gtk_menu_shell_append (GTK_MENU_SHELL (menubar), topitem); gtk_widget_show (topitem); /* Catch Keypress events also when the mouse points to the open menu: */ g_signal_connect (G_OBJECT (submenu), "key_press_event", G_CALLBACK (key_press_event), NULL); /* Command menu */ submenu=gtk_menu_new(); menuitem=gtk_menu_item_new(); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); /* Antialiasing doesn't look nice with lines */ VGUI.antialias=CAIRO_ANTIALIAS_NONE; menuitem=gtk_check_menu_item_new_with_label("Antialias screen plot lines"); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem), VGUI.antialias==CAIRO_ANTIALIAS_DEFAULT); g_signal_connect (G_OBJECT (menuitem), "toggled", G_CALLBACK(toggle_antialias), NULL); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); /* Separator: */ menuitem=gtk_menu_item_new(); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Start entering an argument (=)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"="); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); /* Separator: */ menuitem=gtk_menu_item_new(); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Insert trigger (N)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"N"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); /* Separator: */ menuitem=gtk_menu_item_new(); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Record interactions (r)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"r"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Replay interactions (R)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"R"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); /* Separator: */ menuitem=gtk_menu_item_new(); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Landscape postscript dump (o)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"o"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Portrait postscript dump (O)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"O"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_radio_menu_item_new_with_label(NULL, "Color postscript"); colorgroup=gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(menuitem)); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(set_postscriptcolor), (gpointer)TRUE); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_radio_menu_item_new_with_label(colorgroup, "B/W postscript"); colorgroup=gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(menuitem)); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(set_postscriptcolor), (gpointer)FALSE); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); { char * const post_dev=getenv(POSTSCRIPT_ENVNAME); /* posplot's default is color Postscript */ if (post_dev!=NULL && strcmp(post_dev, POSTSCRIPT_BWDEV)==0) gtk_widget_activate(menuitem); } /* Separator: */ menuitem=gtk_menu_item_new(); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Dump current point as ARRAY_ASCII (y)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"y"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Dump current point full (Y)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"Y"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Write datasets (W)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"W"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); /* Separator: */ menuitem=gtk_menu_item_new(); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Grid channels (G)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"G"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Enter pos modify mode"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"=change\n_"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Leave/switch pos mode (_)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"_"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); /* Separator: */ menuitem=gtk_menu_item_new(); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Zero current point ($)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"$"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Detrend datasets (D)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"D"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Differentiate datasets (%)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"%"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Integrate datasets (&)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"&"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); topitem= gtk_menu_item_new_with_label("Commands"); gtk_menu_item_set_submenu (GTK_MENU_ITEM (topitem), submenu); gtk_menu_shell_append (GTK_MENU_SHELL (menubar), topitem); gtk_widget_show (topitem); /* Catch Keypress events also when the mouse points to the open menu: */ g_signal_connect (G_OBJECT (submenu), "key_press_event", G_CALLBACK (key_press_event), NULL); /* Show menu */ submenu=gtk_menu_new(); menuitem=gtk_menu_item_new(); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Plots (p)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"p"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Axes (x)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"x"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Names (n)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"n"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Marker (m)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"m"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Triggers (M)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"M"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Grayscale (d)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"d"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Info (?)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"?"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Triangulation (z)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"z"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); topitem= gtk_menu_item_new_with_label("Show"); gtk_menu_item_set_submenu (GTK_MENU_ITEM (topitem), submenu); gtk_menu_shell_append (GTK_MENU_SHELL (menubar), topitem); gtk_widget_show (topitem); /* Catch Keypress events also when the mouse points to the open menu: */ g_signal_connect (G_OBJECT (submenu), "key_press_event", G_CALLBACK (key_press_event), NULL); /* Select menu */ submenu=gtk_menu_new(); menuitem=gtk_menu_item_new(); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Point by argument (.)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"."); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Next point (i)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"i"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Previous point (I)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"I"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Left interval boundary ([)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"["); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Right interval boundary (])"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"]"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); /* Separator: */ menuitem=gtk_menu_item_new(); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Dataset by argument (,)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)","); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Toggle datasets (*)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"*"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Datasets up '('"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"("); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Datasets down ')'"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)")"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); /* Separator: */ menuitem=gtk_menu_item_new(); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Next item (})"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"}"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Previous item ({)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"{"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); /* Separator: */ menuitem=gtk_menu_item_new(); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("One channel (ENTER)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"\n"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Hide channel (BACKSPACE)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)""); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("All channels (C)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"C"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); topitem= gtk_menu_item_new_with_label("Select"); gtk_menu_item_set_submenu (GTK_MENU_ITEM (topitem), submenu); gtk_menu_shell_append (GTK_MENU_SHELL (menubar), topitem); gtk_widget_show (topitem); /* Catch Keypress events also when the mouse points to the open menu: */ g_signal_connect (G_OBJECT (submenu), "key_press_event", G_CALLBACK (key_press_event), NULL); /* Transform menu */ submenu=gtk_menu_new(); menuitem=gtk_menu_item_new(); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Exponential (e)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"e"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Logarithm (E)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"E"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); /* Separator: */ menuitem=gtk_menu_item_new(); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Single item mode (')"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"'"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Absolute values (a)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"a"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Power values (P)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"P"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Phase values (A)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"A"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); topitem= gtk_menu_item_new_with_label("Transform"); gtk_menu_item_set_submenu (GTK_MENU_ITEM (topitem), submenu); gtk_menu_shell_append (GTK_MENU_SHELL (menubar), topitem); gtk_widget_show (topitem); /* Catch Keypress events also when the mouse points to the open menu: */ g_signal_connect (G_OBJECT (submenu), "key_press_event", G_CALLBACK (key_press_event), NULL); /* View menu */ submenu=gtk_menu_new(); menuitem=gtk_menu_item_new(); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Redraw (^L)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)""); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Vertical scale lock (v)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"v"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Set/Toggle subsampling (@)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"@"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Toggle black/white background (b)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"b"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Line style mode (u)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"u"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Set first line style (U)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"U"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Swap plus/minus (~)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"~"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Swap x-z (S)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"S"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); /* Separator: */ menuitem=gtk_menu_item_new(); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Position mode (_)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"_"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Center channel (Z)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"Z"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Nearer (+)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"+"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Farther (-)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"-"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Turn l (h)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"h"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Turn r (l)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"l"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Turn u (k)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"k"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Turn d (j)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"j"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Twist l (t)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"t"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Twist r (T)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"T"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Enlarge FOV (/)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"/"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Decrease FOV (\\)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"\\"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Enlarge plots (>)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)">"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Shrink plots (<)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"<"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); menuitem=gtk_menu_item_new_with_label("Reset parameters (c)"); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK(insert_key), (gpointer)"c"); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); topitem= gtk_menu_item_new_with_label("View"); gtk_menu_item_set_submenu (GTK_MENU_ITEM (topitem), submenu); gtk_menu_shell_append (GTK_MENU_SHELL (menubar), topitem); gtk_widget_show (topitem); /* Catch Keypress events also when the mouse points to the open menu: */ g_signal_connect (G_OBJECT (submenu), "key_press_event", G_CALLBACK (key_press_event), NULL); VGUI.cr = NULL; /* Allocated by canvas_configure_event */ VGUI.surface = NULL; VGUI.canvas = gtk_drawing_area_new (); gtk_widget_set_name (VGUI.canvas, "posplot"); gtk_box_pack_start (GTK_BOX (box1), VGUI.canvas, TRUE, TRUE, 0); /* Otherwise, a DrawingArea cannot receive key presses: */ gtk_widget_set_can_focus(VGUI.canvas, TRUE); gtk_widget_set_events(VGUI.canvas, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_KEY_PRESS_MASK | GDK_PROPERTY_CHANGE_MASK); g_signal_connect (G_OBJECT (VGUI.canvas), "configure_event", G_CALLBACK (canvas_configure_event), NULL); #if GTK_MAJOR_VERSION==2 g_signal_connect (G_OBJECT (VGUI.canvas), "expose_event", G_CALLBACK (canvas_expose_event), NULL); #else g_signal_connect (G_OBJECT (VGUI.canvas), "draw", G_CALLBACK (canvas_draw_event), NULL); #endif g_signal_connect (G_OBJECT (VGUI.canvas), "key_press_event", G_CALLBACK (key_press_event), NULL); g_signal_connect (G_OBJECT (VGUI.canvas), "button_press_event", G_CALLBACK (button_press_event), NULL); g_signal_connect (G_OBJECT (VGUI.canvas), "motion_notify_event", G_CALLBACK (motion_notify_event), NULL); gtk_widget_show (VGUI.canvas); gtk_widget_grab_focus(VGUI.canvas); gtk_widget_show (VGUI.window); VGUI.lastbutton=0; VGUI.in_frontbuffer=FALSE; gdk_threads_leave(); /* Set the colors */ VGUI.fg = BLACK; set_palette_entry(BLACK, 0.0, 0.0, 0.0); set_palette_entry(RED, 1.0, 0.0, 0.0); set_palette_entry(GREEN, 0.0, 1.0, 0.0); set_palette_entry(YELLOW, 1.0, 1.0, 0.0); set_palette_entry(BLUE, 0.0, 0.0, 1.0); set_palette_entry(MAGENTA, 1.0, 0.0, 1.0); set_palette_entry(CYAN, 0.0, 1.0, 1.0); set_palette_entry(WHITE, 1.0, 1.0, 1.0); //printf("VGUI_init end\n"); return (1); }
GtkWidget *trg_tree_view_sort_menu(TrgTreeView * tv, const gchar * label) { TrgTreeViewPrivate *priv = TRG_TREE_VIEW_GET_PRIVATE(tv); GtkWidget *item = gtk_menu_item_new_with_mnemonic(label); GtkTreeModel *treeViewModel = gtk_tree_view_get_model(GTK_TREE_VIEW(tv)); GtkTreeSortable *sortableModel = GTK_TREE_SORTABLE(gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER(treeViewModel))); GtkWidget *menu = gtk_menu_new(); GtkWidget *b; GList *li; gint sort; GtkSortType sortType; GSList *group = NULL; gtk_tree_sortable_get_sort_column_id(sortableModel, &sort, &sortType); b = gtk_radio_menu_item_new_with_label(group, _("Ascending")); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(b), sortType == GTK_SORT_ASCENDING); g_object_set_data(G_OBJECT(b), "sort-type", GINT_TO_POINTER(GTK_SORT_ASCENDING)); g_signal_connect(b, "toggled", G_CALLBACK(trg_tree_view_sort_menu_type_toggled), sortableModel); gtk_menu_shell_append(GTK_MENU_SHELL(menu), b); group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(b)); b = gtk_radio_menu_item_new_with_label(group, _("Descending")); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(b), sortType == GTK_SORT_DESCENDING); g_object_set_data(G_OBJECT(b), "sort-type", GINT_TO_POINTER(GTK_SORT_DESCENDING)); g_signal_connect(b, "toggled", G_CALLBACK(trg_tree_view_sort_menu_type_toggled), sortableModel); gtk_menu_shell_append(GTK_MENU_SHELL(menu), b); group = NULL; gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new()); for (li = priv->columns; li; li = g_list_next(li)) { trg_column_description *desc = (trg_column_description *) li->data; if (!(desc->flags & TRG_COLUMN_HIDE_FROM_TOP_MENU)) { b = gtk_radio_menu_item_new_with_label(group, desc->header); group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(b)); if (desc->model_column == sort) gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(b), TRUE); g_object_set_data(G_OBJECT(b), GDATA_KEY_COLUMN_DESC, desc); g_signal_connect(b, "toggled", G_CALLBACK (trg_tree_view_sort_menu_item_toggled), sortableModel); gtk_menu_shell_append(GTK_MENU_SHELL(menu), b); } } gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), menu); return item; }
bool wxMenu::GtkAppend(wxMenuItem *mitem, int pos) { GtkWidget *menuItem; wxString text; GtkLabel* label = NULL; if ( mitem->IsSeparator() ) { // TODO menuItem = gtk_menu_item_new(); } else if (mitem->GetBitmap().IsOk()) { text = mitem->wxMenuItemBase::GetItemLabel(); const wxBitmap *bitmap = &mitem->GetBitmap(); // TODO wxUnusedVar(bitmap); menuItem = gtk_menu_item_new_with_label( wxGTK_CONV( text ) ); label = GTK_LABEL( GTK_BIN(menuItem)->child ); m_prevRadio = NULL; } else // a normal item { // text has "_" instead of "&" after mitem->SetItemLabel() so don't use it text = mitem->wxMenuItemBase::GetItemLabel() ; switch ( mitem->GetKind() ) { case wxITEM_CHECK: { menuItem = gtk_check_menu_item_new_with_label( wxGTK_CONV( text ) ); label = GTK_LABEL( GTK_BIN(menuItem)->child ); // set new text gtk_label_set_text( label, wxGTK_CONV( text ) ); m_prevRadio = NULL; break; } case wxITEM_RADIO: { GSList *group = NULL; if ( m_prevRadio == NULL ) { // start of a new radio group m_prevRadio = menuItem = gtk_radio_menu_item_new_with_label( group, wxGTK_CONV( text ) ); label = GTK_LABEL( GTK_BIN(menuItem)->child ); // set new text gtk_label_set_text( label, wxGTK_CONV( text ) ); } else // continue the radio group { group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (m_prevRadio)); m_prevRadio = menuItem = gtk_radio_menu_item_new_with_label( group, wxGTK_CONV( text ) ); label = GTK_LABEL( GTK_BIN(menuItem)->child ); } break; } default: wxFAIL_MSG( wxT("unexpected menu item kind") ); // fall through case wxITEM_NORMAL: { menuItem = gtk_menu_item_new_with_label( wxGTK_CONV( text ) ); label = GTK_LABEL( GTK_BIN(menuItem)->child ); m_prevRadio = NULL; break; } } } guint accel_key; GdkModifierType accel_mods; wxCharBuffer buf = wxGTK_CONV( GetGtkHotKey(*mitem) ); // wxPrintf( wxT("item: %s hotkey %s\n"), mitem->GetItemLabel().c_str(), GetGtkHotKey(*mitem).c_str() ); gtk_accelerator_parse( (const char*) buf, &accel_key, &accel_mods); if (accel_key != 0) { gtk_widget_add_accelerator (GTK_WIDGET(menuItem), "activate", m_accel, accel_key, accel_mods, GTK_ACCEL_VISIBLE); } if (pos == -1) gtk_menu_shell_append(GTK_MENU_SHELL(m_menu), menuItem); else gtk_menu_shell_insert(GTK_MENU_SHELL(m_menu), menuItem, pos); gtk_widget_show( menuItem ); if ( !mitem->IsSeparator() ) { wxASSERT_MSG( menuItem, wxT("invalid menuitem") ); gtk_signal_connect( GTK_OBJECT(menuItem), "select", GTK_SIGNAL_FUNC(gtk_menu_hilight_callback), (gpointer)this ); gtk_signal_connect( GTK_OBJECT(menuItem), "deselect", GTK_SIGNAL_FUNC(gtk_menu_nolight_callback), (gpointer)this ); if ( mitem->IsSubMenu() && mitem->GetKind() != wxITEM_RADIO && mitem->GetKind() != wxITEM_CHECK ) { gtk_menu_item_set_submenu( GTK_MENU_ITEM(menuItem), mitem->GetSubMenu()->m_menu ); gtk_widget_show( mitem->GetSubMenu()->m_menu ); } else { gtk_signal_connect( GTK_OBJECT(menuItem), "activate", GTK_SIGNAL_FUNC(gtk_menu_clicked_callback), (gpointer)this ); } guint accel_key = gtk_label_parse_uline (GTK_LABEL(label), wxGTK_CONV( text ) ); if (accel_key != GDK_VoidSymbol) { gtk_widget_add_accelerator (menuItem, "activate_item", gtk_menu_ensure_uline_accel_group(GTK_MENU(m_menu)), accel_key, GDK_MOD1_MASK, GTK_ACCEL_LOCKED); } } mitem->SetMenuItem(menuItem); if (ms_locked) { // This doesn't even exist! // gtk_widget_lock_accelerators(mitem->GetMenuItem()); } return true; }
static GtkMenu * create_menu (StatusNotifierItem *sn, GMainLoop *loop) { GtkMenu *menu; GtkMenu *submenu; GtkWidget *item; guint i; StatusNotifierStatus status; GSList *group = NULL; menu = (GtkMenu *) gtk_menu_new (); submenu = (GtkMenu *) gtk_menu_new (); g_object_get (sn, "status", &status, NULL); i = 0; item = gtk_radio_menu_item_new_with_label (group, "Passive"); group = gtk_radio_menu_item_get_group ((GtkRadioMenuItem *) item); if (status == STATUS_NOTIFIER_STATUS_PASSIVE) gtk_check_menu_item_set_active ((GtkCheckMenuItem *) item, TRUE); g_object_set_data ((GObject *) item, "sn-status", GUINT_TO_POINTER (STATUS_NOTIFIER_STATUS_PASSIVE)); gtk_widget_show (item); gtk_menu_attach (submenu, item, 0, 1, i, i + 1); ++i; item = gtk_radio_menu_item_new_with_label (group, "Active"); group = gtk_radio_menu_item_get_group ((GtkRadioMenuItem *) item); if (status == STATUS_NOTIFIER_STATUS_ACTIVE) gtk_check_menu_item_set_active ((GtkCheckMenuItem *) item, TRUE); g_object_set_data ((GObject *) item, "sn-status", GUINT_TO_POINTER (STATUS_NOTIFIER_STATUS_ACTIVE)); gtk_widget_show (item); gtk_menu_attach (submenu, item, 0, 1, i, i + 1); ++i; item = gtk_radio_menu_item_new_with_label (group, "Needs attention"); group = gtk_radio_menu_item_get_group ((GtkRadioMenuItem *) item); if (status == STATUS_NOTIFIER_STATUS_NEEDS_ATTENTION) gtk_check_menu_item_set_active ((GtkCheckMenuItem *) item, TRUE); g_object_set_data ((GObject *) item, "sn-status", GUINT_TO_POINTER (STATUS_NOTIFIER_STATUS_NEEDS_ATTENTION)); gtk_widget_show (item); gtk_menu_attach (submenu, item, 0, 1, i, i + 1); ++i; g_slist_foreach (group, &set_status_activation_trigger, sn); i = 0; item = gtk_menu_item_new_with_label ("Status"); gtk_menu_item_set_submenu ((GtkMenuItem *) item, (GtkWidget *) submenu); gtk_widget_show (item); gtk_menu_attach (menu, item, 0, 1, i, i + 1); ++i; item = gtk_menu_item_new_with_label ("Exit"); g_signal_connect_swapped (item, "activate", (GCallback) g_main_loop_quit, loop); gtk_widget_show (item); gtk_menu_attach (menu, item, 0, 1, i, i + 1); ++i; return menu; }
int main (int argc, char *argv[]) { int i; const char *commandLine_File = NULL; GtkWidget *pVBox; GtkWidget *pMenuBar; GtkWidget *pMenu, *pSubMenu; GtkWidget *pMenuItem, *pSubMenuItem; GtkAccelGroup * accel_group; if(argc == 2) commandLine_File = argv[1]; #ifdef DEBUG LogStart(); #endif gtk_init(&argc, &argv); SDL_Init(SDL_INIT_VIDEO); desmume_init(); dTools_running = (BOOL*)malloc(sizeof(BOOL) * dTools_list_size); for(i=0; i<dTools_list_size; i++) dTools_running[i]=FALSE; CONFIG_FILE = g_build_filename(g_get_home_dir(), ".desmume.ini", NULL); Read_ConfigFile(); /* Creation de la fenetre */ pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(pWindow), "Desmume"); gtk_window_set_policy (GTK_WINDOW (pWindow), FALSE, FALSE, FALSE); gtk_window_set_icon(GTK_WINDOW (pWindow), gdk_pixbuf_new_from_xpm_data(DeSmuME_xpm)); g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL); g_signal_connect(G_OBJECT(pWindow), "key_press_event", G_CALLBACK(Key_Press), NULL); g_signal_connect(G_OBJECT(pWindow), "key_release_event", G_CALLBACK(Key_Release), NULL); /* Creation de la GtkVBox */ pVBox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(pWindow), pVBox); accel_group = gtk_accel_group_new(); action_group = gtk_action_group_new("dui"); gtk_action_group_add_actions(action_group, action_entries, sizeof(action_entries) / sizeof(GtkActionEntry), pWindow); { GList * list = gtk_action_group_list_actions(action_group); g_list_foreach(list, dui_set_accel_group, accel_group); } gtk_window_add_accel_group(GTK_WINDOW(pWindow), accel_group); gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "pause"), FALSE); gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "run"), FALSE); gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "reset"), FALSE); gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "printscreen"), FALSE); /**** Creation du menu ****/ pMenuBar = gtk_menu_bar_new(); /** Menu "Fichier" **/ pMenu = gtk_menu_new(); gtk_container_add(GTK_CONTAINER(pMenu), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "open"))); gtk_container_add(GTK_CONTAINER(pMenu), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "printscreen"))); gtk_container_add(GTK_CONTAINER(pMenu), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "quit"))); pMenuItem = gtk_menu_item_new_with_label("File"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), pMenu); gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem); /** Menu "Emulation" **/ GtkWidget *mEmulation; GtkWidget *mFrameskip; GtkWidget *mFrameskip_Radio[MAX_FRAMESKIP]; GtkWidget *mGraphics; GtkWidget *mSize; GtkWidget *mSize_Radio[MAX_SCREENCOEFF]; GtkWidget *mLayers; GtkWidget *mLayers_Radio[10]; mEmulation = gtk_menu_new(); pMenuItem = gtk_menu_item_new_with_label("Emulation"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mEmulation); gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem); gtk_container_add(GTK_CONTAINER(mEmulation), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "run"))); gtk_container_add(GTK_CONTAINER(mEmulation), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "pause"))); gtk_container_add(GTK_CONTAINER(mEmulation), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "reset"))); mFrameskip = gtk_menu_new(); pMenuItem = gtk_menu_item_new_with_label("Frameskip"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mFrameskip); gtk_menu_shell_append(GTK_MENU_SHELL(mEmulation), pMenuItem); for(i = 0; i < MAX_FRAMESKIP; i++) { char frameskipRadio_buf[16]; sprintf(frameskipRadio_buf, "%d", i); if(i>0) mFrameskip_Radio[i] = gtk_radio_menu_item_new_with_label_from_widget(GTK_RADIO_MENU_ITEM(mFrameskip_Radio[i-1]), frameskipRadio_buf); else mFrameskip_Radio[i] = gtk_radio_menu_item_new_with_label(NULL, frameskipRadio_buf); g_signal_connect(G_OBJECT(mFrameskip_Radio[i]), "activate", G_CALLBACK(Modify_Frameskip), GINT_TO_POINTER(i)); gtk_menu_shell_append(GTK_MENU_SHELL(mFrameskip), mFrameskip_Radio[i]); } gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mFrameskip_Radio[0]), TRUE); mGraphics = gtk_menu_new(); pMenuItem = gtk_menu_item_new_with_label("Graphics"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mGraphics); gtk_menu_shell_append(GTK_MENU_SHELL(mEmulation), pMenuItem); // TODO: Un jour, peut être... >< mSize = gtk_menu_new(); pMenuItem = gtk_menu_item_new_with_label("Size"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mSize); gtk_menu_shell_append(GTK_MENU_SHELL(mGraphics), pMenuItem); for(i = 1; i < MAX_SCREENCOEFF; i++) { char sizeRadio_buf[16]; sprintf(sizeRadio_buf, "x%d", i); if(i>1) mSize_Radio[i] = gtk_radio_menu_item_new_with_label_from_widget(GTK_RADIO_MENU_ITEM(mSize_Radio[i-1]), sizeRadio_buf); else mSize_Radio[i] = gtk_radio_menu_item_new_with_label(NULL, sizeRadio_buf); g_signal_connect(G_OBJECT(mSize_Radio[i]), "activate", G_CALLBACK(Modify_ScreenCoeff), GINT_TO_POINTER(i)); gtk_menu_shell_append(GTK_MENU_SHELL(mSize), mSize_Radio[i]); } gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mFrameskip_Radio[0]), TRUE); mLayers = gtk_menu_new(); pMenuItem = gtk_menu_item_new_with_label("Layers"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mLayers); gtk_menu_shell_append(GTK_MENU_SHELL(mGraphics), pMenuItem); for(i = 0; i < 10; i++) { mLayers_Radio[i] = gtk_check_menu_item_new_with_label(Layers_Menu[i]); g_signal_connect(G_OBJECT(mLayers_Radio[i]), "activate", G_CALLBACK(Modify_Layer), (void*)Layers_Menu[i]); gtk_menu_shell_append(GTK_MENU_SHELL(mLayers), mLayers_Radio[i]); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mLayers_Radio[i]), TRUE); } /** Menu "Options" **/ GtkWidget *mConfig = gtk_menu_new(); pMenuItem = gtk_menu_item_new_with_label("Config"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mConfig); gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem); pMenuItem = gtk_menu_item_new_with_label("Edit controls"); g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(Edit_Controls), (GtkWidget*) pWindow); gtk_menu_shell_append(GTK_MENU_SHELL(mConfig), pMenuItem); #if 0 GtkWidget *mFirmware; mFirmware = gtk_menu_new(); pMenuItem = gtk_menu_item_new_with_label("Firmware"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mFirmware); gtk_menu_shell_append(GTK_MENU_SHELL(mConfig), pMenuItem); pMenuItem = gtk_menu_item_new_with_label("Select..."); g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(SelectFirmwareFile), (gpointer)0); gtk_menu_shell_append(GTK_MENU_SHELL(mFirmware), pMenuItem); pMenuItem = gtk_menu_item_new_with_label("Config"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mConfig); gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem); #endif /** Menu "Outils" **/ pMenu = gtk_menu_new(); for(i = 0; i < dTools_list_size; i++) { pMenuItem = gtk_menu_item_new_with_label(dTools_list[i]->name); g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(Start_dTool), GINT_TO_POINTER(i)); gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem); } pMenuItem = gtk_menu_item_new_with_label("Tools"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), pMenu); gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem); /** Menu "?" **/ pMenu = gtk_menu_new(); #if ((GTK_MAJOR_VERSION >= 2) && (GTK_MINOR_VERSION >= 6)) pMenuItem = gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT,NULL); #else pMenuItem = gtk_menu_item_new_with_label("About"); #endif g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(About), (GtkWidget*) pWindow); gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem); pMenuItem = gtk_menu_item_new_with_label("?"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), pMenu); gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem); /* Ajout du menu a la fenetre */ gtk_box_pack_start(GTK_BOX(pVBox), pMenuBar, FALSE, FALSE, 0); /* Création de la Toolbar */ pToolbar = gtk_toolbar_new(); gtk_box_pack_start(GTK_BOX(pVBox), pToolbar, FALSE, FALSE, 0); gtk_toolbar_insert(GTK_TOOLBAR(pToolbar), GTK_TOOL_ITEM(gtk_action_create_tool_item(gtk_action_group_get_action(action_group, "open"))), -1); gtk_toolbar_insert(GTK_TOOLBAR(pToolbar), GTK_TOOL_ITEM(gtk_action_create_tool_item(gtk_action_group_get_action(action_group, "run"))), -1); gtk_toolbar_insert(GTK_TOOLBAR(pToolbar), GTK_TOOL_ITEM(gtk_action_create_tool_item(gtk_action_group_get_action(action_group, "pause"))), -1); gtk_toolbar_insert(GTK_TOOLBAR(pToolbar), GTK_TOOL_ITEM(gtk_action_create_tool_item(gtk_action_group_get_action(action_group, "quit"))), -1); /* Création de l'endroit pour l'affichage des écrans */ pDrawingArea= gtk_drawing_area_new(); gtk_drawing_area_size(GTK_DRAWING_AREA(pDrawingArea), 256, 384); gtk_widget_set_usize (pDrawingArea, 256, 384); gtk_widget_set_events(pDrawingArea, GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_KEY_PRESS_MASK ); g_signal_connect(G_OBJECT(pDrawingArea), "button_press_event", G_CALLBACK(Stylus_Press), NULL); g_signal_connect(G_OBJECT(pDrawingArea), "button_release_event", G_CALLBACK(Stylus_Release), NULL); g_signal_connect(G_OBJECT(pDrawingArea), "motion_notify_event", G_CALLBACK(Stylus_Move), NULL); g_signal_connect( G_OBJECT(pDrawingArea), "realize", G_CALLBACK(Draw), NULL ) ; g_signal_connect( G_OBJECT(pDrawingArea), "expose_event", G_CALLBACK(gtkFloatExposeEvent), NULL ) ; gtk_box_pack_start(GTK_BOX(pVBox), pDrawingArea, FALSE, FALSE, 0); /* Création de la barre d'état */ pStatusBar = gtk_statusbar_new(); pStatusBar_Ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(pStatusBar), "Global"); pStatusBar_Change("Desmume"); gtk_box_pack_end(GTK_BOX(pVBox), pStatusBar, FALSE, FALSE, 0); gtk_widget_show_all(pWindow); //LoadFirmware("fw.bin"); /* Vérifie la ligne de commandes */ if(commandLine_File) { if(Open(commandLine_File) >= 0) { Launch(); } else { GtkWidget *pDialog = gtk_message_dialog_new(GTK_WINDOW(pWindow), GTK_DIALOG_MODAL, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, "Unable to load :\n%s", commandLine_File); gtk_dialog_run(GTK_DIALOG(pDialog)); gtk_widget_destroy(pDialog); } } /* Boucle principale */ // gtk_idle_add(&EmuLoop, pWindow); // g_idle_add(&EmuLoop, pWindow); gtk_main(); desmume_free(); #ifdef DEBUG LogStop(); #endif SDL_Quit(); Write_ConfigFile(); return EXIT_SUCCESS; }
GuiObject GuiMenu_addItem (GuiObject menu, const wchar_t *title, long flags, void (*commandCallback) (GuiObject, XtPointer, XtPointer), const void *closure) { Boolean toggle = flags & (GuiMenu_CHECKBUTTON | GuiMenu_RADIO_FIRST | GuiMenu_RADIO_NEXT | GuiMenu_TOGGLE_ON) ? True : False; GuiObject button; int accelerator = flags & 127; Melder_assert (title != NULL); if (toggle) { if (flags & (GuiMenu_RADIO_FIRST)) group = NULL; if (flags & (GuiMenu_RADIO_FIRST | GuiMenu_RADIO_NEXT)) { button = gtk_radio_menu_item_new_with_label (group, Melder_peekWcsToUtf8 (title)); group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (button)); //Melder_casual ("Created a radio menu item with title %ls, group %ld", title, group); } else { button = gtk_check_menu_item_new_with_label (Melder_peekWcsToUtf8 (title)); } } else { button = gtk_menu_item_new_with_label (Melder_peekWcsToUtf8 (title)); } gtk_menu_shell_append (GTK_MENU_SHELL (menu), button); Melder_assert (button != NULL); if (flags & GuiMenu_INSENSITIVE) GuiObject_setSensitive (button, false); if (flags & GuiMenu_TOGGLE_ON) gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (button), TRUE); if (accelerator) { /* * For printable characters, the Command key is assumed. */ if (accelerator >= 32) flags |= GuiMenu_COMMAND; static const guint acceleratorKeys [] = { 0, GDK_Left, GDK_Right, GDK_Up, GDK_Down, GDK_Pause, GDK_Delete, GDK_Insert, GDK_BackSpace, GDK_Tab, GDK_Return, GDK_Home, GDK_End, GDK_Return, GDK_Page_Up, GDK_Page_Down, GDK_Escape, GDK_F1, GDK_F2, GDK_F3, GDK_F4, GDK_F5, GDK_F6, GDK_F7, GDK_F8, GDK_F9, GDK_F10, GDK_F11, GDK_F12, 0, 0, 0 }; int modifiers = 0; if (flags & GuiMenu_COMMAND) modifiers |= GDK_CONTROL_MASK; if (flags & GuiMenu_SHIFT) modifiers |= GDK_SHIFT_MASK; if (flags & GuiMenu_OPTION) modifiers |= GDK_MOD1_MASK; guint key; if (accelerator < 32) { key = acceleratorKeys [accelerator]; } else { // gdk key symbols in the ASCII range are equal to ASCII key = accelerator; } GtkAccelGroup *ag = gtk_menu_get_accel_group (GTK_MENU (menu)); if (key != 0) gtk_widget_add_accelerator (button, toggle ? "toggled" : "activate", ag, key, (GdkModifierType)modifiers, GTK_ACCEL_VISIBLE); } #if mac if (flags & GuiMenu_ATTRACTIVE) { //Melder_casual ("attractive!"); SetItemStyle (button -> nat.entry.handle, button -> nat.entry.item, bold); } #endif if (commandCallback != NULL) { gulong handlerId = g_signal_connect (G_OBJECT (button), toggle ? "toggled" : "activate", G_CALLBACK (commandCallback), (gpointer) closure); g_object_set_data (G_OBJECT (button), "handlerId", (gpointer) handlerId); g_object_set_data (G_OBJECT (button), "commandCallback", (gpointer) commandCallback); g_object_set_data (G_OBJECT (button), "commandClosure", (gpointer) closure); } else { gtk_widget_set_sensitive (button, FALSE); } gtk_widget_show (button); return button; }