void pMenu::constructor() {
gtkMenu = gtk_menu_new();
widget = gtk_image_menu_item_new_with_mnemonic("");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(widget), gtkMenu);
setText(menu.state.text);
}
static GObject *
matewnck_action_menu_constructor (GType type,
guint n_construct_properties,
GObjectConstructParam *construct_properties)
{
GObject *obj;
MatewnckActionMenu *menu;
MatewnckActionMenuPrivate *priv;
GtkWidget *submenu;
GtkWidget *separator;
GSList *pin_group;
MatewnckScreen *screen;
obj = G_OBJECT_CLASS (matewnck_action_menu_parent_class)->constructor (type,
n_construct_properties,
construct_properties);
menu = MATEWNCK_ACTION_MENU (obj);
priv = menu->priv;
if (priv->window == NULL)
{
g_warning ("No window specified during creation of the action menu");
return obj;
}
g_object_weak_ref (G_OBJECT (priv->window), window_weak_notify, menu);
g_object_weak_ref (G_OBJECT (menu), object_weak_notify, priv->window);
priv->minimize_item = make_menu_item (MINIMIZE);
gtk_menu_shell_append (GTK_MENU_SHELL (menu),
priv->minimize_item);
priv->maximize_item = make_menu_item (MAXIMIZE);
gtk_menu_shell_append (GTK_MENU_SHELL (menu),
priv->maximize_item);
priv->move_item = make_menu_item (MOVE);
gtk_menu_shell_append (GTK_MENU_SHELL (menu),
priv->move_item);
set_item_text (priv->move_item, _("_Move"));
set_item_stock (priv->move_item, NULL);
priv->resize_item = make_menu_item (RESIZE);
gtk_menu_shell_append (GTK_MENU_SHELL (menu),
priv->resize_item);
set_item_text (priv->resize_item, _("_Resize"));
set_item_stock (priv->move_item, NULL);
priv->workspace_separator = separator = gtk_separator_menu_item_new ();
gtk_widget_show (separator);
gtk_menu_shell_append (GTK_MENU_SHELL (menu),
separator);
priv->above_item = make_check_menu_item (ABOVE,
_("Always On _Top"));
gtk_menu_shell_append (GTK_MENU_SHELL (menu),
priv->above_item);
pin_group = NULL;
priv->pin_item = make_radio_menu_item (PIN, &pin_group,
_("_Always on Visible Workspace"));
gtk_menu_shell_append (GTK_MENU_SHELL (menu),
priv->pin_item);
priv->unpin_item = make_radio_menu_item (UNPIN, &pin_group,
_("_Only on This Workspace"));
gtk_menu_shell_append (GTK_MENU_SHELL (menu),
priv->unpin_item);
priv->left_item = make_menu_item (LEFT);
gtk_menu_shell_append (GTK_MENU_SHELL (menu),
priv->left_item);
set_item_text (priv->left_item, _("Move to Workspace _Left"));
set_item_stock (priv->left_item, NULL);
priv->right_item = make_menu_item (RIGHT);
gtk_menu_shell_append (GTK_MENU_SHELL (menu),
priv->right_item);
set_item_text (priv->right_item, _("Move to Workspace R_ight"));
set_item_stock (priv->right_item, NULL);
priv->up_item = make_menu_item (UP);
gtk_menu_shell_append (GTK_MENU_SHELL (menu),
priv->up_item);
set_item_text (priv->up_item, _("Move to Workspace _Up"));
set_item_stock (priv->up_item, NULL);
priv->down_item = make_menu_item (DOWN);
gtk_menu_shell_append (GTK_MENU_SHELL (menu),
priv->down_item);
set_item_text (priv->down_item, _("Move to Workspace _Down"));
set_item_stock (priv->down_item, NULL);
priv->workspace_item = gtk_menu_item_new_with_mnemonic (_("Move to Another _Workspace"));
gtk_widget_show (priv->workspace_item);
submenu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (priv->workspace_item),
submenu);
gtk_menu_shell_append (GTK_MENU_SHELL (menu),
priv->workspace_item);
separator = gtk_separator_menu_item_new ();
gtk_widget_show (separator);
gtk_menu_shell_append (GTK_MENU_SHELL (menu),
separator);
priv->close_item = make_menu_item (CLOSE);
gtk_menu_shell_append (GTK_MENU_SHELL (menu),
priv->close_item);
set_item_text (priv->close_item, _("_Close"));
set_item_stock (priv->close_item, MATEWNCK_STOCK_DELETE);
g_signal_connect_object (G_OBJECT (priv->window),
"state_changed",
G_CALLBACK (state_changed_callback),
G_OBJECT (menu),
0);
g_signal_connect_object (G_OBJECT (priv->window),
"actions_changed",
G_CALLBACK (actions_changed_callback),
G_OBJECT (menu),
0);
g_signal_connect_object (G_OBJECT (priv->window),
"workspace_changed",
G_CALLBACK (workspace_changed_callback),
G_OBJECT (menu),
0);
screen = matewnck_window_get_screen (priv->window);
g_signal_connect_object (G_OBJECT (screen),
"workspace_created",
G_CALLBACK (screen_workspace_callback),
G_OBJECT (menu),
0);
g_signal_connect_object (G_OBJECT (screen),
"workspace_destroyed",
G_CALLBACK (screen_workspace_callback),
G_OBJECT (menu),
0);
g_signal_connect_object (G_OBJECT (screen),
"viewports_changed",
G_CALLBACK (viewports_changed_callback),
G_OBJECT (menu),
0);
update_menu_state (menu);
return obj;
}
static GtkWidget *vte_create_popup_menu(void)
{
GtkWidget *menu, *item;
GtkAccelGroup *accel_group;
menu = gtk_menu_new();
accel_group = gtk_accel_group_new();
gtk_window_add_accel_group(GTK_WINDOW(main_widgets.window), accel_group);
item = gtk_image_menu_item_new_from_stock(GTK_STOCK_COPY, NULL);
gtk_widget_add_accelerator(item, "activate", accel_group,
GDK_c, GEANY_PRIMARY_MOD_MASK | GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
g_signal_connect(item, "activate", G_CALLBACK(vte_popup_menu_clicked), GINT_TO_POINTER(POPUP_COPY));
item = gtk_image_menu_item_new_from_stock(GTK_STOCK_PASTE, NULL);
gtk_widget_add_accelerator(item, "activate", accel_group,
GDK_v, GEANY_PRIMARY_MOD_MASK | GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
g_signal_connect(item, "activate", G_CALLBACK(vte_popup_menu_clicked), GINT_TO_POINTER(POPUP_PASTE));
item = gtk_separator_menu_item_new();
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
item = gtk_image_menu_item_new_from_stock(GTK_STOCK_SELECT_ALL, NULL);
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
g_signal_connect(item, "activate", G_CALLBACK(vte_popup_menu_clicked), GINT_TO_POINTER(POPUP_SELECTALL));
item = gtk_separator_menu_item_new();
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
item = gtk_image_menu_item_new_with_mnemonic(_("_Set Path From Document"));
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
g_signal_connect(item, "activate", G_CALLBACK(vte_popup_menu_clicked), GINT_TO_POINTER(POPUP_CHANGEPATH));
item = gtk_image_menu_item_new_with_mnemonic(_("_Restart Terminal"));
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
g_signal_connect(item, "activate", G_CALLBACK(vte_popup_menu_clicked), GINT_TO_POINTER(POPUP_RESTARTTERMINAL));
item = gtk_separator_menu_item_new();
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
item = gtk_image_menu_item_new_from_stock(GTK_STOCK_PREFERENCES, NULL);
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
g_signal_connect(item, "activate", G_CALLBACK(vte_popup_menu_clicked), GINT_TO_POINTER(POPUP_PREFERENCES));
msgwin_menu_add_common_items(GTK_MENU(menu));
item = gtk_separator_menu_item_new();
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
/* the IM submenu should always be the last item to be consistent with other GTK popup menus */
vc->im_submenu = gtk_menu_new();
item = gtk_image_menu_item_new_with_mnemonic(_("_Input Methods"));
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), vc->im_submenu);
/* submenu populated after vte realized */
return menu;
}
/* New dialog */
void
new_cb()
{
// If another nn is open, call delete_cb()
if(nn != NULL)
delete_cb();
GtkWidget *tmp;
// Dialog where select the net neurons number
new_w = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(new_w), "New Neural Network");
gtk_window_resize(GTK_WINDOW(new_w), 300, 180);
//g_signal_connect(G_OBJECT(window), "destroy",
// G_CALLBACK(gtk_main_quit), NULL);
GtkWidget *mbox = gtk_vbox_new(1, 0);
gtk_container_add(GTK_CONTAINER(new_w), mbox);
GtkWidget *menu = gtk_menu_bar_new();
gtk_box_pack_start(GTK_BOX(mbox),menu,TRUE,TRUE,0);
//
GtkWidget *menu_file = gtk_menu_item_new_with_label("File");
gtk_menu_bar_append (GTK_MENU_BAR(menu), menu_file);
GtkWidget *menu_sub = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_file), menu_sub);
GtkWidget *menuitem = gtk_menu_item_new_with_label ("Quit");
g_signal_connect(G_OBJECT(menuitem), "clicked", G_CALLBACK(save_cb), NULL);
gtk_menu_append(GTK_MENU(menu_sub), menuitem);
// Input neurons
tmp = gtk_hbox_new(0,0);
gtk_box_pack_start(GTK_BOX(mbox),tmp,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(tmp),gtk_label_new("Input neurons: "),FALSE,FALSE,0);
input_spin = gtk_spin_button_new(
GTK_ADJUSTMENT(gtk_adjustment_new(2.0, 0.0, 10000.0, 1.0, 10.0, 10.0)),
1.0, 0);
gtk_box_pack_start(GTK_BOX(tmp),input_spin,FALSE,FALSE,0);
// Hidden neurons
tmp = gtk_hbox_new(0,0);
gtk_box_pack_start(GTK_BOX(mbox),tmp,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(tmp),gtk_label_new("Hidden neurons: "),FALSE,FALSE,0);
hidden_spin = gtk_spin_button_new(
GTK_ADJUSTMENT(gtk_adjustment_new(3.0, 0.0, 10000.0, 1.0, 10.0, 10.0)),
1.0, 0);
gtk_box_pack_start(GTK_BOX(tmp),hidden_spin,FALSE,FALSE,0);
// Output neurons
tmp = gtk_hbox_new(0,0);
gtk_box_pack_start(GTK_BOX(mbox),tmp,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(tmp),gtk_label_new("Output neurons: "),FALSE,FALSE,0);
output_spin = gtk_spin_button_new(
GTK_ADJUSTMENT(gtk_adjustment_new(1.0, 0.0, 10000.0, 1.0, 10.0, 10.0)),
1.0, 0);
gtk_box_pack_start(GTK_BOX(tmp),output_spin,FALSE,FALSE,0);
// Learning neurons
tmp = gtk_hbox_new(0,0);
gtk_box_pack_start(GTK_BOX(mbox),tmp,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(tmp),gtk_label_new("Learning rate: "),FALSE,FALSE,0);
learning_spin = gtk_spin_button_new(
GTK_ADJUSTMENT(gtk_adjustment_new(0.6, 0.0, 1.0, 0.02, 0.6, 0.1)),
1.0, 2);
gtk_box_pack_start(GTK_BOX(tmp),learning_spin,FALSE,FALSE,0);
// Combo for transfer function
tmp = gtk_hbox_new(0,0);
gtk_box_pack_start(GTK_BOX(mbox),tmp,FALSE,FALSE,0);
GtkWidget *new_button = gtk_button_new_with_label("New");
g_signal_connect(G_OBJECT(new_button), "clicked", G_CALLBACK(new_do_cb), NULL);
gtk_container_add(GTK_CONTAINER(tmp), new_button);
GtkWidget *cancel_button = gtk_button_new_with_label("Cancel");
g_signal_connect(G_OBJECT(cancel_button), "clicked", G_CALLBACK(new_cancel_cb), NULL);
gtk_container_add(GTK_CONTAINER(tmp), cancel_button);
gtk_widget_show_all(new_w);
}
int
main (int argc, char *argv[])
{
GtkWidget *box;
GtkWidget *menubar;
GtkWidget *menuitem;
GtkWidget *menu;
GtkWidget *button;
GtkAccelGroup *accel_group;
gtk_init (&argc, &argv);
manager = gtk_recent_manager_get_default ();
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (window), -1, -1);
gtk_window_set_title (GTK_WINDOW (window), "Recent Chooser Menu Test");
g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
accel_group = gtk_accel_group_new ();
gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box);
gtk_widget_show (box);
menubar = gtk_menu_bar_new ();
gtk_box_pack_start (GTK_BOX (box), menubar, FALSE, TRUE, 0);
gtk_widget_show (menubar);
menu = create_file_menu (accel_group);
menuitem = gtk_menu_item_new_with_mnemonic ("_File");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
gtk_widget_show (menuitem);
menu = create_recent_chooser_menu (4);
menuitem = gtk_menu_item_new_with_mnemonic ("_Recently Used");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
gtk_widget_show (menuitem);
label = gtk_label_new ("No recent item selected");
gtk_box_pack_start (GTK_BOX (box), label, TRUE, TRUE, 0);
gtk_widget_show (label);
button = gtk_button_new_with_label ("Close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy),
window);
gtk_box_pack_end (GTK_BOX (box), button, TRUE, TRUE, 0);
gtk_widget_set_can_default (button, TRUE);
gtk_widget_grab_default (button);
gtk_widget_show (button);
gtk_widget_show (window);
gtk_main ();
return 0;
}
RtTraceGtk::RtTraceGtk( void *tr_parent_ctx, GtkWidget *tr_parent_wid, pwr_tObjid tr_objid,
pwr_tStatus *status) :
RtTrace( tr_parent_ctx, tr_objid, status), parent_wid(tr_parent_wid), toplevel(0), nav_shell(0)
{
const int window_width = 900;
const int window_height = 800;
const int nav_width = 180;
pwr_tStatus sts;
pwr_tObjid window_objid;
pwr_tClassId cid;
char title[220];
pwr_tOName hostname;
pwr_tOName plcconnect;
pwr_tFileName fname;
sts = gdh_ObjidToName( tr_objid, name, sizeof(name), cdh_mNName);
if (EVEN(sts)) {
*status = sts;
return;
}
strcpy( title, "Trace ");
strcat( title, name);
/* Find plcwindow */
sts = gdh_GetObjectClass( tr_objid, &cid);
if ( EVEN(sts)) {
*status = sts;
return;
}
if ( !(cid == pwr_cClass_windowplc ||
cid == pwr_cClass_windowcond ||
cid == pwr_cClass_windoworderact ||
cid == pwr_cClass_windowsubstep )) {
sts = gdh_GetChild( tr_objid, &window_objid);
if ( EVEN(sts)) {
*status = sts;
return;
}
}
else
window_objid = tr_objid;
sts = gdh_GetObjectClass( window_objid, &cid);
if ( EVEN(sts)) {
*status = sts;
return;
}
if ( !(cid == pwr_cClass_windowplc ||
cid == pwr_cClass_windowcond ||
cid == pwr_cClass_windoworderact ||
cid == pwr_cClass_windowsubstep )) {
*status = 0;
return;
}
sts = get_filename( window_objid, filename, &m_has_host, hostname,
plcconnect);
if ( EVEN(sts)) {
*status = sts;
return;
}
/* Create object context */
objid = window_objid;
if ( m_has_host) {
strcpy( m_hostname, hostname);
strcpy( m_plcconnect, plcconnect);
}
char *titleutf8 = g_convert( title, -1, "UTF-8", "ISO8859-1", NULL, NULL, NULL);
// Gtk
toplevel = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW,
"default-height", window_height,
"default-width", window_width,
"title", titleutf8,
NULL);
g_free( titleutf8);
g_signal_connect( toplevel, "delete_event", G_CALLBACK(delete_event), this);
g_signal_connect( toplevel, "destroy", G_CALLBACK(destroy_event), this);
CoWowGtk::SetWindowIcon( toplevel);
GtkAccelGroup *accel_g = (GtkAccelGroup *) g_object_new(GTK_TYPE_ACCEL_GROUP, NULL);
gtk_window_add_accel_group(GTK_WINDOW(toplevel), accel_g);
GtkMenuBar *menu_bar = (GtkMenuBar *) g_object_new(GTK_TYPE_MENU_BAR, NULL);
// File Entry
// Submenu Print
GtkWidget *file_print = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Print"));
g_signal_connect( file_print, "activate",
G_CALLBACK(activate_print), this);
GtkWidget *file_print_select = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("Print _Selected Documents"));
g_signal_connect( file_print_select, "activate",
G_CALLBACK(activate_printselect), this);
GtkWidget *file_savetrace = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("Save _Trace"));
g_signal_connect( file_savetrace, "activate",
G_CALLBACK(activate_savetrace), this);
GtkWidget *file_restoretrace = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Restore Trace"));
g_signal_connect( file_restoretrace, "activate",
G_CALLBACK(activate_restoretrace), this);
GtkWidget *file_cleartrace = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("C_lear Trace"));
g_signal_connect( file_cleartrace, "activate",
G_CALLBACK(activate_cleartrace), this);
GtkWidget *file_close = gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, accel_g);
g_signal_connect(file_close, "activate", G_CALLBACK(activate_close), this);
GtkMenu *file_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_print);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_print_select);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_savetrace);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_restoretrace);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_cleartrace);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_close);
GtkWidget *file = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_File"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), GTK_WIDGET(file_menu));
// Functions Entry
GtkWidget *functions_open_object = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Open Object"));
g_signal_connect( functions_open_object, "activate",
G_CALLBACK(activate_open_object), this);
gtk_widget_add_accelerator( functions_open_object, "activate", accel_g,
'a', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *functions_open_subwindow = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("Open S_ubwindow"));
g_signal_connect( functions_open_subwindow, "activate",
G_CALLBACK(activate_open_subwindow), this);
gtk_widget_add_accelerator( functions_open_subwindow, "activate", accel_g,
'l', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *functions_display_object = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Display object in Navigator"));
g_signal_connect( functions_display_object, "activate",
G_CALLBACK(activate_display_object), this);
gtk_widget_add_accelerator( functions_display_object, "activate", accel_g,
'd', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *functions_show_cross = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Show Crossreferences"));
g_signal_connect( functions_show_cross, "activate",
G_CALLBACK(activate_show_cross), this);
gtk_widget_add_accelerator( functions_show_cross, "activate", accel_g,
'r', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *functions_open_classgraph = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Open ObjectGraph"));
g_signal_connect( functions_open_classgraph, "activate",
G_CALLBACK(activate_open_classgraph), this);
gtk_widget_add_accelerator( functions_open_classgraph, "activate", accel_g,
'g', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *functions_collect_insert = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Collect Insert"));
g_signal_connect( functions_collect_insert, "activate",
G_CALLBACK(activate_collect_insert), this);
gtk_widget_add_accelerator( functions_collect_insert, "activate", accel_g,
'v', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkMenu *functions_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_open_object);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_open_subwindow);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_display_object);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_show_cross);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_open_classgraph);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_collect_insert);
GtkWidget *functions = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Functions"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), functions);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(functions), GTK_WIDGET(functions_menu));
// View Entry
GtkWidget *view_zoom_in = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_IN, NULL);
g_signal_connect( view_zoom_in, "activate",
G_CALLBACK(activate_zoomin), this);
gtk_widget_add_accelerator( view_zoom_in, "activate", accel_g,
'i', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *view_zoom_out = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_OUT, NULL);
g_signal_connect( view_zoom_out, "activate",
G_CALLBACK(activate_zoomout), this);
gtk_widget_add_accelerator( view_zoom_out, "activate", accel_g,
'o', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *view_zoom_reset = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_100, NULL);
g_signal_connect( view_zoom_reset, "activate",
G_CALLBACK(activate_zoomreset), this);
gtk_widget_add_accelerator( view_zoom_reset, "activate", accel_g,
'b', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
// Submenu ScanTime
GSList *view_sc_group = NULL;
GtkWidget *view_scantime1 = gtk_radio_menu_item_new_with_mnemonic( view_sc_group,
"0.50 s");
view_sc_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(view_scantime1));
g_signal_connect( view_scantime1, "activate",
G_CALLBACK(activate_scantime1), this);
GtkWidget *view_scantime2 = gtk_radio_menu_item_new_with_mnemonic( view_sc_group,
"0.20 s");
view_sc_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(view_scantime1));
g_signal_connect( view_scantime2, "activate",
G_CALLBACK(activate_scantime2), this);
GtkWidget *view_scantime3 = gtk_radio_menu_item_new_with_mnemonic( view_sc_group,
"0.10 s");
view_sc_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(view_scantime1));
g_signal_connect( view_scantime3, "activate",
G_CALLBACK(activate_scantime3), this);
GtkWidget *view_scantime4 = gtk_radio_menu_item_new_with_mnemonic( view_sc_group,
"0.05 s");
view_sc_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(view_scantime1));
g_signal_connect( view_scantime4, "activate",
G_CALLBACK(activate_scantime4), this);
GtkWidget *view_scantime5 = gtk_radio_menu_item_new_with_mnemonic( view_sc_group,
"0.02 s");
g_signal_connect( view_scantime5, "activate",
G_CALLBACK(activate_scantime5), this);
GtkWidget *view_sc = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_ScanTime"));
GtkMenu *view_sc_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(view_sc_menu), view_scantime1);
gtk_menu_shell_append(GTK_MENU_SHELL(view_sc_menu), view_scantime2);
gtk_menu_shell_append(GTK_MENU_SHELL(view_sc_menu), view_scantime3);
gtk_menu_shell_append(GTK_MENU_SHELL(view_sc_menu), view_scantime4);
gtk_menu_shell_append(GTK_MENU_SHELL(view_sc_menu), view_scantime5);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(view_sc),
GTK_WIDGET(view_sc_menu));
GtkMenu *view_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_in);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_out);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_reset);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_sc);
GtkWidget *view = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_View"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), view);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(view), GTK_WIDGET(view_menu));
// Mode entry
GSList *mode_group = NULL;
GtkWidget *mode_view = gtk_radio_menu_item_new_with_mnemonic( mode_group, CoWowGtk::translate_utf8("V_iew"));
mode_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(mode_view));
g_signal_connect( mode_view, "activate",
G_CALLBACK(activate_view), this);
GtkWidget *mode_trace = gtk_radio_menu_item_new_with_mnemonic( mode_group, CoWowGtk::translate_utf8("_Trace"));
mode_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(mode_trace));
g_signal_connect( mode_trace, "activate",
G_CALLBACK(activate_trace), this);
GtkWidget *mode_simulate = gtk_radio_menu_item_new_with_mnemonic( mode_group, CoWowGtk::translate_utf8("_Simulate"));
gtk_widget_add_accelerator( mode_simulate, "activate", accel_g,
's', GdkModifierType(GDK_CONTROL_MASK | GDK_SHIFT_MASK),
GTK_ACCEL_VISIBLE);
g_signal_connect( mode_simulate, "activate",
G_CALLBACK(activate_simulate), this);
GtkMenu *mode_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(mode_menu), mode_view);
gtk_menu_shell_append(GTK_MENU_SHELL(mode_menu), mode_trace);
gtk_menu_shell_append(GTK_MENU_SHELL(mode_menu), mode_simulate);
GtkWidget *mode = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Mode"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), mode);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(mode), GTK_WIDGET(mode_menu));
// Menu Help
GtkWidget *help_help = gtk_image_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("On _Trace"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(help_help),
gtk_image_new_from_stock( "gtk-help", GTK_ICON_SIZE_MENU));
g_signal_connect(help_help, "activate", G_CALLBACK(activate_help), this);
gtk_widget_add_accelerator( help_help, "activate", accel_g,
'h', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget *help_plcpgm = gtk_check_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("On _PlcPgm"));
g_signal_connect( help_plcpgm, "activate",
G_CALLBACK(activate_helpplc), this);
GtkMenu *help_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_help);
gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_plcpgm);
GtkWidget *help = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Help"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), help);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), GTK_WIDGET(help_menu));
// Toolbar
GtkToolbar *tools = (GtkToolbar *) g_object_new(GTK_TYPE_TOOLBAR, NULL);
GtkWidget *tools_display_object = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_navigator.png");
gtk_container_add( GTK_CONTAINER(tools_display_object),
gtk_image_new_from_file( fname));
g_signal_connect(tools_display_object, "clicked", G_CALLBACK(activate_display_object), this);
gtk_toolbar_append_widget( tools, tools_display_object, "Display object in Navigator", "");
GtkWidget *tools_show_cross = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_crossref.png");
gtk_container_add( GTK_CONTAINER(tools_show_cross),
gtk_image_new_from_file( fname));
g_signal_connect(tools_show_cross, "clicked", G_CALLBACK(activate_show_cross), this);
gtk_toolbar_append_widget( tools, tools_show_cross, "Show Crossreferences", "");
GtkWidget *tools_zoom_in = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_in.png");
gtk_container_add( GTK_CONTAINER(tools_zoom_in),
gtk_image_new_from_file( fname));
g_signal_connect(tools_zoom_in, "clicked", G_CALLBACK(activate_zoomin), this);
gtk_toolbar_append_widget( tools, tools_zoom_in, "Zoom in", "");
GtkWidget *tools_zoom_out = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_out.png");
gtk_container_add( GTK_CONTAINER(tools_zoom_out),
gtk_image_new_from_file( fname));
g_signal_connect(tools_zoom_out, "clicked", G_CALLBACK(activate_zoomout), this);
gtk_toolbar_append_widget( tools, tools_zoom_out, "Zoom out", "");
GtkWidget *tools_zoom_reset = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_reset.png");
gtk_container_add( GTK_CONTAINER(tools_zoom_reset),
gtk_image_new_from_file( fname));
g_signal_connect(tools_zoom_reset, "clicked", G_CALLBACK(activate_zoomreset), this);
gtk_toolbar_append_widget( tools, tools_zoom_reset, "Zoom reset", "");
// Flow widget
GtkWidget *flow_scrolled = scrolledflowwidgetgtk_new( init_flow,
this, &flow_widget);
gtk_widget_show_all(flow_widget);
nav_widget = flownavwidgetgtk_new( flow_widget);
GtkWidget *paned = gtk_hpaned_new();
gtk_paned_pack1( GTK_PANED(paned), flow_scrolled, TRUE, TRUE);
gtk_paned_pack2( GTK_PANED(paned), nav_widget, FALSE, TRUE);
GtkWidget *vbox = gtk_vbox_new( FALSE, 0);
gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(menu_bar), FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(tools), FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(paned), TRUE, TRUE, 0);
gtk_container_add( GTK_CONTAINER(toplevel), vbox);
gtk_widget_show_all( toplevel);
gtk_paned_set_position( GTK_PANED(paned), window_width - nav_width);
#if 0
// Navigator window
nav_shell = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW,
"default-height", 200,
"default-width", 200,
"title", "Navigator",
NULL);
g_signal_connect( nav_shell, "delete_event", G_CALLBACK(nav_delete_event), this);
nav_widget = flownavwidgetgtk_new( flow_widget);
gtk_container_add( GTK_CONTAINER(nav_shell), nav_widget);
gtk_widget_show_all( nav_shell);
#endif
wow = new CoWowGtk( toplevel);
trace_timerid = wow->timer_new();
viewsetup();
flow_Open( flow_ctx, filename);
gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( mode_trace), TRUE);
gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( view_scantime1), TRUE);
//trasetup();
//trace_start();
#if defined OS_LINUX
{
struct stat info;
if ( stat( filename, &info) != -1)
version = info.st_ctime;
}
#endif
// Check version
unsigned int flow_version;
pwr_tUInt32 window_version;
pwr_tAName aname;
flow_GetCtxUserVersion( flow_ctx, &flow_version);
strcpy( aname, name);
strcat( aname, ".Version");
sts = gdh_GetObjectInfo( aname, &window_version, sizeof(window_version));
if ( EVEN(sts)) return;
if ( flow_version > window_version)
wow->DisplayError( "Version mismatch", "Trace file is newer than database version");
else if ( flow_version < window_version)
wow->DisplayError( "Version mismatch", "Trace file is older than database version");
}
static GtkWidget *create_menubar(GFunc *quit_proc) {
GtkWidget *menubar;
GtkWidget *menu,*menu_item;
GtkWidget *menu_entry_play, *menu_entry_pause, *menu_entry_conn, *menu_entry_disconn;
/* GtkActionGroup *group;
GtkUIManager *ui_manager; */
menubar = gtk_menu_bar_new();
/* action group whatever *
group = gtk_action_group_new("MainActionGroup");
gtk_action_group_add_actions(group,entries,NUM_ENTRIES,NULL);
* UI Manager *
ui_manager = gtk_ui_manager_new();
gtk_ui_manager_insert_action_group(ui_manager, group, 0);
* adjust path !!! *
gtk_ui_manager_add_ui_from_file(ui_manager, "menu.ui", NULL);
menubar = gtk_ui_manager_get_widget(ui_manager, "/MenuBar"); */
/* item: Playlist */
menu_item = gtk_menu_item_new_with_mnemonic ("_Playlist");
gtk_container_add(GTK_CONTAINER(menubar), menu_item);
/* create menubox for the item */
menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), menu);
/* action: add url */
menu_add_entry(GTK_CONTAINER(menu), "_Add Media Resource Locator", G_CALLBACK(gui_add_mrl_win), NULL);
/* action: delete */
menu_add_entry(GTK_CONTAINER(menu), "_Delete Songs", G_CALLBACK(pl_del_songs), NULL);
/* action: get current song lyrics */
// menu_add_entry(GTK_CONTAINER(menu), "_Get lyrics", G_CALLBACK(pl_get_current_song_lyrics), NULL);
/* menu_entry = gtk_menu_item_new_with_mnemonic("Media _Browser");
gtk_container_add(GTK_CONTAINER(menu), menu_entry);
g_signal_connect(G_OBJECT(menu_entry), "activate",
G_CALLBACK(media_browser_window_show), NULL);
g_signal_connect(G_OBJECT(menu_entry), "activate",
G_CALLBACK(media_database_read), NULL); */
/* action: separator */
menu_add_separator(GTK_CONTAINER(menu));
/* action: reload playlist */
menu_add_entry(GTK_CONTAINER(menu), "_Reload playlist", G_CALLBACK(playlist_update_tree_cb), NULL);
/* action reload media browser */
menu_add_entry(GTK_CONTAINER(menu), "Reload _Media Browser", G_CALLBACK(mb_reread_cb), NULL);
/* action: separator */
menu_add_separator(GTK_CONTAINER(menu));
/* action: properties dialog */
menu_add_entry(GTK_CONTAINER(menu), "_Properties", G_CALLBACK(mpd_new_properties_window_cb), (gpointer)MpdWin.win);
/* action: quit */
#ifdef CLOSE
menu_add_entry(GTK_CONTAINER(menu), "_Close", G_CALLBACK(quit_proc), MpdWin.win);
#else
menu_add_entry(GTK_CONTAINER(menu), "_Quit", G_CALLBACK(quit_proc), MpdWin.win);
#endif
/* item: MPD */
menu_item = gtk_menu_item_new_with_mnemonic ("_MPD");
gtk_container_add(GTK_CONTAINER(menubar), menu_item);
/* create menubox for the item */
menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), menu);
/* action: connect/disconnect */
menu_entry_disconn = menu_add_entry_stock_icon(GTK_CONTAINER(menu), "_Disconnect", GTK_STOCK_DISCONNECT, G_CALLBACK(mpd_disconnect_cb), NULL);
menu_entry_conn = menu_add_entry_stock_icon(GTK_CONTAINER(menu), "_Connect", GTK_STOCK_CONNECT, G_CALLBACK(mpd_connect_cb), NULL);
/* separator */
menu_add_separator(GTK_CONTAINER(menu));
/* action: Previous */
menu_add_entry_stock_icon(GTK_CONTAINER(menu), "P_revious", GTK_STOCK_MEDIA_PREVIOUS, G_CALLBACK(action), ACTION_TYPE_TO_GPOINTER(ACTION_PREVIOUS));
/* action: Play */
menu_entry_play = menu_add_entry_stock_icon(GTK_CONTAINER(menu), "_Play", GTK_STOCK_MEDIA_PLAY, G_CALLBACK(action), ACTION_TYPE_TO_GPOINTER(ACTION_PLAY_PAUSE));
/* action: Pause */
menu_entry_pause = menu_add_entry_stock_icon(GTK_CONTAINER(menu), "_Pause", GTK_STOCK_MEDIA_PAUSE, G_CALLBACK(action), ACTION_TYPE_TO_GPOINTER(ACTION_PLAY_PAUSE));
/* action: Stop */
menu_add_entry_stock_icon(GTK_CONTAINER(menu), "_Stop", GTK_STOCK_MEDIA_STOP, G_CALLBACK(action), ACTION_TYPE_TO_GPOINTER(ACTION_STOP));
/* action: Next */
menu_add_entry_stock_icon(GTK_CONTAINER(menu), "_Next", GTK_STOCK_MEDIA_NEXT, G_CALLBACK(action), ACTION_TYPE_TO_GPOINTER(ACTION_NEXT));
/* action: separator */
menu_add_separator(GTK_CONTAINER(menu));
/* action: Update DB */
menu_add_entry(GTK_CONTAINER(menu), "_Update DB", G_CALLBACK(action), ACTION_TYPE_TO_GPOINTER(ACTION_UPDATE_DB));
/* action: Shuffle Playlist */
menu_add_entry(GTK_CONTAINER(menu), "R_andom", G_CALLBACK(action), ACTION_TYPE_TO_GPOINTER(ACTION_RANDOM));
/* action: Repeat */
menu_add_entry(GTK_CONTAINER(menu), "R_epeat", G_CALLBACK(action), ACTION_TYPE_TO_GPOINTER(ACTION_REPEAT));
/* action: Xfade */
menu_add_entry(GTK_CONTAINER(menu), "_Xfade", G_CALLBACK(action), ACTION_TYPE_TO_GPOINTER(ACTION_XFADE));
/* item: Help */
menu_item = gtk_menu_item_new_with_mnemonic ("_Help");
gtk_container_add(GTK_CONTAINER(menubar), menu_item);
/* create menubox for the item */
menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), menu);
/* action: log window */
// menu_add_entry(GTK_CONTAINER(menu), "_Log window", G_CALLBACK(open_log_window), NULL);
/* action: separator */
menu_add_separator(GTK_CONTAINER(menu));
/* action: About */
menu_add_entry(GTK_CONTAINER(menu), "_About", G_CALLBACK(open_about_dialog), NULL);
gtk_widget_show_all(menubar);
menu_entries = NULL;
menu_entries = g_list_append(menu_entries, menu_entry_play);
menu_entries = g_list_append(menu_entries, menu_entry_pause);
menu_entries = g_list_append(menu_entries, menu_entry_conn);
menu_entries = g_list_append(menu_entries, menu_entry_disconn);
return menubar;
}
GtkUIManager *
gl_ui_new (glWindow *window)
{
GtkUIManager *ui;
GtkActionGroup *actions;
GError *error = NULL;
GtkWidget *recent_menu;
gl_debug (DEBUG_UI, "START");
g_return_val_if_fail (window && GL_IS_WINDOW (window), NULL);
gl_debug (DEBUG_UI, "window = %p", window);
ui = gtk_ui_manager_new ();
g_signal_connect (ui, "connect_proxy",
G_CALLBACK (connect_proxy_cb), window);
g_signal_connect (ui, "disconnect_proxy",
G_CALLBACK (disconnect_proxy_cb), window);
actions = gtk_action_group_new ("Actions");
gtk_action_group_set_translation_domain (actions, NULL);
gtk_action_group_add_actions (actions, entries, n_entries, GTK_WINDOW (window));
gtk_action_group_add_toggle_actions (actions,
toggle_entries, n_toggle_entries,
window);
gtk_action_group_add_toggle_actions (actions,
ui_toggle_entries, n_ui_toggle_entries,
ui);
gtk_ui_manager_insert_action_group (ui, actions, 0);
gtk_window_add_accel_group (GTK_WINDOW (window), gtk_ui_manager_get_accel_group (ui));
gl_debug (DEBUG_UI, "Creating ui from string");
if (!gtk_ui_manager_add_ui_from_string (ui, ui_info, strlen (ui_info), &error)) {
g_message ("building menus failed: %s", error->message);
g_error_free (error);
}
/* Set the toolbar styles according to prefs */
set_app_main_toolbar_style (ui);
set_app_drawing_toolbar_style (ui);
/* Set view grid and markup visibility according to prefs */
set_view_style (ui);
/* add an Open Recents Submenu */
recent_menu = gl_recent_create_menu ();
g_signal_connect (G_OBJECT (recent_menu), "item-activated",
G_CALLBACK (gl_ui_cmd_file_open_recent), window);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (gtk_ui_manager_get_widget (ui, "/MenuBar/FileMenu/FileRecentsMenu")),
recent_menu);
set_additional_properties (ui);
gl_ui_util_set_verb_list_sensitive (ui, doc_verbs, FALSE);
gl_ui_util_set_verb_list_sensitive (ui, paste_verbs, FALSE);
gl_debug (DEBUG_UI, "END");
return ui;
}
int main(int argc, char *argv[] ) {
int i;
char track_text[4];
gtk_init (&argc, &argv);
id3win=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(id3win),"MP3info - An ID3 tag editor");
gtk_window_set_policy (GTK_WINDOW(id3win), FALSE,FALSE,FALSE);
gtk_widget_set_usize(id3win,450,360);
gtk_container_border_width(GTK_CONTAINER(id3win),5);
gtk_signal_connect(GTK_OBJECT(id3win), "delete_event", (GtkSignalFunc) gtk_exit, NULL);
id3win_frame_global=gtk_vbox_new(FALSE,5);
/* rmcc was here */
id3win_menu_bar = gtk_menu_bar_new();
gtk_widget_show(id3win_menu_bar);
gtk_box_pack_start(GTK_BOX(id3win_frame_global), id3win_menu_bar, FALSE, TRUE, 1);
id3win_menu_file = gtk_menu_item_new_with_label("File");
gtk_widget_show(id3win_menu_file);
gtk_container_add(GTK_CONTAINER(id3win_menu_bar), id3win_menu_file);
id3win_menu_fcont = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(id3win_menu_file), id3win_menu_fcont);
id3win_menu_open = gtk_menu_item_new_with_label("Open New ");
gtk_widget_show(id3win_menu_open);
gtk_container_add(GTK_CONTAINER(id3win_menu_fcont), id3win_menu_open);
gtk_signal_connect(GTK_OBJECT(id3win_menu_open), "activate",
GTK_SIGNAL_FUNC(open_mp3_file),
NULL);
id3win_menu_info = gtk_menu_item_new_with_label("Info ");
gtk_widget_show(id3win_menu_info);
gtk_container_add(GTK_CONTAINER(id3win_menu_fcont), id3win_menu_info);
gtk_signal_connect(GTK_OBJECT(id3win_menu_info), "activate",
GTK_SIGNAL_FUNC(create_techinfo_win),
NULL);
id3win_menu_help = gtk_menu_item_new_with_label(" Help");
gtk_widget_show(id3win_menu_help);
gtk_container_add(GTK_CONTAINER(id3win_menu_bar), id3win_menu_help);
gtk_menu_item_right_justify(GTK_MENU_ITEM(id3win_menu_help));
id3win_menu_hcont = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(id3win_menu_help), id3win_menu_hcont);
id3win_menu_about = gtk_menu_item_new_with_label("About ");
gtk_widget_show(id3win_menu_about);
gtk_container_add(GTK_CONTAINER(id3win_menu_hcont), id3win_menu_about);
gtk_signal_connect(GTK_OBJECT(id3win_menu_about), "activate",
GTK_SIGNAL_FUNC(about_mp3info),
NULL);
/* rmcc has left the building */
id3win_frame_title=gtk_frame_new("Title");
gtk_container_border_width(GTK_CONTAINER(id3win_frame_title),5);
id3win_text_title=gtk_entry_new_with_max_length(30);
gtk_container_add(GTK_CONTAINER(id3win_frame_title),id3win_text_title);
gtk_box_pack_start(GTK_BOX(id3win_frame_global),id3win_frame_title,TRUE,TRUE,0);
id3win_frame_artist=gtk_frame_new("Artist");
gtk_container_border_width(GTK_CONTAINER(id3win_frame_artist),5);
id3win_text_artist=gtk_entry_new_with_max_length(30);
gtk_container_add(GTK_CONTAINER(id3win_frame_artist),id3win_text_artist);
gtk_box_pack_start(GTK_BOX(id3win_frame_global),id3win_frame_artist,TRUE,TRUE,0);
id3win_frame_albyear=gtk_hbox_new(FALSE,30);
id3win_frame_album=gtk_frame_new("Album");
gtk_container_border_width(GTK_CONTAINER(id3win_frame_album),5);
id3win_text_album=gtk_entry_new_with_max_length(30);
gtk_container_add(GTK_CONTAINER(id3win_frame_album),id3win_text_album);
gtk_box_pack_start(GTK_BOX(id3win_frame_albyear),id3win_frame_album,TRUE,TRUE,0);
id3win_frame_year=gtk_frame_new("Year");
gtk_widget_set_usize(id3win_frame_year,2,0);
gtk_container_border_width(GTK_CONTAINER(id3win_frame_year),5);
id3win_text_year=gtk_entry_new_with_max_length(4);
gtk_container_add(GTK_CONTAINER(id3win_frame_year),id3win_text_year);
gtk_box_pack_start(GTK_BOX(id3win_frame_albyear),id3win_frame_year,TRUE,TRUE,0);
gtk_box_pack_start(GTK_BOX(id3win_frame_global),id3win_frame_albyear,TRUE,TRUE,0);
id3win_frame_comtrack=gtk_hbox_new(FALSE,30);
id3win_frame_comment=gtk_frame_new("Comment");
gtk_container_border_width(GTK_CONTAINER(id3win_frame_comment),5);
id3win_text_comment=gtk_entry_new_with_max_length(30);
gtk_container_add(GTK_CONTAINER(id3win_frame_comment),id3win_text_comment);
gtk_box_pack_start(GTK_BOX(id3win_frame_comtrack),id3win_frame_comment,TRUE,TRUE,0);
id3win_frame_track=gtk_frame_new("Track");
gtk_widget_set_usize(id3win_frame_track,2,0);
gtk_container_border_width(GTK_CONTAINER(id3win_frame_track),5);
id3win_text_track=gtk_entry_new_with_max_length(3);
gtk_container_add(GTK_CONTAINER(id3win_frame_track),id3win_text_track);
gtk_box_pack_start(GTK_BOX(id3win_frame_comtrack),id3win_frame_track,TRUE,TRUE,0);
gtk_box_pack_start(GTK_BOX(id3win_frame_global),id3win_frame_comtrack,TRUE,TRUE,0);
id3win_frame_genre=gtk_frame_new("Genre");
gtk_container_border_width(GTK_CONTAINER(id3win_frame_genre),5);
id3win_combo_genre=gtk_combo_new();
for(i=0;i<MAXGENRE+2;i++) {
genrelist = g_list_append(genrelist, typegenre[galphagenreindex[i]]);
}
gtk_combo_set_popdown_strings(GTK_COMBO(id3win_combo_genre),genrelist);
gtk_container_add(GTK_CONTAINER(id3win_frame_genre),id3win_combo_genre);
gtk_box_pack_start(GTK_BOX(id3win_frame_global),id3win_frame_genre,TRUE,TRUE,0);
id3win_frame_buttons=gtk_hbox_new(TRUE,30);
id3win_ok_button=gtk_button_new_with_label("OK");
gtk_box_pack_start(GTK_BOX(id3win_frame_buttons),id3win_ok_button,TRUE,TRUE,0);
if(read_only) {
gtk_widget_set_sensitive (id3win_text_title, FALSE);
gtk_widget_set_sensitive (id3win_text_artist, FALSE);
gtk_widget_set_sensitive (id3win_text_album, FALSE);
gtk_widget_set_sensitive (id3win_text_year, FALSE);
gtk_widget_set_sensitive (id3win_text_comment, FALSE);
gtk_widget_set_sensitive (id3win_text_track, FALSE);
gtk_widget_set_sensitive (id3win_combo_genre, FALSE);
} else {
id3win_cancel_button=gtk_button_new_with_label("Cancel");
gtk_box_pack_start(GTK_BOX(id3win_frame_buttons),id3win_cancel_button,TRUE,TRUE,0);
gtk_signal_connect (GTK_OBJECT (id3win_cancel_button), "clicked", GTK_SIGNAL_FUNC (gtk_exit), NULL);
}
gtk_widget_set_usize(id3win_frame_buttons,30,20);
gtk_box_pack_start(GTK_BOX(id3win_frame_global),id3win_frame_buttons,TRUE,TRUE,0);
gtk_container_add(GTK_CONTAINER(id3win),id3win_frame_global);
gtk_signal_connect (GTK_OBJECT (id3win_ok_button), "clicked", GTK_SIGNAL_FUNC (exit_save), NULL);
gtk_widget_show_all(id3win);
memset(&mp3,0,sizeof(mp3info));
if(argc==2) {
if (! load_mp3(argv[1])) {
exit(0);
}
gtk_entry_set_text(GTK_ENTRY(id3win_text_title),mp3.id3.title);
gtk_entry_set_text(GTK_ENTRY(id3win_text_artist),mp3.id3.artist);
gtk_entry_set_text(GTK_ENTRY(id3win_text_album),mp3.id3.album);
gtk_entry_set_text(GTK_ENTRY(id3win_text_year),mp3.id3.year);
gtk_entry_set_text(GTK_ENTRY(id3win_text_comment),mp3.id3.comment);
if(mp3.id3.track[0] > 0)
sprintf(track_text,"%d",(int)mp3.id3.track[0]);
else
track_text[0]=0;
gtk_entry_set_text(GTK_ENTRY(id3win_text_track),track_text);
gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(id3win_combo_genre)->entry), gtext_genre(mp3.id3.genre[0]));
} else {
open_mp3_file();
}
gtk_main();
return(0);
}
static void
create_colors (void)
{
static GtkWidget *window = NULL;
GtkWidget *box1 = NULL;
GtkWidget *box2 = NULL;
GtkWidget *close_button = NULL;
GtkWidget *box = NULL;
GtkWidget *separator;
GtkWidget *label;
GtkWidget *menu;
GtkWidget *root_menu;
GtkWidget *menu_bar;
gfloat *X = NULL;
gfloat *Y = NULL;
gint i, j;
GdkColor color;
GtkDataboxGraph *graph;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request (window, 500, 300);
g_signal_connect (G_OBJECT (window), "destroy",
G_CALLBACK (gtk_main_quit), NULL);
gtk_window_set_title (GTK_WINDOW (window), "GtkDatabox: Colors");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
box1 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
box = gtk_databox_new ();
gtk_databox_set_enable_selection (GTK_DATABOX (box), FALSE);
gtk_databox_set_enable_zoom (GTK_DATABOX (box), FALSE);
color.red = 0;
color.green = 0;
color.blue = 0;
gtk_widget_modify_bg (box, GTK_STATE_NORMAL, &color);
menu = gtk_menu_new ();
root_menu = gtk_menu_item_new_with_label ("Color Menu");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (root_menu), menu);
menu_bar = gtk_menu_bar_new ();
gtk_menu_shell_append (GTK_MENU_SHELL (menu_bar), root_menu);
gtk_box_pack_start (GTK_BOX (box1), menu_bar, FALSE, TRUE, 0);
label =
gtk_label_new
("You can change the colors of the shown datasets via the menu.\n\n");
gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (box), "destroy",
G_CALLBACK (gtk_main_quit), NULL);
for (i = 0; i < NO_OF_DATASETS; i++)
{
if (!i)
X = g_new0 (gfloat, POINTS);
Y = g_new0 (gfloat, POINTS);
for (j = 0; j < POINTS; j++)
{
X[j] = j;
Y[j] = 100. * sin ((i + 1) * 2 * j * G_PI / POINTS);
}
color.red = 65535 * ((i + 1) % 2);
color.green = (65535 / 2) * ((i + 1) % 3);
color.blue = (65535 / 3) * ((i + 1) % 4);
graph = gtk_databox_points_new (POINTS, X, Y, &color, 1);
gtk_databox_graph_add (GTK_DATABOX (box), graph);
create_menu_entry (menu, i, box, graph);
}
gtk_databox_auto_rescale (GTK_DATABOX (box), 0.05);
gtk_box_pack_start (GTK_BOX (box1), box, TRUE, TRUE, 0);
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
box2 = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_end (GTK_BOX (box1), box2, FALSE, TRUE, 0);
close_button = gtk_button_new_with_label ("close");
g_signal_connect (G_OBJECT (close_button), "clicked",
G_CALLBACK (gtk_main_quit), (gpointer) NULL);
gtk_box_pack_start (GTK_BOX (box2), close_button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (close_button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (close_button);
gtk_widget_show_all (window);
}
void open_mainwindow ()
{
mainwin = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(mainwin), GTK_WIN_POS_CENTER);
gtk_window_set_default_size(GTK_WINDOW(mainwin), 250, 200);
gtk_window_set_title(GTK_WINDOW(mainwin), "Bakamoona v 0.1");
gtk_window_set_icon(GTK_WINDOW(mainwin), create_pixbuf("images/bkm.png"));
layout = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (mainwin), layout);
menubar = gtk_menu_bar_new ();
/*
System | Maintenance | Finance | Search | Statistics | About
*/
// System
sysmenu = gtk_menu_new();
sys_menu_item = gtk_menu_item_new_with_label ("System");
gtk_menu_item_set_submenu (GTK_MENU_ITEM(sys_menu_item), sysmenu);
// adding bus
bus_item = gtk_menu_item_new_with_label ("Bus");
gtk_menu_shell_append (GTK_MENU_SHELL(sysmenu), bus_item);
busmenu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM(bus_item), busmenu);
addbus = gtk_menu_item_new_with_label ("Add Bus");
updatebus = gtk_menu_item_new_with_label ("Update Bus");
deletebus = gtk_menu_item_new_with_label ("Delete Bus");
gtk_menu_shell_append (GTK_MENU_SHELL(busmenu), addbus);
gtk_menu_shell_append (GTK_MENU_SHELL(busmenu), updatebus);
gtk_menu_shell_append (GTK_MENU_SHELL(busmenu), deletebus);
// adding owner
owner_item = gtk_menu_item_new_with_label ("Owner");
gtk_menu_shell_append (GTK_MENU_SHELL(sysmenu), owner_item);
ownermenu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM(owner_item), ownermenu);
addowner = gtk_menu_item_new_with_label ("Add Owner");
updateowner = gtk_menu_item_new_with_label ("Update Owner");
deleteowner = gtk_menu_item_new_with_label ("Delete Owner");
gtk_menu_shell_append (GTK_MENU_SHELL(ownermenu), addowner);
gtk_menu_shell_append (GTK_MENU_SHELL(ownermenu), updateowner);
gtk_menu_shell_append (GTK_MENU_SHELL(ownermenu), deleteowner);
// adding sparepart
sp_item = gtk_menu_item_new_with_label ("Spare Part");
gtk_menu_shell_append (GTK_MENU_SHELL(sysmenu), sp_item);
spmenu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM(sp_item), spmenu);
addsp = gtk_menu_item_new_with_label ("Add Spare Part");
updatesp = gtk_menu_item_new_with_label ("Update Spare Part");
deletesp = gtk_menu_item_new_with_label ("Delete Spare Part");
gtk_menu_shell_append (GTK_MENU_SHELL(spmenu), addsp);
gtk_menu_shell_append (GTK_MENU_SHELL(spmenu), updatesp);
gtk_menu_shell_append (GTK_MENU_SHELL(spmenu), deletesp);
// adding worker
worker_item = gtk_menu_item_new_with_label ("Worker");
gtk_menu_shell_append (GTK_MENU_SHELL(sysmenu), worker_item);
workermenu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM(worker_item), workermenu);
addworker = gtk_menu_item_new_with_label ("Add Worker");
updateworker = gtk_menu_item_new_with_label ("Update Worker");
deleteworker = gtk_menu_item_new_with_label ("Delete Worker");
gtk_menu_shell_append (GTK_MENU_SHELL(workermenu), addworker);
gtk_menu_shell_append (GTK_MENU_SHELL(workermenu), updateworker);
gtk_menu_shell_append (GTK_MENU_SHELL(workermenu), deleteworker);
// adding packages
package_item = gtk_menu_item_new_with_label ("Package");
gtk_menu_shell_append (GTK_MENU_SHELL(sysmenu), package_item);
packagemenu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM(package_item), packagemenu);
addpackage = gtk_menu_item_new_with_label ("Add Package");
updatepackage = gtk_menu_item_new_with_label ("Update Package");
deletepackage = gtk_menu_item_new_with_label ("Delete Package");
gtk_menu_shell_append (GTK_MENU_SHELL(packagemenu), addpackage);
gtk_menu_shell_append (GTK_MENU_SHELL(packagemenu), updatepackage);
gtk_menu_shell_append (GTK_MENU_SHELL(packagemenu), deletepackage);
sep = gtk_separator_menu_item_new();
quit = gtk_menu_item_new_with_label("Quit");
gtk_menu_shell_append (GTK_MENU_SHELL(sysmenu), sep);
gtk_menu_shell_append (GTK_MENU_SHELL(sysmenu), quit);
gtk_menu_shell_append (GTK_MENU_SHELL(menubar), sys_menu_item);
mntmenu = gtk_menu_new();
mnt_menu_item = gtk_menu_item_new_with_label ("Maintenance");
gtk_menu_item_set_submenu (GTK_MENU_ITEM(mnt_menu_item), mntmenu);
gtk_menu_shell_append (GTK_MENU_SHELL(menubar), mnt_menu_item);
addmnt = gtk_menu_item_new_with_label ("Add Maintenance");
updatemnt = gtk_menu_item_new_with_label ("Update Maintenance");
gtk_menu_shell_append (GTK_MENU_SHELL(mntmenu), addmnt);
gtk_menu_shell_append (GTK_MENU_SHELL(mntmenu), updatemnt);
//
finmenu = gtk_menu_new();
fin_menu_item = gtk_menu_item_new_with_label ("Finance");
gtk_menu_item_set_submenu (GTK_MENU_ITEM(fin_menu_item), finmenu);
gtk_menu_shell_append (GTK_MENU_SHELL(menubar), fin_menu_item);
addfin = gtk_menu_item_new_with_label ("Add Bill");
updatefin = gtk_menu_item_new_with_label ("Update Bill");
gtk_menu_shell_append (GTK_MENU_SHELL(finmenu), addfin);
gtk_menu_shell_append (GTK_MENU_SHELL(finmenu), updatefin);
//
searchmenu = gtk_menu_new();
search_menu_item = gtk_menu_item_new_with_label ("Search");
gtk_menu_item_set_submenu (GTK_MENU_ITEM(search_menu_item), searchmenu);
gtk_menu_shell_append (GTK_MENU_SHELL(menubar), search_menu_item);
search_bus = gtk_menu_item_new_with_label ("Bus");
search_own = gtk_menu_item_new_with_label ("Owner");
search_worker = gtk_menu_item_new_with_label ("Worker");
search_sp = gtk_menu_item_new_with_label ("Spare Part");
search_bill = gtk_menu_item_new_with_label ("Bill");
search_mnt = gtk_menu_item_new_with_label ("Maintenance");
gtk_menu_shell_append (GTK_MENU_SHELL(searchmenu), search_bus);
gtk_menu_shell_append (GTK_MENU_SHELL(searchmenu), search_own);
gtk_menu_shell_append (GTK_MENU_SHELL(searchmenu), search_worker);
gtk_menu_shell_append (GTK_MENU_SHELL(searchmenu), search_sp);
gtk_menu_shell_append (GTK_MENU_SHELL(searchmenu), search_bill);
gtk_menu_shell_append (GTK_MENU_SHELL(searchmenu), search_mnt);
//
aboutmenu = gtk_menu_new();
about_menu_item = gtk_menu_item_new_with_label ("About");
gtk_menu_item_set_submenu (GTK_MENU_ITEM(about_menu_item), aboutmenu);
gtk_menu_shell_append (GTK_MENU_SHELL(menubar), about_menu_item);
devteam = gtk_menu_item_new_with_label ("About DEV team");
gtk_menu_shell_append (GTK_MENU_SHELL(aboutmenu), devteam);
// end
gtk_box_pack_start (GTK_BOX(layout), menubar, FALSE, FALSE, 0);
toolbar = gtk_toolbar_new();
gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);
gtk_container_set_border_width(GTK_CONTAINER(toolbar), 0);
quit_tool = gtk_tool_button_new_from_stock (GTK_STOCK_QUIT);
gtk_toolbar_insert (GTK_TOOLBAR(toolbar), quit_tool, -1);
new_tool = gtk_tool_button_new_from_stock(GTK_STOCK_NEW);
gtk_toolbar_insert (GTK_TOOLBAR(toolbar), new_tool, -1);
open_tool = gtk_tool_button_new_from_stock(GTK_STOCK_OPEN);
gtk_toolbar_insert (GTK_TOOLBAR(toolbar), open_tool, -1);
save_tool = gtk_tool_button_new_from_stock(GTK_STOCK_SAVE);
gtk_toolbar_insert (GTK_TOOLBAR(toolbar), save_tool, -1);
gtk_box_pack_start (GTK_BOX(layout), toolbar, FALSE, FALSE, 0);
g_signal_connect_swapped(G_OBJECT(mainwin), "destroy",
G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(G_OBJECT(addbus), "activate",
G_CALLBACK(add_bus_clicked), NULL);
g_signal_connect(G_OBJECT(addworker), "activate",
G_CALLBACK(add_worker_clicked), NULL);
g_signal_connect(G_OBJECT(addowner), "activate",
G_CALLBACK(add_owner_clicked), NULL);
g_signal_connect(G_OBJECT(addsp), "activate",
G_CALLBACK(add_sparepart_clicked), NULL);
g_signal_connect(G_OBJECT(quit), "activate",
G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(G_OBJECT(addmnt), "activate",
G_CALLBACK(add_maintenance_clicked), NULL);
g_signal_connect(G_OBJECT(addfin), "activate",
G_CALLBACK(add_bill_clicked), NULL);
g_signal_connect(G_OBJECT(addpackage), "activate",
G_CALLBACK(add_package_clicked), NULL);
gtk_window_maximize (GTK_WINDOW(mainwin));
gtk_widget_show_all(mainwin);
}
/**
* main routine, parses args and reads from console
*/
int main(int argc, char *argv[])
{
GtkWidget *menubar, *menu, *menuitem, *vbox;
GtkWidget *dummMenu, *guestMenu, *switchMenu;
enumerator_t *enumerator;
guest_t *guest;
library_init(NULL);
gtk_init(&argc, &argv);
pages = linked_list_create();
dumm = dumm_create(NULL);
/* setup window */
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(quit), NULL);
gtk_window_set_title(GTK_WINDOW (window), "Dumm");
gtk_window_set_default_size(GTK_WINDOW (window), 1000, 500);
g_signal_connect(G_OBJECT(vte_reaper_get()), "child-exited",
G_CALLBACK(child_exited), NULL);
/* add vbox with menubar, notebook */
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), vbox);
menubar = gtk_menu_bar_new();
gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, TRUE, 0);
notebook = gtk_notebook_new();
g_object_set(G_OBJECT(notebook), "homogeneous", TRUE, NULL);
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_BOTTOM);
gtk_container_add(GTK_CONTAINER(vbox), notebook);
/* Dumm menu */
menu = gtk_menu_new();
dummMenu = gtk_menu_item_new_with_mnemonic("_Dumm");
gtk_menu_bar_append(GTK_MENU_BAR(menubar), dummMenu);
gtk_widget_show(dummMenu);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(dummMenu), menu);
/* Dumm -> exit */
menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, NULL);
g_signal_connect(G_OBJECT(menuitem), "activate",
G_CALLBACK(quit), NULL);
gtk_menu_append(GTK_MENU(menu), menuitem);
gtk_widget_show(menuitem);
/* Guest menu */
menu = gtk_menu_new();
guestMenu = gtk_menu_item_new_with_mnemonic("_Guest");
gtk_menu_bar_append(GTK_MENU_BAR(menubar), guestMenu);
gtk_widget_show(guestMenu);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(guestMenu), menu);
/* Guest -> new */
menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_NEW, NULL);
g_signal_connect(G_OBJECT(menuitem), "activate",
G_CALLBACK(create_guest), NULL);
gtk_menu_append(GTK_MENU(menu), menuitem);
gtk_widget_show(menuitem);
/* Guest -> delete */
menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_DELETE, NULL);
g_signal_connect(G_OBJECT(menuitem), "activate",
G_CALLBACK(delete_guest), NULL);
gtk_menu_append(GTK_MENU(menu), menuitem);
gtk_widget_show(menuitem);
menuitem = gtk_separator_menu_item_new();
gtk_menu_append(GTK_MENU(menu), menuitem);
gtk_widget_show(menuitem);
/* Guest -> start */
menuitem = gtk_menu_item_new_with_mnemonic("_Start");
g_signal_connect(G_OBJECT(menuitem), "activate",
G_CALLBACK(start_guest), NULL);
gtk_menu_append(GTK_MENU(menu), menuitem);
gtk_widget_show(menuitem);
/* Guest -> startall */
menuitem = gtk_menu_item_new_with_mnemonic("Start _all");
g_signal_connect(G_OBJECT(menuitem), "activate",
G_CALLBACK(start_all_guests), NULL);
gtk_menu_append(GTK_MENU(menu), menuitem);
gtk_widget_show(menuitem);
/* Guest -> stop */
menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_STOP, NULL);
g_signal_connect(G_OBJECT(menuitem), "activate",
G_CALLBACK(stop_guest), NULL);
gtk_menu_append(GTK_MENU(menu), menuitem);
gtk_widget_show(menuitem);
menuitem = gtk_separator_menu_item_new();
gtk_menu_append(GTK_MENU(menu), menuitem);
gtk_widget_show(menuitem);
/* Guest -> connect */
menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_CONNECT, NULL);
g_signal_connect(G_OBJECT(menuitem), "activate",
G_CALLBACK(connect_guest), NULL);
gtk_menu_append(GTK_MENU(menu), menuitem);
gtk_widget_show(menuitem);
/* Guest -> disconnect */
menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_DISCONNECT, NULL);
g_signal_connect(G_OBJECT(menuitem), "activate",
G_CALLBACK(disconnect_guest), NULL);
gtk_menu_append(GTK_MENU(menu), menuitem);
gtk_widget_set_sensitive(menuitem, FALSE);
gtk_widget_show(menuitem);
/* Switch menu */
menu = gtk_menu_new();
switchMenu = gtk_menu_item_new_with_mnemonic("_Switch");
gtk_menu_bar_append(GTK_MENU_BAR(menubar), switchMenu);
gtk_widget_show(switchMenu);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(switchMenu), menu);
/* Switch -> new */
menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_NEW, NULL);
g_signal_connect(G_OBJECT(menuitem), "activate",
G_CALLBACK(create_switch), NULL);
gtk_menu_append(GTK_MENU(menu), menuitem);
gtk_widget_show(menuitem);
/* Switch -> delete */
menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_DELETE, NULL);
g_signal_connect(G_OBJECT(menuitem), "activate",
G_CALLBACK(delete_switch), NULL);
gtk_menu_append(GTK_MENU(menu), menuitem);
gtk_widget_set_sensitive(menuitem, FALSE);
gtk_widget_show(menuitem);
/* show widgets */
gtk_widget_show(menubar);
gtk_widget_show(notebook);
gtk_widget_show(vbox);
gtk_widget_show(window);
/* fill notebook with guests */
enumerator = dumm->create_guest_enumerator(dumm);
while (enumerator->enumerate(enumerator, (void**)&guest))
{
create_page(guest);
}
enumerator->destroy(enumerator);
gtk_main();
dumm->destroy(dumm);
pages->destroy_function(pages, g_free);
library_deinit();
return 0;
}
int main (int argc, char *argv[])
{
/* Vars */
GtkWidget *vbox;
GtkWidget *window;
GtkWidget *table;
GtkWidget *label;
GtkWidget *entry;
GtkWidget *button;
GtkWidget* scrolled;
GtkWidget *menubar;
GtkWidget *filemenu;
GtkWidget *file;
GtkWidget *quit;
GtkWidget *reindexer;
/* Set default directory to index */
indexdir = ".";
/* Run the indexer */
reindex(NULL, NULL);
/* Create the search objects */
createSearch();
/* Make the GUI */
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
initialize_window(window);
/* Create a 10x5 table */
table = gtk_table_new (10, 5, FALSE);
gtk_container_add (GTK_CONTAINER (window), table);
/* create a new label. */
label = gtk_label_new ("Search Terms:" );
gtk_table_set_homogeneous(GTK_TABLE (table), TRUE);
gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 1, 2);
entry = gtk_entry_new ();
gtk_entry_set_max_length (GTK_ENTRY (entry),1000);
gtk_table_attach_defaults (GTK_TABLE (table), entry, 1, 3, 1, 2);
button = gtk_button_new_with_label ("OR Search");
gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (orsearch), (gpointer) entry);
gtk_table_attach_defaults (GTK_TABLE (table), button, 3, 4, 1, 2);
button = gtk_button_new_with_label ("AND Search");
gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (andsearch), (gpointer) entry);
gtk_table_attach_defaults (GTK_TABLE (table), button, 4, 5, 1, 2);
textview = gtk_text_view_new();
gtk_text_view_set_editable( GTK_TEXT_VIEW (textview), 0);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (textview), 0);
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_container_add (GTK_CONTAINER (scrolled), textview);
gtk_table_attach_defaults (GTK_TABLE (table), scrolled, 0, 5, 2, 10);
vbox = gtk_vbox_new(FALSE, 0);
gtk_table_attach_defaults (GTK_TABLE (table), vbox, 0, 5, 0, 1);
menubar = gtk_menu_bar_new();
filemenu = gtk_menu_new();
file = gtk_menu_item_new_with_label("File");
reindexer = gtk_menu_item_new_with_label("Reindex");
gtk_signal_connect (GTK_OBJECT (reindexer), "activate", G_CALLBACK(reindex), NULL);
quit = gtk_menu_item_new_with_label("Quit");
gtk_signal_connect (GTK_OBJECT (quit), "activate", G_CALLBACK(destroy), NULL);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), filemenu);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), reindexer);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), quit);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), file);
gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 3);
gtk_widget_show_all(window);
gtk_main ();
return 0;
}
static void bar_pane_keywords_menu_popup(GtkWidget *widget, PaneKeywordsData *pkd, gint x, gint y)
{
GtkWidget *menu;
GtkWidget *item;
GtkWidget *submenu;
GtkTreeViewDropPosition pos;
if (pkd->click_tpath) gtk_tree_path_free(pkd->click_tpath);
pkd->click_tpath = NULL;
gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(pkd->keyword_treeview), x, y, &pkd->click_tpath, &pos);
menu = popup_menu_short_lived();
menu_item_add_stock(menu, _("Add keyword"), GTK_STOCK_EDIT, G_CALLBACK(bar_pane_keywords_add_dialog_cb), pkd);
menu_item_add_divider(menu);
menu_item_add(menu, _("Add keyword to all selected images"), G_CALLBACK(bar_pane_keywords_add_to_selected_cb), pkd);
menu_item_add_divider(menu);
if (pkd->click_tpath)
{
/* for the entry */
gchar *text;
gchar *mark;
gint i;
GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
GtkTreeIter iter;
gtk_tree_model_get_iter(model, &iter, pkd->click_tpath);
gchar *name;
gtk_tree_model_get(model, &iter, FILTER_KEYWORD_COLUMN_NAME, &name,
FILTER_KEYWORD_COLUMN_MARK, &mark, -1);
text = g_strdup_printf(_("Hide \"%s\""), name);
menu_item_add_stock(menu, text, GTK_STOCK_EDIT, G_CALLBACK(bar_pane_keywords_hide_cb), pkd);
g_free(text);
submenu = gtk_menu_new();
for (i = 0; i < FILEDATA_MARKS_SIZE; i++)
{
text = g_strdup_printf(_("Mark %d"), i + 1);
item = menu_item_add(submenu, text, G_CALLBACK(bar_pane_keywords_connect_mark_cb), pkd);
g_object_set_data(G_OBJECT(item), "mark", GINT_TO_POINTER(i + 1));
g_free(text);
}
text = g_strdup_printf(_("Connect \"%s\" to mark"), name);
item = menu_item_add(menu, text, NULL, NULL);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
g_free(text);
menu_item_add_divider(menu);
text = g_strdup_printf(_("Edit \"%s\""), name);
menu_item_add_stock(menu, text, GTK_STOCK_EDIT, G_CALLBACK(bar_pane_keywords_edit_dialog_cb), pkd);
g_free(text);
text = g_strdup_printf(_("Remove \"%s\""), name);
menu_item_add_stock(menu, text, GTK_STOCK_DELETE, G_CALLBACK(bar_pane_keywords_delete_cb), pkd);
g_free(text);
if (mark && mark[0])
{
text = g_strdup_printf(_("Disconnect \"%s\" from mark %s"), name, mark);
menu_item_add_stock(menu, text, GTK_STOCK_DELETE, G_CALLBACK(bar_pane_keywords_connect_mark_cb), pkd);
g_free(text);
}
menu_item_add_divider(menu);
g_free(mark);
g_free(name);
}
/* for the pane */
menu_item_add(menu, _("Expand checked"), G_CALLBACK(bar_pane_keywords_expand_checked_cb), pkd);
menu_item_add(menu, _("Collapse unchecked"), G_CALLBACK(bar_pane_keywords_collapse_unchecked_cb), pkd);
menu_item_add(menu, _("Hide unchecked"), G_CALLBACK(bar_pane_keywords_hide_unchecked_cb), pkd);
menu_item_add(menu, _("Show all"), G_CALLBACK(bar_pane_keywords_show_all_cb), pkd);
submenu = gtk_menu_new();
item = menu_item_add(menu, _("On any change"), NULL, NULL);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
menu_item_add_check(submenu, _("Expand checked"), pkd->expand_checked, G_CALLBACK(bar_pane_keywords_expand_checked_toggle_cb), pkd);
menu_item_add_check(submenu, _("Collapse unchecked"), pkd->collapse_unchecked, G_CALLBACK(bar_pane_keywords_collapse_unchecked_toggle_cb), pkd);
menu_item_add_check(submenu, _("Hide unchecked"), pkd->hide_unchecked, G_CALLBACK(bar_pane_keywords_hide_unchecked_toggle_cb), pkd);
gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, 0, GDK_CURRENT_TIME);
}
void sc_gui_update_editor_menu_cb(GObject *obj, const gchar *word, gint pos,
GeanyDocument *doc, gpointer user_data)
{
gchar *search_word;
g_return_if_fail(doc != NULL && doc->is_valid);
/* hide the submenu in any case, we will reshow it again if we actually found something */
gtk_widget_hide(sc_info->edit_menu);
gtk_widget_hide(sc_info->edit_menu_sep);
if (! sc_info->show_editor_menu_item)
return;
/* if we have a selection, prefer it over the current word */
if (sci_has_selection(doc->editor->sci))
{
gint len = sci_get_selected_text_length(doc->editor->sci);
search_word = g_malloc(len + 1);
sci_get_selected_text(doc->editor->sci, search_word);
}
else
search_word = g_strdup(word);
/* ignore numbers or words starting with digits and non-text */
if (EMPTY(search_word) || isdigit(*search_word) || ! sc_speller_is_text(doc, pos))
{
g_free(search_word);
return;
}
/* ignore too long search words */
if (strlen(search_word) > 100)
{
GtkWidget *menu_item;
init_editor_submenu();
menu_item = gtk_menu_item_new_with_label(
_("Search term is too long to provide\nspelling suggestions in the editor menu."));
gtk_widget_set_sensitive(menu_item, FALSE);
gtk_widget_show(menu_item);
gtk_container_add(GTK_CONTAINER(sc_info->edit_menu_sub), menu_item);
menu_item = gtk_menu_item_new_with_label(_("Perform Spell Check"));
gtk_widget_show(menu_item);
gtk_container_add(GTK_CONTAINER(sc_info->edit_menu_sub), menu_item);
g_signal_connect(menu_item, "activate", G_CALLBACK(perform_spell_check_cb), doc);
g_free(search_word);
return;
}
if (sc_speller_dict_check(search_word) != 0)
{
GtkWidget *menu_item, *menu;
gchar *label;
gsize n_suggs, i;
gchar **suggs;
suggs = sc_speller_dict_suggest(search_word, &n_suggs);
clickinfo.pos = pos;
clickinfo.doc = doc;
setptr(clickinfo.word, search_word);
menu = init_editor_submenu();
for (i = 0; i < n_suggs; i++)
{
if (i > 0 && i % 10 == 0)
{
menu_item = gtk_menu_item_new();
gtk_widget_show(menu_item);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
menu_item = gtk_menu_item_new_with_label(_("More..."));
gtk_widget_show(menu_item);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
menu = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item), menu);
}
menu_item = gtk_menu_item_new_with_label(suggs[i]);
gtk_widget_show(menu_item);
gtk_container_add(GTK_CONTAINER(menu), menu_item);
g_signal_connect(menu_item, "activate",
G_CALLBACK(menu_suggestion_item_activate_cb), NULL);
}
if (suggs == NULL)
{
menu_item = gtk_menu_item_new_with_label(_("(No Suggestions)"));
gtk_widget_set_sensitive(menu_item, FALSE);
gtk_widget_show(menu_item);
gtk_container_add(GTK_CONTAINER(sc_info->edit_menu_sub), menu_item);
}
menu_item = gtk_separator_menu_item_new();
gtk_widget_show(menu_item);
gtk_container_add(GTK_CONTAINER(sc_info->edit_menu_sub), menu_item);
label = g_strdup_printf(_("Add \"%s\" to Dictionary"), search_word);
menu_item = image_menu_item_new(GTK_STOCK_ADD, label);
gtk_widget_show(menu_item);
gtk_container_add(GTK_CONTAINER(sc_info->edit_menu_sub), menu_item);
g_signal_connect(menu_item, "activate",
G_CALLBACK(menu_addword_item_activate_cb), GINT_TO_POINTER(FALSE));
menu_item = image_menu_item_new(GTK_STOCK_REMOVE, _("Ignore All"));
gtk_widget_show(menu_item);
gtk_container_add(GTK_CONTAINER(sc_info->edit_menu_sub), menu_item);
g_signal_connect(menu_item, "activate",
G_CALLBACK(menu_addword_item_activate_cb), GINT_TO_POINTER(TRUE));
if (suggs != NULL)
sc_speller_dict_free_string_list(suggs);
g_free(label);
}
else
{
g_free(search_word);
}
}
struct menu *
gui_gtk_menu_new(struct container *co, GtkWidget **widget)
{
struct menu *this=g_new0(struct menu, 1);
this->gui=g_new0(struct menu_gui,1);
this->gui->co=co;
GtkWidget *menu,*item,*menu2,*item2,*menu3,*clock;
menu=gtk_menu_bar_new();
item=gtk_menu_item_new_with_label("Goto");
gtk_menu_bar_append(GTK_MENU_BAR(menu), item);
{
menu2=gtk_menu_new();
item2=gtk_menu_item_new_with_label("Abensberg");
gtk_menu_append (GTK_MENU(menu2), item2);
gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
GTK_SIGNAL_FUNC (menu_goto_abensberg), this);
item2=gtk_menu_item_new_with_label("Regensburg");
gtk_menu_append (GTK_MENU(menu2), item2);
gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
GTK_SIGNAL_FUNC (menu_goto_regensburg), this);
item2=gtk_menu_item_new_with_label("Problem");
gtk_menu_append (GTK_MENU(menu2), item2);
gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
GTK_SIGNAL_FUNC (menu_goto_problem), this);
}
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), menu2);
item=gtk_menu_item_new_with_label("Window");
gtk_menu_bar_append(GTK_MENU_BAR(menu), item);
{
menu2=gtk_menu_new();
item2=gtk_menu_item_new_with_label("Clone");
gtk_menu_append (GTK_MENU(menu2), item2);
gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
GTK_SIGNAL_FUNC (menu_window_clone), this);
item2=gtk_menu_item_new_with_label("Command");
gtk_menu_append (GTK_MENU(menu2), item2);
gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
GTK_SIGNAL_FUNC (menu_window_command), this);
item2=gtk_menu_item_new_with_label("Visible Blocks");
gtk_menu_append (GTK_MENU(menu2), item2);
gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
GTK_SIGNAL_FUNC (menu_window_visible_blocks), co);
item2=gtk_menu_item_new_with_label("Visible Towns");
gtk_menu_append (GTK_MENU(menu2), item2);
gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
GTK_SIGNAL_FUNC (menu_window_visible_towns), co);
item2=gtk_menu_item_new_with_label("Visible Polys");
gtk_menu_append (GTK_MENU(menu2), item2);
gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
GTK_SIGNAL_FUNC (menu_window_visible_polys), co);
item2=gtk_menu_item_new_with_label("Visible Streets");
gtk_menu_append (GTK_MENU(menu2), item2);
gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
GTK_SIGNAL_FUNC (menu_window_visible_streets), co);
menu_item(this, menu2, "Visible Points", menu_window_visible_points);
item2=gtk_menu_item_new_with_label("Exit");
gtk_menu_append (GTK_MENU(menu2), item2);
gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
GTK_SIGNAL_FUNC (exit), this);
}
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), menu2);
item=gtk_menu_item_new_with_label("Map");
gtk_menu_bar_append(GTK_MENU_BAR(menu), item);
{
menu2=gtk_menu_new();
item2=gtk_menu_item_new_with_label("Compare");
gtk_menu_append (GTK_MENU(menu2), item2);
gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
GTK_SIGNAL_FUNC (menu_map_compare), this);
item2=gtk_menu_item_new_with_label("Distances");
gtk_menu_append (GTK_MENU(menu2), item2);
gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
GTK_SIGNAL_FUNC (menu_map_distances), this);
}
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), menu2);
item=gtk_menu_item_new_with_label("Route");
gtk_menu_bar_append(GTK_MENU_BAR(menu), item);
{
menu2=gtk_menu_new();
item2=gtk_menu_item_new_with_label("Start");
gtk_menu_append (GTK_MENU(menu2), item2);
gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
GTK_SIGNAL_FUNC (route_start), co);
item2=gtk_menu_item_new_with_label("Trace");
gtk_menu_append (GTK_MENU(menu2), item2);
gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
GTK_SIGNAL_FUNC (route_trace), co);
item2=gtk_menu_item_new_with_label("Update");
gtk_menu_append (GTK_MENU(menu2), item2);
gtk_signal_connect_object(GTK_OBJECT(item2), "activate",
GTK_SIGNAL_FUNC (menu_route_update), this);
}
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), menu2);
item=gtk_menu_item_new_with_label("Destinations");
gtk_menu_bar_append(GTK_MENU_BAR(menu), item);
menu2=gtk_menu_new();
item2=gtk_menu_item_new_with_label("Last Destinations");
gtk_menu_append (GTK_MENU(menu2), item2);
menu3=gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item2), menu3);
item2=gtk_menu_item_new_with_label("Address");
gtk_menu_append (GTK_MENU(menu2), item2);
{
FILE *file;
char buffer[8192];
double lat,lng,lat_deg,lng_deg;
char lat_c,lng_c;
struct destination *dest;
int pos,len;
char *utf8,*text,*tok,*label;
GList *list;
file=fopen("locations.txt","r");
while (fgets(buffer,8192,file)) {
dest=malloc(sizeof(*dest));
dest->co=co;
len=strlen(buffer)-1;
while (len >= 0 && buffer[len] == '\n') {
buffer[len]='\0';
}
sscanf(buffer,"%lf %c %lf %c %n",&lat, &lat_c, &lng, &lng_c, &pos);
lat_deg=floor(lat/100);
lat-=lat_deg*100;
lat_deg+=lat/60;
lng_deg=floor(lng/100);
lng-=lng_deg*100;
lng_deg+=lng/60;
transform_mercator(&lng_deg, &lat_deg, &dest->pos);
text=buffer+pos;
dest->text=strdup(text);
item2=NULL;
menu3=menu2;
while ((tok=strtok(text,"/"))) {
list=NULL;
if (item2) {
menu3=gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item2), menu3);
}
list=gtk_container_get_children(GTK_CONTAINER(menu3));
while (list) {
item2=GTK_WIDGET(list->data);
gtk_label_get(GTK_LABEL(gtk_bin_get_child(GTK_BIN(item2))),&label);
if (!strcmp(label, tok)) {
menu3=gtk_menu_item_get_submenu(GTK_MENU_ITEM(item2));
break;
}
list=list->next;
}
item2=NULL;
if (! list) {
utf8=g_locale_to_utf8(tok,-1,NULL,NULL,NULL);
item2=gtk_menu_item_new_with_label(utf8);
gtk_menu_append (GTK_MENU(menu3), item2);
g_free(utf8);
}
text=NULL;
}
gtk_signal_connect(GTK_OBJECT(item2), "activate",
GTK_SIGNAL_FUNC (menu_destination_selected), dest);
}
}
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), menu2);
item=gtk_menu_item_new();
clock=gtk_label_new(NULL);
gtk_menu_item_right_justify(GTK_MENU_ITEM(item));
gtk_container_add(GTK_CONTAINER(item), clock);
gtk_menu_bar_append(GTK_MENU_BAR(menu), item);
menu_clock_update(clock);
*widget=menu;
return this;
}
int
main (int argc, char *argv[])
{
GtkWidget *button;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *menubar;
GtkWidget *menuitem;
GtkWidget *menu;
GtkWidget *entry;
GtkWidget *checkbutton;
GtkAccelGroup *accel_group;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_main_quit), NULL);
gtk_window_set_title (GTK_WINDOW (window), "Socket Test");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
menubar = gtk_menu_bar_new ();
menuitem = gtk_menu_item_new_with_mnemonic ("_File");
gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
menuitem = gtk_menu_item_new_with_mnemonic ("_Quit");
g_signal_connect (menuitem, "activate", G_CALLBACK (quit_cb), window);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
accel_group = gtk_accel_group_new ();
gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
gtk_box_pack_start (GTK_BOX (vbox), menubar, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Add Active Child");
gtk_box_pack_start (GTK_BOX(vbox), button, FALSE, FALSE, 0);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (add_active_child), vbox);
button = gtk_button_new_with_label ("Add Passive Child");
gtk_box_pack_start (GTK_BOX(vbox), button, FALSE, FALSE, 0);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (add_passive_child), vbox);
button = gtk_button_new_with_label ("Add Local Active Child");
gtk_box_pack_start (GTK_BOX(vbox), button, FALSE, FALSE, 0);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (add_local_active_child), vbox);
button = gtk_button_new_with_label ("Add Local Passive Child");
gtk_box_pack_start (GTK_BOX(vbox), button, FALSE, FALSE, 0);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (add_local_passive_child), vbox);
button = gtk_button_new_with_label ("Remove Last Child");
gtk_box_pack_start (GTK_BOX(vbox), button, FALSE, FALSE, 0);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (remove_child), vbox);
checkbutton = gtk_check_button_new_with_label ("Grab keyboard");
gtk_box_pack_start (GTK_BOX (vbox), checkbutton, FALSE, FALSE, 0);
g_signal_connect (checkbutton, "toggled",
G_CALLBACK (grab_window_toggled),
window);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX(hbox), entry, FALSE, FALSE, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
box = hbox;
gtk_widget_show_all (window);
gtk_main ();
if (n_children)
{
g_print ("Waiting for children to exit\n");
while (n_children)
g_main_context_iteration (NULL, TRUE);
}
return 0;
}
void
add_mainmenu_actions (GtkWidget *mainwin)
{
DB_plugin_t **plugins = deadbeef->plug_get_list();
int i;
for (i = 0; plugins[i]; i++)
{
if (!plugins[i]->get_actions)
continue;
DB_plugin_action_t *actions = plugins[i]->get_actions (NULL);
DB_plugin_action_t *action;
for (action = actions; action; action = action->next)
{
char *tmp = NULL;
if (0 == (action->flags & DB_ACTION_COMMON))
continue;
// 1st check if we have slashes
const char *slash = action->title;
while (NULL != (slash = strchr (slash, '/'))) {
if (slash && slash > action->title && *(slash-1) == '\\') {
slash++;
continue;
}
break;
}
if (!slash) {
continue;
}
char *ptr = tmp = strdup (action->title);
char *prev_title = NULL;
GtkWidget *current = mainwin;
GtkWidget *previous;
while (1)
{
// find unescaped forward slash
char *slash = strchr (ptr, '/');
if (slash && slash > ptr && *(slash-1) == '\\') {
ptr = slash + 1;
continue;
}
if (!slash)
{
GtkWidget *actionitem;
actionitem = gtk_image_menu_item_new_with_mnemonic (_(ptr));
gtk_widget_show (actionitem);
/* Here we have special cases for different submenus */
if (0 == strcmp ("File", prev_title))
gtk_menu_shell_insert (GTK_MENU_SHELL (current), actionitem, 5);
else if (0 == strcmp ("Edit", prev_title))
gtk_menu_shell_insert (GTK_MENU_SHELL (current), actionitem, 7);
else
gtk_container_add (GTK_CONTAINER (current), actionitem);
g_signal_connect ((gpointer) actionitem, "activate",
G_CALLBACK (on_actionitem_activate),
action);
break;
}
*slash = 0;
char menuname [1024];
snprintf (menuname, sizeof (menuname), "%s_menu", ptr);
previous = current;
current = lookup_widget (current, menuname);
if (!current)
{
GtkWidget *newitem;
newitem = gtk_menu_item_new_with_mnemonic (ptr);
gtk_widget_show (newitem);
//If we add new submenu in main bar, add it before 'Help'
if (NULL == prev_title)
gtk_menu_shell_insert (GTK_MENU_SHELL (previous), newitem, 4);
else
gtk_container_add (GTK_CONTAINER (previous), newitem);
current = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (newitem), current);
}
prev_title = ptr;
ptr = slash + 1;
}
if (tmp) {
free (tmp);
}
}
}
}
int main(int argc,char *argv[])
{
char dmmy[20];
GtkWidget *main_window;
GtkWidget *v_box;
GtkWidget *h_box;
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *right_side;
GtkWidget *game_border;
GtkWidget *next_block_border;
GdkBitmap *mask;
GtkWidget *menu_bar;
GtkWidget *menu_game;
GtkWidget *menu_game_menu;
GtkWidget *separatormenuitem1;
GtkWidget *separator1;
GtkWidget *menu_settings;
GtkWidget *menu_settings_menu;
GtkWidget *menu_help;
GtkWidget *menu_help_menu;
GtkWidget *help1;
GtkWidget *high_scores1;
GtkWidget *separator2;
GtkWidget *about1;
GtkAccelGroup* accel_group;
//init game values
game_play=FALSE;
get_opt_file(options_f,100);
read_options();
game_over = TRUE;
game_pause = FALSE;
current_x = current_y = 0;
current_block = current_frame = 0;
current_score = current_lines = 0;
current_level = options.level;
next_block = next_frame = 0;
// seed random generator
srandom(time(NULL));
//options.shw_nxt = TRUE;
gtk_set_locale();
gtk_init(&argc,&argv);
accel_group = gtk_accel_group_new();
// window
main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_policy(GTK_WINDOW(main_window),FALSE,FALSE,TRUE);
gtk_window_set_title(GTK_WINDOW(main_window),"GTK Tetris");
g_signal_connect ((gpointer) main_window, "key_press_event",
G_CALLBACK (keyboard_event_handler),
NULL);
// vertical box
v_box = gtk_vbox_new(FALSE,0);
gtk_container_add(GTK_CONTAINER(main_window),v_box);
gtk_widget_show(v_box);
// menu stuff
menu_bar = gtk_menu_bar_new();
gtk_widget_show(menu_bar);
gtk_box_pack_start(GTK_BOX(v_box),menu_bar,FALSE,FALSE,0);
//Game sub-menu
menu_game=gtk_menu_item_new_with_mnemonic ("_Game");
gtk_widget_show(menu_game);
gtk_container_add (GTK_CONTAINER (menu_bar), menu_game);
menu_game_menu=gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_game), menu_game_menu);
menu_game_quick = gtk_menu_item_new_with_mnemonic ("Start Game");
gtk_widget_show (menu_game_quick);
gtk_container_add (GTK_CONTAINER (menu_game_menu), menu_game_quick);
g_signal_connect ((gpointer) menu_game_quick, "activate",
G_CALLBACK (game_start_stop),
NULL);
gtk_widget_add_accelerator (menu_game_quick, "activate", accel_group,
GDK_G, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
menu_game_stop = gtk_menu_item_new_with_mnemonic ("Stop Game");
gtk_widget_show (menu_game_stop);
gtk_container_add (GTK_CONTAINER (menu_game_menu), menu_game_stop);
g_signal_connect ((gpointer) menu_game_stop, "activate",
G_CALLBACK (game_start_stop),
NULL);
gtk_widget_add_accelerator (menu_game_stop, "activate", accel_group,
GDK_O, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
gtk_widget_set_sensitive(menu_game_stop,FALSE);
menu_game_pause = gtk_check_menu_item_new_with_mnemonic ("Pause");
gtk_widget_show (menu_game_pause);
gtk_container_add (GTK_CONTAINER (menu_game_menu), menu_game_pause);
g_signal_connect ((gpointer) menu_game_pause, "activate",
G_CALLBACK (game_set_pause),
NULL);
gtk_widget_add_accelerator (menu_game_pause, "activate", accel_group,
GDK_P, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
separatormenuitem1 = gtk_menu_item_new ();
gtk_widget_show (separatormenuitem1);
gtk_container_add (GTK_CONTAINER (menu_game_menu), separatormenuitem1);
gtk_widget_set_sensitive (separatormenuitem1, FALSE);
menu_game_quit = gtk_menu_item_new_with_mnemonic ("Quit");
gtk_widget_show (menu_game_quit);
gtk_container_add (GTK_CONTAINER (menu_game_menu), menu_game_quit);
g_signal_connect ((gpointer) menu_game_quit, "activate",
G_CALLBACK (gtk_main_quit),
NULL);
gtk_widget_add_accelerator(menu_game_quit,"activate", accel_group,
GDK_X, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
//Settings sub-menu
menu_settings = gtk_menu_item_new_with_mnemonic ("_Settings");
gtk_widget_show (menu_settings);
gtk_container_add (GTK_CONTAINER (menu_bar), menu_settings);
menu_settings_menu=gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_settings),
menu_settings_menu);
menu_game_start = gtk_menu_item_new_with_mnemonic ("Level Settings");
gtk_widget_show (menu_game_start);
gtk_container_add (GTK_CONTAINER (menu_settings_menu), menu_game_start);
g_signal_connect ((gpointer) menu_game_start, "activate",
G_CALLBACK (show_new_game),
NULL);
menu_game_show_next_block = gtk_check_menu_item_new_with_mnemonic ("Show next block");
gtk_widget_show (menu_game_show_next_block);
gtk_container_add (GTK_CONTAINER (menu_settings_menu),
menu_game_show_next_block);
if (options.shw_nxt)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_game_show_next_block),
TRUE);
g_signal_connect ((gpointer) menu_game_show_next_block, "activate",
G_CALLBACK (game_show_next_block),
NULL);
gtk_widget_add_accelerator (menu_game_show_next_block, "activate",
accel_group,
GDK_N, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
separator1 = gtk_menu_item_new ();
gtk_widget_show (separator1);
gtk_container_add (GTK_CONTAINER (menu_settings_menu), separator1);
gtk_widget_set_sensitive (separator1, FALSE);
menu_save_options = gtk_menu_item_new_with_mnemonic ("Save Settings");
gtk_widget_show (menu_save_options);
gtk_container_add (GTK_CONTAINER (menu_settings_menu),
menu_save_options);
g_signal_connect ((gpointer) menu_save_options, "activate",
G_CALLBACK (save_options),
NULL);
//Help sub-menu
menu_help=gtk_menu_item_new_with_mnemonic ("_Help");
gtk_widget_show (menu_help);
gtk_container_add (GTK_CONTAINER (menu_bar), menu_help);
gtk_menu_item_set_right_justified (GTK_MENU_ITEM(menu_help),TRUE);
menu_help_menu = gtk_menu_new();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_help),
menu_help_menu);
help1 = gtk_menu_item_new_with_mnemonic ("Help");
gtk_widget_show (help1);
gtk_container_add (GTK_CONTAINER (menu_help_menu), help1);
g_signal_connect ((gpointer) help1, "activate",
G_CALLBACK (show_help),
NULL);
gtk_widget_add_accelerator (help1, "activate",
accel_group,
GDK_F1, (GdkModifierType) 0,
GTK_ACCEL_VISIBLE);
high_scores1 = gtk_menu_item_new_with_mnemonic ("High-scores");
gtk_widget_show (high_scores1);
gtk_container_add (GTK_CONTAINER (menu_help_menu), high_scores1);
g_signal_connect ((gpointer) high_scores1, "activate",
G_CALLBACK (show_highscore_wrapper),
NULL);
separator2 = gtk_menu_item_new ();
gtk_widget_show (separator2);
gtk_container_add (GTK_CONTAINER (menu_help_menu), separator2);
gtk_widget_set_sensitive (separator2, FALSE);
about1 = gtk_menu_item_new_with_mnemonic ("About");
gtk_widget_show (about1);
gtk_container_add (GTK_CONTAINER (menu_help_menu), about1);
g_signal_connect ((gpointer) about1, "activate",
G_CALLBACK (show_about),
NULL);
// horizontal box
h_box = gtk_hbox_new(FALSE,1);
gtk_widget_show(h_box);
gtk_box_pack_start(GTK_BOX(v_box),h_box,FALSE,FALSE,0);
// game_border
game_border = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(game_border),GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(h_box),game_border,FALSE,FALSE,1);
gtk_widget_show(game_border);
// game_area
game_area = gtk_drawing_area_new();
gtk_widget_show(game_area);
gtk_drawing_area_size(GTK_DRAWING_AREA(game_area),
MAX_X*BLOCK_WIDTH,MAX_Y*BLOCK_HEIGHT);
g_signal_connect ((gpointer) game_area, "expose_event",
G_CALLBACK (game_area_expose_event),
NULL);
gtk_widget_set_events(game_area, GDK_EXPOSURE_MASK);
gtk_container_add(GTK_CONTAINER(game_border),game_area);
// right_side
right_side = gtk_vbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(h_box),right_side,FALSE,FALSE,0);
gtk_widget_show(right_side);
// next_block_border
next_block_border = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(next_block_border),GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(right_side),next_block_border,FALSE,FALSE,0);
gtk_widget_show(next_block_border);
// next_block_area
next_block_area = gtk_drawing_area_new();
gtk_widget_show(next_block_area);
gtk_drawing_area_size(GTK_DRAWING_AREA(next_block_area),
4*BLOCK_WIDTH,4*BLOCK_HEIGHT);
g_signal_connect ((gpointer) next_block_area, "expose_event",
G_CALLBACK (next_block_area_expose_event),
NULL);
gtk_widget_set_events(next_block_area, GDK_EXPOSURE_MASK);
gtk_container_add(GTK_CONTAINER(next_block_border),next_block_area);
// the score,level and lines labels
score_label1 = gtk_label_new("Score:");
gtk_label_set_justify(GTK_LABEL(score_label1),GTK_JUSTIFY_RIGHT);
gtk_widget_show(score_label1);
gtk_box_pack_start(GTK_BOX(right_side),score_label1,FALSE,FALSE,3);
score_label2 = gtk_label_new("0");
set_gtk_color_style(score_label2,0xffff,0,0);
gtk_label_set_justify(GTK_LABEL(score_label2),GTK_JUSTIFY_RIGHT);
gtk_widget_show(score_label2);
gtk_box_pack_start(GTK_BOX(right_side),score_label2,FALSE,FALSE,3);
level_label1 = gtk_label_new("Level:");
gtk_label_set_justify(GTK_LABEL(level_label1),GTK_JUSTIFY_RIGHT);
gtk_widget_show(level_label1);
gtk_box_pack_start(GTK_BOX(right_side),level_label1,FALSE,FALSE,3);
sprintf(dmmy,"%d",current_level);
level_label2 = gtk_label_new(dmmy);
set_gtk_color_style(level_label2,0,0,0xffff);
gtk_label_set_justify(GTK_LABEL(level_label2),GTK_JUSTIFY_RIGHT);
gtk_widget_show(level_label2);
gtk_box_pack_start(GTK_BOX(right_side),level_label2,FALSE,FALSE,3);
lines_label1 = gtk_label_new("Lines:");
gtk_label_set_justify(GTK_LABEL(lines_label1),GTK_JUSTIFY_RIGHT);
gtk_widget_show(lines_label1);
gtk_box_pack_start(GTK_BOX(right_side),lines_label1,FALSE,FALSE,3);
lines_label2 = gtk_label_new("0");
gtk_label_set_justify(GTK_LABEL(lines_label2),GTK_JUSTIFY_RIGHT);
gtk_widget_show(lines_label2);
gtk_box_pack_start(GTK_BOX(right_side),lines_label2,FALSE,FALSE,3);
//the game buttons
//Start_stop
Start_stop_button = gtk_button_new();
gtk_widget_show(Start_stop_button);
g_signal_connect ((gpointer) Start_stop_button, "clicked",
G_CALLBACK (game_start_stop),
NULL);
Start_stop_button_label= gtk_label_new(start_stop_str[0]);
box2 = label_box(right_side, Start_stop_button_label,
start_stop_str[0] );
gtk_widget_show(box2);
gtk_container_add (GTK_CONTAINER (Start_stop_button), box2);
gtk_box_pack_start(GTK_BOX(right_side),Start_stop_button,FALSE,FALSE,3);
GTK_WIDGET_SET_FLAGS(Start_stop_button, GTK_CAN_DEFAULT);
gtk_widget_grab_default(Start_stop_button);
//Pause
Pause_button = gtk_button_new();
gtk_widget_show(Pause_button);
g_signal_connect ((gpointer) Pause_button, "clicked",
G_CALLBACK (game_set_pause_b),
NULL);
Pause_button_label = gtk_label_new(pause_str[0]);
box1 = label_box(right_side, Pause_button_label, pause_str[0] );
gtk_widget_show(box1);
gtk_container_add (GTK_CONTAINER (Pause_button), box1);
gtk_box_pack_start(GTK_BOX(right_side),Pause_button,FALSE,FALSE,3);
GTK_WIDGET_SET_FLAGS(Pause_button, GTK_CAN_DEFAULT);
gtk_widget_set_sensitive(Pause_button,FALSE);
gtk_window_add_accel_group (GTK_WINDOW (main_window), accel_group);
gtk_widget_show(main_window);
// Block images...
blocks_pixmap = gdk_pixmap_create_from_xpm_d(game_area->window,
&mask,
NULL,
(gchar **)blocks_xpm);
gtk_main ();
return 0;
}
static void notify_incoming_call(struct gtk_mod *mod,
struct call *call)
{
static const char *title = "Incoming call";
const char *msg = call_peeruri(call);
GtkWidget *call_menu;
GtkWidget *menu_item;
#if defined(USE_LIBNOTIFY)
NotifyNotification *notification;
if (!notify_is_initted())
return;
notification = notify_notification_new(title, msg, "baresip");
notify_notification_set_urgency(notification, NOTIFY_URGENCY_CRITICAL);
notify_notification_show(notification, NULL);
g_object_unref(notification);
#elif GLIB_CHECK_VERSION(2,40,0)
char id[64];
GVariant *target;
GNotification *notification = g_notification_new(title);
re_snprintf(id, sizeof id, "incoming-call-%p", call);
id[sizeof id - 1] = '\0';
#if GLIB_CHECK_VERSION(2,42,0)
g_notification_set_priority(notification,
G_NOTIFICATION_PRIORITY_URGENT);
#else
g_notification_set_urgent(notification, TRUE);
#endif
target = g_variant_new_int64(GPOINTER_TO_INT(call));
g_notification_set_body(notification, msg);
g_notification_add_button_with_target_value(notification,
"Answer", "app.answer", target);
g_notification_add_button_with_target_value(notification,
"Reject", "app.reject", target);
g_application_send_notification(mod->app, id, notification);
g_object_unref(notification);
#else
(void)msg;
(void)title;
#endif
/* Add incoming call to the app menu */
call_menu = gtk_menu_new();
menu_item = gtk_menu_item_new_with_mnemonic("_Incoming call");
g_object_set_data(G_OBJECT(menu_item), "call", call);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item),
call_menu);
gtk_menu_shell_prepend(GTK_MENU_SHELL(mod->app_menu), menu_item);
mod->incoming_call_menus = g_slist_append(mod->incoming_call_menus,
menu_item);
menu_item = gtk_menu_item_new_with_label(call_peeruri(call));
gtk_widget_set_sensitive(menu_item, FALSE);
gtk_menu_shell_append(GTK_MENU_SHELL(call_menu), menu_item);
menu_item = gtk_menu_item_new_with_mnemonic("_Accept");
g_object_set_data(G_OBJECT(menu_item), "call", call);
g_signal_connect(G_OBJECT(menu_item), "activate",
G_CALLBACK(menu_on_incoming_call_answer), mod);
gtk_menu_shell_append(GTK_MENU_SHELL(call_menu), menu_item);
menu_item = gtk_menu_item_new_with_mnemonic("_Reject");
g_object_set_data(G_OBJECT(menu_item), "call", call);
g_signal_connect(G_OBJECT(menu_item), "activate",
G_CALLBACK(menu_on_incoming_call_reject), mod);
gtk_menu_shell_append(GTK_MENU_SHELL(call_menu), menu_item);
}
GtkWidget* mooMenuBar (GtkWidget* window)
{
GtkWidget *menubar, *game, *view, *help;
GtkWidget *gamemenu, *viewmenu, *helpmenu;
GtkWidget *newgame, *quit, *hint, *rules, *about;
GtkWidget *newgame_image, *quit_image,
*hint_image, *rules_image;
GtkWidget *separator;
GtkAccelGroup *accel_group;
accel_group = gtk_accel_group_new ();
gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
gtk_menu_set_accel_group (GTK_MENU (menubar), accel_group);
/*-------------------------------------------*\
* Create menubar: Game, View, Help *
\*-------------------------------------------*/
menubar = gtk_menu_bar_new ();
game = gtk_menu_item_new_with_mnemonic ("_Game");
gtk_widget_show (game);
gtk_container_add (GTK_CONTAINER (menubar), game);
/*-->Game Menu Starts Here<--*/
gamemenu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (game), gamemenu);
gtk_widget_set_size_request (menubar, -1, 25);
newgame = gtk_image_menu_item_new_with_mnemonic ("_New Game");
gtk_widget_show (newgame);
gtk_container_add (GTK_CONTAINER (gamemenu), newgame);
gtk_widget_add_accelerator (newgame, "activate", accel_group,
GDK_N, (GdkModifierType) GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
newgame_image = gtk_image_new_from_stock ("gtk-new", GTK_ICON_SIZE_MENU);
gtk_widget_show (newgame_image);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (newgame), newgame_image);
g_signal_connect ((gpointer) newgame, "activate",
G_CALLBACK (start_newgame), NULL);
separator = gtk_separator_menu_item_new ();
gtk_widget_show (separator);
gtk_container_add (GTK_CONTAINER (gamemenu), separator);
gtk_widget_set_sensitive (separator, FALSE);
quit = gtk_image_menu_item_new_with_mnemonic ("_Quit");
gtk_widget_show (quit);
gtk_container_add (GTK_CONTAINER (gamemenu), quit);
gtk_widget_add_accelerator (quit, "activate", accel_group,
GDK_Q, (GdkModifierType) GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
quit_image = gtk_image_new_from_stock ("gtk-quit", GTK_ICON_SIZE_MENU);
//create_pixmap (mainwindow, "Eket Mask.xpm");
gtk_widget_show (quit_image);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (quit), quit_image);
g_signal_connect ((gpointer) quit, "activate",
G_CALLBACK (gtk_main_quit),
NULL);
/*-->Game Menu Ends Here<--*/
/*-->View Menu Starts Here Here<--*/
view = gtk_menu_item_new_with_mnemonic ("_View");
gtk_widget_show (view);
gtk_container_add (GTK_CONTAINER (menubar), view);
viewmenu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (view), viewmenu);
hint = gtk_image_menu_item_new_with_mnemonic ("Show _Hint");
gtk_widget_show (hint);
gtk_container_add (GTK_CONTAINER (viewmenu), hint);
gtk_widget_add_accelerator (hint, "activate", accel_group,
GDK_h, (GdkModifierType) GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
hint_image = gtk_image_new_from_stock ("gtk-dialog-info", GTK_ICON_SIZE_MENU);
gtk_widget_show (hint_image);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (hint), hint_image);
g_signal_connect ((gpointer) hint, "activate",
G_CALLBACK (showHint),
NULL);
/*-->View Menu Ends Here<--*/
/*-->Help Menu Starts Here<--*/
help = gtk_menu_item_new_with_mnemonic ("_Help");
gtk_widget_show (help);
gtk_container_add (GTK_CONTAINER (menubar), help);
helpmenu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (help), helpmenu);
rules = gtk_image_menu_item_new_with_mnemonic ("_Rules");
gtk_widget_show (rules);
gtk_container_add (GTK_CONTAINER (helpmenu), rules);
gtk_widget_add_accelerator (rules, "activate", accel_group,
GDK_F1, (GdkModifierType) 0,
GTK_ACCEL_VISIBLE);
rules_image = gtk_image_new_from_stock ("gtk-help", GTK_ICON_SIZE_MENU);
gtk_widget_show (rules_image);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (rules), rules_image);
g_signal_connect ((gpointer) rules, "activate",
G_CALLBACK (mooRules), NULL);
separator = gtk_separator_menu_item_new ();
gtk_widget_show (separator);
gtk_container_add (GTK_CONTAINER (helpmenu), separator);
gtk_widget_set_sensitive (separator, FALSE);
about = gtk_image_menu_item_new_from_stock ("gtk-about", accel_group);
gtk_widget_show (about);
gtk_container_add (GTK_CONTAINER (helpmenu), about);
g_signal_connect ((gpointer) about, "activate",
G_CALLBACK (init_about),
NULL);
/*-->Help Menu Ends Here<--*/
return menubar;
}
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;
}
static void
hn_others_menu_get_items (GtkMenu *menu,
HNOthersButton *button,
GtkTreeModel *model,
GtkTreeIter *iter)
{
GtkMenu *submenu = NULL;
GtkWidget *menu_item = NULL;
gchar *item_name = NULL;
gchar *item_comment = NULL;
GdkPixbuf *item_icon = NULL;
GdkPixbuf *item_thumb_icon = NULL;
gchar *item_exec = NULL;
gchar *item_service = NULL;
gchar *item_desktop_id = NULL;
gchar *item_text_domain = NULL;
GtkTreeIter child_iter;
gint children;
gboolean my_iterator = FALSE;
g_return_if_fail (menu);
if (!model)
{
GtkTreeIter iter0;
model = get_menu_contents();
iter = g_malloc0 (sizeof (GtkTreeIter));
my_iterator = TRUE;
/* Get the top level iterator. */
if (!gtk_tree_model_get_iter_first(model, &iter0) ||
!gtk_tree_model_iter_children(model, iter, &iter0))
{
g_object_unref (G_OBJECT (model));
return;
}
}
else
{
g_object_ref (G_OBJECT (model));
}
/* Loop! */
do {
item_name = NULL;
item_icon = NULL;
item_thumb_icon = NULL;
item_exec = NULL;
item_service = NULL;
item_desktop_id = NULL;
item_text_domain = NULL;
gtk_tree_model_get (model, iter,
TREE_MODEL_NAME, &item_name,
TREE_MODEL_ICON, &item_icon,
TREE_MODEL_THUMB_ICON, &item_thumb_icon,
TREE_MODEL_EXEC, &item_exec,
TREE_MODEL_SERVICE, &item_service,
TREE_MODEL_DESKTOP_ID, &item_desktop_id,
TREE_MODEL_COMMENT, &item_comment,
TREE_MODEL_TEXT_DOMAIN, &item_text_domain,
-1);
children = 0;
/* If the item has children. */
if (gtk_tree_model_iter_children (model, &child_iter, iter))
{
gchar *child_string = NULL;
/* It's a submenu */
submenu = GTK_MENU (gtk_menu_new ());
gtk_widget_set_name (GTK_WIDGET (submenu),
NAVIGATOR_MENU_NAME);
/* Create a menu item and add it to the menu. */
children = gtk_tree_model_iter_n_children (model, iter);
child_string = g_strdup_printf(MENU_ITEM_N_ITEMS (children), children);
menu_item = hildon_thumb_menu_item_new_with_labels (
(item_text_domain && *item_text_domain) ?
dgettext(item_text_domain, item_name):
_(item_name),
NULL,
child_string);
g_free(child_string);
gtk_menu_shell_append (GTK_MENU_SHELL (menu),
GTK_WIDGET (menu_item));
/* Add the submenu icon */
if (item_icon && item_thumb_icon)
{
hildon_thumb_menu_item_set_images (
HILDON_THUMB_MENU_ITEM (menu_item),
gtk_image_new_from_pixbuf (item_icon),
gtk_image_new_from_pixbuf (item_thumb_icon));
}
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item),
GTK_WIDGET (submenu));
/* Recurse! */
hn_others_menu_get_items(submenu, button, model, &child_iter);
}
else if ( !item_desktop_id || strlen( item_desktop_id ) == 0 )
{
/* Empty submenu. Skip "Extras" */
if (strcmp (item_name, "tana_fi_extras") != 0)
{
gchar *child_string;
submenu = GTK_MENU(gtk_menu_new());
gtk_widget_set_name (GTK_WIDGET(submenu),
NAVIGATOR_MENU_NAME);
/* Create a menu item and add it to the menu.
*/
child_string = g_strdup_printf(MENU_ITEM_N_ITEMS(children), children);
menu_item = hildon_thumb_menu_item_new_with_labels (
(item_text_domain && *item_text_domain)?
dgettext(item_text_domain, item_name):
dgettext("maemo-af-desktop", item_name),
NULL,
child_string);
g_free(child_string);
gtk_menu_shell_append (GTK_MENU_SHELL (menu),
GTK_WIDGET (menu_item));
/* Add the submenu icon */
if (item_icon)
{
hildon_thumb_menu_item_set_images(
HILDON_THUMB_MENU_ITEM(menu_item),
gtk_image_new_from_pixbuf(item_icon),
gtk_image_new_from_pixbuf(item_thumb_icon));
}
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item),
GTK_WIDGET (submenu));
/* Create a menu item and add it to the menu. */
GtkWidget *submenu_item =
gtk_image_menu_item_new_with_label (MENU_ITEM_EMPTY_SUBMENU_STRING);
gtk_widget_set_sensitive (submenu_item, FALSE);
gtk_menu_shell_append (GTK_MENU_SHELL (submenu),
GTK_WIDGET (submenu_item));
}
}
else if (strcmp(item_desktop_id, SEPARATOR_STRING) == 0)
{
/* Separator */
menu_item = gtk_separator_menu_item_new();
gtk_menu_shell_append (GTK_MENU_SHELL (menu),
GTK_WIDGET (menu_item));
}
else
{
/* Application */
menu_item = hildon_thumb_menu_item_new_with_labels (
(item_text_domain && *item_text_domain)?
dgettext(item_text_domain, item_name):
dgettext("maemo-af-desktop", item_name),
NULL,
/* work around strange behaviour of gettext for
* empty strings
*/
(item_comment && *item_comment)?_(item_comment):"");
if (!item_icon)
{
item_icon = get_icon (MENU_ITEM_DEFAULT_APP_ICON,
MENU_ITEM_ICON_SIZE);
}
if (!item_thumb_icon)
{
item_thumb_icon = get_icon (MENU_ITEM_DEFAULT_APP_ICON,
MENU_ITEM_THUMB_ICON_SIZE);
}
if (item_icon && item_thumb_icon)
{
hildon_thumb_menu_item_set_images (
HILDON_THUMB_MENU_ITEM (menu_item),
gtk_image_new_from_pixbuf (item_icon),
gtk_image_new_from_pixbuf (item_thumb_icon));
}
gtk_menu_shell_append (GTK_MENU_SHELL (menu),
GTK_WIDGET (menu_item));
g_object_set_data_full (G_OBJECT (menu_item),
DESKTOP_ENTRY_EXEC_FIELD,
g_strdup (item_exec),
g_free);
g_object_set_data_full (G_OBJECT(menu_item),
DESKTOP_ENTRY_SERVICE_FIELD,
g_strdup (item_service),
g_free);
/* Connect the signal and callback */
g_signal_connect (G_OBJECT (menu_item),
"activate",
G_CALLBACK (hn_others_menu_activate_item),
button);
}
g_free (item_name);
if (item_icon)
g_object_unref (G_OBJECT (item_icon));
if (item_thumb_icon)
g_object_unref (G_OBJECT (item_thumb_icon));
g_free (item_exec);
g_free (item_service);
g_free (item_desktop_id);
g_free (item_comment);
g_free (item_text_domain);
} while (gtk_tree_model_iter_next(model, iter));
if (my_iterator)
{
gtk_tree_iter_free (iter);
g_debug ("ref count remaining on model %d (should be 1)",
G_OBJECT (model)->ref_count);
}
g_object_unref (G_OBJECT (model));
}
void menu(int argc, char* argv[])
{
GtkWidget* window;
GtkWidget* box;
GtkWidget* menubar;
GtkWidget* menu;
GtkWidget* editmenu;
GtkWidget* helpmenu;
GtkWidget* rootmenu;
GtkWidget* menuitem;
GtkAccelGroup* accel_group;
gtk_init(&argc, &argv);
window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), txt("²Ëµ¥²âÊÔ³ÌÐò"));
g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
accel_group=gtk_accel_group_new();
gtk_window_add_accel_group(GTK_WINDOW(window), accel_group);
box=gtk_vbox_new(FALSE,0);
gtk_container_add(GTK_CONTAINER(window), box);
menu=gtk_menu_new(); //Îļþ²Ëµ¥
menuitem=gtk_image_menu_item_new_from_stock(GTK_STOCK_NEW, accel_group);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(on_menu_activate), (gpointer)(txt("н¨")));
menuitem=gtk_image_menu_item_new_from_stock(GTK_STOCK_OPEN, accel_group);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(on_menu_activate), (gpointer)(txt("´ò¿ª")));
menuitem=gtk_image_menu_item_new_from_stock(GTK_STOCK_SAVE, accel_group);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(on_menu_activate), (gpointer)(txt("±£´æ")));
menuitem=gtk_image_menu_item_new_from_stock(GTK_STOCK_SAVE_AS, accel_group);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(on_menu_activate), (gpointer)(txt("Áí´æΪ")));
menuitem=gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, accel_group);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(on_menu_activate), (gpointer)(txt("Í˳ö")));
rootmenu=gtk_menu_item_new_with_label(txt("Îļþ"));
gtk_menu_item_set_submenu(GTK_MENU_ITEM(rootmenu), menu);
menubar=gtk_menu_bar_new();
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), rootmenu);
//menuitem=gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, accel_group);
//gtk_menu_shell_append(GTK_MENU_SHELL(menubar), menuitem);
rootmenu=gtk_menu_item_new_with_label(txt("±à¼"));
editmenu=gtk_menu_new();//±à¼²Ëµ¥
menuitem=gtk_image_menu_item_new_from_stock(GTK_STOCK_CUT,accel_group);
gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), menuitem);
g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(on_menu_activate), (gpointer)(txt("¼ôÇÐ")));
menuitem=gtk_image_menu_item_new_from_stock(GTK_STOCK_COPY,accel_group);
gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), menuitem);
g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(on_menu_activate), (gpointer)(txt("¸´ÖÆ")));
menuitem=gtk_image_menu_item_new_from_stock(GTK_STOCK_PASTE,accel_group);
gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), menuitem);
g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(on_menu_activate), (gpointer)(txt("Õ³Ìù")));
menuitem=gtk_image_menu_item_new_from_stock(GTK_STOCK_FIND,accel_group);
gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), menuitem);
g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(on_menu_activate), (gpointer)(txt("²éÕÒ")));
gtk_menu_item_set_submenu(GTK_MENU_ITEM(rootmenu), editmenu);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), rootmenu);
rootmenu=gtk_menu_item_new_with_label(txt("°ïÖú"));
helpmenu=gtk_menu_new();//°ïÖú²Ëµ¥
menuitem=gtk_image_menu_item_new_from_stock(GTK_STOCK_HELP,accel_group);
gtk_menu_shell_append(GTK_MENU_SHELL(helpmenu), menuitem);
g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(on_menu_activate), (gpointer)(txt("°ïÖú")));
menuitem=gtk_menu_item_new_with_label(txt("¹ØÓÚ..."));
gtk_menu_shell_append(GTK_MENU_SHELL(helpmenu), menuitem);
g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(on_menu_activate), (gpointer)(txt("¹ØÓÚ")));
gtk_menu_item_set_submenu(GTK_MENU_ITEM(rootmenu), helpmenu);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), rootmenu);
gtk_box_pack_start(GTK_BOX(box), menubar, FALSE, FALSE, 0);
gtk_widget_show_all(window);
gtk_main();
}
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;
}
int main( int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *menubar;
GtkWidget *filemenu, *item_file, *item_new, *item_quit;
GtkWidget *editmenu, *item_edit, *item_undo, *item_redo, *item_cut, *item_copy, *item_paste;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_default_size(GTK_WINDOW(window), 250, 200);
gtk_window_set_title(GTK_WINDOW(window), "menu demo");
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), vbox);
menubar = gtk_menu_bar_new(); //菜单栏构件（menubar），实际上是一个menu shell
filemenu = gtk_menu_new(); //菜单构件(menu),也是一个menu shell
item_file = gtk_menu_item_new_with_label("File");
item_new = gtk_menu_item_new_with_label("New");
item_quit = gtk_menu_item_new_with_label("Quit");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_file), filemenu);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), item_new);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), item_quit); //把“quit”菜单选项被填加进file菜单中
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), item_file); //把“file”菜单选项被填加进菜单中（menubar）
/*这里构建Edit菜单，同上面的file菜单添加方法一样*/
editmenu = gtk_menu_new(); //菜单构件(menu),也是一个menu shell
item_edit = gtk_menu_item_new_with_label("Edit");
item_undo = gtk_menu_item_new_with_label("Undo");
item_redo = gtk_menu_item_new_with_label("Redo");
item_cut = gtk_menu_item_new_with_label("Cut");
item_copy = gtk_menu_item_new_with_label("Copy");
item_paste = gtk_menu_item_new_with_label("Paste");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_edit), editmenu);
gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), item_redo);
gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), item_cut);
gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), item_copy);
gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), item_paste);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), item_edit); //把“edit”菜单选项被填加进菜单中（menubar）
/*这里把窗口分为了上中下3个区域，最上面是menubar*/
gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 3);
g_signal_connect_swapped(G_OBJECT(window),
"destroy",G_CALLBACK(gtk_main_quit), NULL);
/*信号：当你单击“quit”菜单按钮，程序就会退出。*/
g_signal_connect(G_OBJECT(item_quit),
"activate",G_CALLBACK(gtk_main_quit), NULL);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
bool 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
: static_cast<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 ( n < numItems )
{
wxMenuItem* const itemNext = FindItemByPosition(n);
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);
}
}
return true;
}
void do_away_menu()
{
GtkWidget *menuitem;
GtkWidget *remmenu;
GtkWidget *submenu, *submenu2;
GtkWidget *remitem;
GtkWidget *image;
GdkPixbuf *pixbuf, *scale;
GList *l;
GSList *awy = away_messages;
struct away_message *a;
GList *con;
GaimConnection *gc = NULL;
GaimPluginProtocolInfo *prpl_info = NULL;
int count = 0;
if (prefs_away_store != NULL) {
gtk_list_store_clear(prefs_away_store);
while (awy) {
GtkTreeIter iter;
a = (struct away_message *)awy->data;
gtk_list_store_append(prefs_away_store, &iter);
gtk_list_store_set(prefs_away_store, &iter,
0, a->name,
1, a,
-1);
awy = g_slist_next(awy);
}
}
if (awaymenu) {
l = gtk_container_get_children(GTK_CONTAINER(awaymenu));
while (l) {
gtk_container_remove(GTK_CONTAINER(awaymenu), GTK_WIDGET(l->data));
l = l->next;
}
g_list_free(l);
remmenu = gtk_menu_new();
menuitem = gtk_menu_item_new_with_label(_("New Away Message"));
gtk_menu_shell_append(GTK_MENU_SHELL(awaymenu), menuitem);
gtk_widget_show(menuitem);
g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(create_away_mess),
NULL);
awy = away_messages;
while (awy) {
a = (struct away_message *)awy->data;
remitem = gtk_menu_item_new_with_label(a->name);
gtk_menu_shell_append(GTK_MENU_SHELL(remmenu), remitem);
gtk_widget_show(remitem);
g_signal_connect(G_OBJECT(remitem), "activate",
G_CALLBACK(rem_away_mess), a);
awy = g_slist_next(awy);
}
menuitem = gtk_menu_item_new_with_label(_("Remove Away Message"));
gtk_menu_shell_append(GTK_MENU_SHELL(awaymenu), menuitem);
gtk_widget_show(menuitem);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), remmenu);
gtk_widget_show(remmenu);
gaim_separator(awaymenu);
for (con = gaim_connections_get_all(); con != NULL; con = con->next) {
gc = con->data;
prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(gc->prpl);
if (prpl_info->away_states != NULL && prpl_info->set_away != NULL)
count++;
}
if (count == 0) {
} else if (count == 1) {
GList *msgs, *tmp;
for (con = gaim_connections_get_all(); con != NULL; con = con->next) {
gc = con->data;
prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(gc->prpl);
if (prpl_info->away_states && prpl_info->set_away)
break;
}
tmp = msgs = prpl_info->away_states(gc);
if ((g_list_length(msgs) == 1) && !strcmp(msgs->data, GAIM_AWAY_CUSTOM)) {
awy = away_messages;
while (awy) {
a = (struct away_message *)awy->data;
menuitem = gtk_menu_item_new_with_label(a->name);
g_object_set_data(G_OBJECT(menuitem), "away_message", a);
gtk_menu_shell_append(GTK_MENU_SHELL(awaymenu), menuitem);
gtk_widget_show(menuitem);
g_signal_connect(G_OBJECT(menuitem), "activate",
G_CALLBACK(do_away_message), a);
awy = g_slist_next(awy);
}
} else
while (msgs) {
awy = away_messages;
menuitem = gtk_menu_item_new_with_label(msgs->data);
g_object_set_data(G_OBJECT(menuitem), "away_state", msgs->data);
gtk_menu_shell_append(GTK_MENU_SHELL(awaymenu), menuitem);
gtk_widget_show(menuitem);
if (strcmp(msgs->data, GAIM_AWAY_CUSTOM)) {
g_signal_connect(G_OBJECT(menuitem), "activate",
G_CALLBACK(set_gc_state), gc);
} else {
submenu = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem),
submenu);
gtk_widget_show(submenu);
while (awy) {
a = (struct away_message *)awy->data;
menuitem = gtk_menu_item_new_with_label(a->name);
g_object_set_data(G_OBJECT(menuitem), "away_message",
a);
gtk_menu_shell_append(GTK_MENU_SHELL(awaymenu),
menuitem);
gtk_widget_show(menuitem);
g_signal_connect(G_OBJECT(menuitem),
"activate",
G_CALLBACK
(do_away_message), a);
awy = g_slist_next(awy);
}
}
msgs = g_list_next(msgs);
}
g_list_free(tmp);
}
else {
for (con = gaim_connections_get_all(); con != NULL; con = con->next) {
GaimAccount *account;
char buf[256];
GList *msgs, *tmp;
gc = con->data;
prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(gc->prpl);
if (!prpl_info->away_states || !prpl_info->set_away)
continue;
account = gaim_connection_get_account(gc);
g_snprintf(buf, sizeof(buf), "%s (%s)",
gaim_account_get_username(account),
gaim_account_get_protocol_name(account));
menuitem = gtk_image_menu_item_new_with_label(buf);
pixbuf = create_prpl_icon(gc->account);
if (pixbuf) {
scale = gdk_pixbuf_scale_simple(pixbuf, 16, 16, GDK_INTERP_BILINEAR);
image = gtk_image_new_from_pixbuf(scale);
g_object_unref(G_OBJECT(pixbuf));
g_object_unref(G_OBJECT(scale));
gtk_widget_show(image);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menuitem),
image);
}
gtk_menu_shell_append(GTK_MENU_SHELL(awaymenu), menuitem);
gtk_widget_show(menuitem);
submenu = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), submenu);
gtk_widget_show(submenu);
tmp = msgs = prpl_info->away_states(gc);
if ((g_list_length(msgs) == 1) &&
(!strcmp(msgs->data, GAIM_AWAY_CUSTOM))) {
menuitem = gtk_menu_item_new_with_label(_("Back"));
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), menuitem);
gtk_widget_show(menuitem);
g_signal_connect(G_OBJECT(menuitem), "activate",
G_CALLBACK(set_gc_away), gc);
gaim_separator(submenu);
awy = away_messages;
while (awy) {
a = (struct away_message *)awy->data;
menuitem = gtk_menu_item_new_with_label(a->name);
g_object_set_data(G_OBJECT(menuitem), "away_message", a);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), menuitem);
gtk_widget_show(menuitem);
g_signal_connect(G_OBJECT(menuitem), "activate",
G_CALLBACK(set_gc_away), gc);
awy = g_slist_next(awy);
}
} else
while (msgs) {
awy = away_messages;
menuitem = gtk_menu_item_new_with_label(msgs->data);
g_object_set_data(G_OBJECT(menuitem), "away_state",
msgs->data);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), menuitem);
gtk_widget_show(menuitem);
if (strcmp(msgs->data, GAIM_AWAY_CUSTOM)) {
g_signal_connect(G_OBJECT(menuitem),
"activate",
G_CALLBACK(set_gc_state),
gc);
} else {
submenu2 = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM
(menuitem), submenu2);
gtk_widget_show(submenu2);
while (awy) {
a = (struct away_message *)awy->data;
menuitem =
gtk_menu_item_new_with_label(a->
name);
g_object_set_data(G_OBJECT(menuitem),
"away_message", a);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu2),
menuitem);
gtk_widget_show(menuitem);
g_signal_connect(G_OBJECT(menuitem),
"activate",
G_CALLBACK
(set_gc_away), gc);
awy = g_slist_next(awy);
}
}
msgs = g_list_next(msgs);
}
g_list_free(tmp);
}
menuitem = gtk_menu_item_new_with_label(_("Set All Away"));
gtk_menu_shell_append(GTK_MENU_SHELL(awaymenu), menuitem);
gtk_widget_show(menuitem);
submenu = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), submenu);
gtk_widget_show(submenu);
awy = away_messages;
while (awy) {
a = (struct away_message *)awy->data;
menuitem = gtk_menu_item_new_with_label(a->name);
g_object_set_data(G_OBJECT(menuitem), "away_message", a);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), menuitem);
gtk_widget_show(menuitem);
g_signal_connect(G_OBJECT(menuitem), "activate",
G_CALLBACK(do_away_message), a);
awy = g_slist_next(awy);
}
}
}
if (prefs_away_menu) {
l = gtk_container_get_children(GTK_CONTAINER(prefs_away_menu));
while (l) {
gtk_widget_destroy(GTK_WIDGET(l->data));
l = l->next;
}
gtk_widget_hide(GTK_WIDGET(prefs_away_menu));
default_away_menu_init(GTK_WIDGET(prefs_away_menu));
gtk_widget_show(prefs_away_menu);
}
}
MetaWindowMenu*
meta_window_menu_new (MetaFrames *frames,
MetaMenuOp ops,
MetaMenuOp insensitive,
Window client_xwindow,
unsigned long active_workspace,
int n_workspaces,
MetaWindowMenuFunc func,
gpointer data)
{
int i;
MetaWindowMenu *menu;
/* FIXME: Modifications to 'ops' should happen in meta_window_show_menu */
if (n_workspaces < 2)
ops &= ~(META_MENU_OP_STICK | META_MENU_OP_UNSTICK | META_MENU_OP_WORKSPACES);
else if (n_workspaces == 2)
/* #151183: If we only have two workspaces, disable the menu listing them. */
ops &= ~(META_MENU_OP_WORKSPACES);
menu = g_new (MetaWindowMenu, 1);
menu->frames = frames;
menu->client_xwindow = client_xwindow;
menu->func = func;
menu->data = data;
menu->ops = ops;
menu->insensitive = insensitive;
menu->menu = gtk_menu_new ();
gtk_menu_set_screen (GTK_MENU (menu->menu),
gtk_widget_get_screen (GTK_WIDGET (frames)));
for (i = 0; i < (int) G_N_ELEMENTS (menuitems); i++)
{
MenuItem menuitem = menuitems[i];
if (ops & menuitem.op || menuitem.op == 0)
{
GtkWidget *mi;
MenuData *md;
unsigned int key;
MetaVirtualModifier mods;
mi = menu_item_new (&menuitem, -1);
/* Set the activeness of radiobuttons. */
switch (menuitem.op)
{
case META_MENU_OP_STICK:
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi),
active_workspace == 0xFFFFFFFF);
break;
case META_MENU_OP_UNSTICK:
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi),
active_workspace != 0xFFFFFFFF);
break;
default:
break;
}
if (menuitem.type == MENU_ITEM_WORKSPACE_LIST)
{
if (ops & META_MENU_OP_WORKSPACES)
{
Display *display;
Window xroot;
GdkScreen *screen;
GtkWidget *submenu;
int j;
MenuItem to_another_workspace = {
0, MENU_ITEM_NORMAL,
NULL, FALSE,
N_("Move to Another _Workspace")
};
meta_verbose ("Creating %d-workspace menu current space %lu\n",
n_workspaces, active_workspace);
display = gdk_x11_drawable_get_xdisplay (GTK_WIDGET (frames)->window);
screen = gdk_drawable_get_screen (GTK_WIDGET (frames)->window);
xroot = GDK_DRAWABLE_XID (gdk_screen_get_root_window (screen));
submenu = gtk_menu_new ();
g_assert (mi==NULL);
mi = menu_item_new (&to_another_workspace, -1);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (mi), submenu);
for (j = 0; j < n_workspaces; j++)
{
char *label;
MenuData *md;
unsigned int key;
MetaVirtualModifier mods;
MenuItem moveitem;
GtkWidget *submi;
meta_core_get_menu_accelerator (META_MENU_OP_WORKSPACES,
j + 1,
&key, &mods);
label = get_workspace_name_with_accel (display, xroot, j);
moveitem.type = MENU_ITEM_NORMAL;
moveitem.op = META_MENU_OP_WORKSPACES;
moveitem.label = label;
submi = menu_item_new (&moveitem, j + 1);
g_free (label);
if ((active_workspace == (unsigned)j) && (ops & META_MENU_OP_UNSTICK))
gtk_widget_set_sensitive (submi, FALSE);
md = g_new (MenuData, 1);
md->menu = menu;
md->op = META_MENU_OP_WORKSPACES;
g_object_set_data (G_OBJECT (submi),
"workspace",
GINT_TO_POINTER (j));
gtk_signal_connect_full (GTK_OBJECT (submi),
"activate",
G_CALLBACK (activate_cb),
NULL,
md,
g_free, FALSE, FALSE);
gtk_menu_shell_append (GTK_MENU_SHELL (submenu), submi);
gtk_widget_show (submi);
}
}
else
meta_verbose ("not creating workspace menu\n");
}
else if (menuitem.type != MENU_ITEM_SEPARATOR)
{
meta_core_get_menu_accelerator (menuitems[i].op, -1,
&key, &mods);
if (insensitive & menuitem.op)
gtk_widget_set_sensitive (mi, FALSE);
md = g_new (MenuData, 1);
md->menu = menu;
md->op = menuitem.op;
gtk_signal_connect_full (GTK_OBJECT (mi),
"activate",
G_CALLBACK (activate_cb),
NULL,
md,
g_free, FALSE, FALSE);
}
if (mi)
{
gtk_menu_shell_append (GTK_MENU_SHELL (menu->menu), mi);
gtk_widget_show (mi);
}
}
}
g_signal_connect (menu->menu, "selection_done", G_CALLBACK(menu_closed), menu);
return menu;
}
void ui_set_menu() {
mwin->menu = gtk_menu_bar_new();
GtkAccelGroup *group_file = ui_set_menu_item(&(mwin->menu_file),
&(mwin->menu_file_item), "_File");
GtkAccelGroup *group_edit = ui_set_menu_item(&(mwin->menu_edit),
&(mwin->menu_edit_item), "_Edit");
GtkAccelGroup *group_help = ui_set_menu_item(&(mwin->menu_help),
&(mwin->menu_help_item), "_Help");
/* create submenu items */
mwin->menu_file_item_open = gtk_menu_item_new_with_mnemonic("_Open");
mwin->menu_file_item_compare = gtk_menu_item_new_with_mnemonic("_Compare To");
mwin->menu_file_item_exit = gtk_menu_item_new_with_mnemonic("_Exit");
mwin->menu_file_item_space = gtk_separator_menu_item_new();
mwin->menu_edit_item_update = gtk_menu_item_new_with_mnemonic("_Update");
mwin->menu_edit_item_purge = gtk_menu_item_new_with_mnemonic("_Purge Lists");
mwin->menu_help_item_about = gtk_menu_item_new_with_mnemonic("_About");
/* add accelerator keys to menu */
gtk_widget_add_accelerator(mwin->menu_file_item_open, "activate",
group_file, GDK_KEY_O, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_add_accelerator(mwin->menu_file_item_compare, "activate",
group_file, GDK_KEY_L, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_add_accelerator(mwin->menu_file_item_exit, "activate",
group_file, GDK_KEY_Q, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_add_accelerator(mwin->menu_edit_item_update, "activate",
group_edit, GDK_KEY_U, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_add_accelerator(mwin->menu_edit_item_purge, "activate",
group_edit, GDK_KEY_P, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_add_accelerator(mwin->menu_help_item_about, "activate",
group_help, GDK_KEY_A, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
/* append menu items to menus */
gtk_menu_shell_append(GTK_MENU_SHELL(mwin->menu_file), mwin->menu_file_item_open);
gtk_menu_shell_append(GTK_MENU_SHELL(mwin->menu_file), mwin->menu_file_item_compare);
gtk_menu_shell_append(GTK_MENU_SHELL(mwin->menu_file), mwin->menu_file_item_space);
gtk_menu_shell_append(GTK_MENU_SHELL(mwin->menu_file), mwin->menu_file_item_exit);
gtk_menu_shell_append(GTK_MENU_SHELL(mwin->menu_edit), mwin->menu_edit_item_update);
gtk_menu_shell_append(GTK_MENU_SHELL(mwin->menu_edit), mwin->menu_edit_item_purge);
gtk_menu_shell_append(GTK_MENU_SHELL(mwin->menu_help), mwin->menu_help_item_about);
/* attach callback functions to menu-items */
g_signal_connect_swapped(G_OBJECT(mwin->menu_file_item_open),
"activate", G_CALLBACK(menu_signal_open), (gpointer)nb_lists_mov_tab);
g_signal_connect_swapped(G_OBJECT(mwin->menu_file_item_compare),
"activate", G_CALLBACK(menu_signal_open), (gpointer)nb_lists_lst_tab);
g_signal_connect_swapped(G_OBJECT(mwin->menu_file_item_exit),
"activate", G_CALLBACK(menu_signal_quit), (gpointer)mwin->main);
g_signal_connect_swapped(G_OBJECT(mwin->menu_edit_item_update),
"activate", G_CALLBACK(menu_signal_update), (gpointer)mwin->main);
g_signal_connect_swapped(G_OBJECT(mwin->menu_edit_item_purge),
"activate", G_CALLBACK(menu_signal_purge), (gpointer)mwin->main);
g_signal_connect_swapped(G_OBJECT(mwin->menu_help_item_about),
"activate", G_CALLBACK(menu_signal_about), (gpointer)mwin->main);
/* add submenus to menu items */
gtk_menu_item_set_submenu(GTK_MENU_ITEM(mwin->menu_file_item),
mwin->menu_file);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(mwin->menu_edit_item),
mwin->menu_edit);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(mwin->menu_help_item),
mwin->menu_help);
/* add to main menubar */
gtk_menu_shell_append(GTK_MENU_SHELL(mwin->menu), mwin->menu_file_item);
gtk_menu_shell_append(GTK_MENU_SHELL(mwin->menu), mwin->menu_edit_item);
gtk_menu_shell_append(GTK_MENU_SHELL(mwin->menu), mwin->menu_help_item);
}
