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;
}
