GtkWidget *menu_bar_init(GtkWindow* window, GtkWidget* vbox)
{
GtkWidget *menubar, *filemenu, *file, *save, *about, *close, *separator;
GtkAccelGroup *group;
group = gtk_accel_group_new();
menubar = gtk_menu_bar_new();
file = gtk_menu_item_new_with_label("File");
filemenu = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), filemenu);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), file);
save = gtk_image_menu_item_new_from_stock(GTK_STOCK_SAVE, group);
separator = gtk_separator_menu_item_new();
about = gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT, group);
close = gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, group);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), save);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), separator);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), about);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), close);
g_signal_connect(G_OBJECT(save), "activate", G_CALLBACK(ui_action_save_file), window);
g_signal_connect(G_OBJECT(about), "activate", G_CALLBACK(ui_action_show_about_dialog), NULL);
g_signal_connect_swapped(G_OBJECT(close), "activate", G_CALLBACK(ui_action_destroy), window);
gtk_window_add_accel_group(window, group);
gtk_box_pack_start_defaults(GTK_BOX(vbox), menubar);
return menubar;
}
GtkWidget *makeMenubar(uiWindow *w)
{
GtkWidget *menubar;
guint i, j;
uiMenu *m;
GtkWidget *menuitem;
GtkWidget *submenu;
menusFinalized = TRUE;
menubar = gtk_menu_bar_new();
if (menus != NULL)
for (i = 0; i < menus->len; i++) {
m = g_array_index(menus, uiMenu *, i);
menuitem = gtk_menu_item_new_with_label(m->name);
submenu = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), submenu);
for (j = 0; j < m->items->len; j++)
appendMenuItem(GTK_MENU_SHELL(submenu), g_array_index(m->items, uiMenuItem *, j), w);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), menuitem);
}
gtk_widget_set_hexpand(menubar, TRUE);
gtk_widget_set_halign(menubar, GTK_ALIGN_FILL);
return menubar;
}
void build_menus( GtkWidget* window )
{
GtkWidget* menu_bar;
GtkWidget* file_menu;
GtkWidget* file_item;
GtkWidget* file_open;
GtkWidget* file_quit;
menu_bar = gtk_menu_bar_new( );
file_menu = gtk_menu_new( );
file_open = gtk_menu_item_new_with_label( "Open" );
gtk_signal_connect_object( GTK_OBJECT( file_open ), "activate",
GTK_SIGNAL_FUNC( show_open_dialog ), NULL );
gtk_menu_append( GTK_MENU( file_menu ), file_open );
gtk_widget_show( file_open );
file_quit = gtk_menu_item_new_with_label( "Quit" );
gtk_signal_connect_object( GTK_OBJECT( file_quit ), "activate",
GTK_SIGNAL_FUNC( query_quit ), NULL );
gtk_menu_append( GTK_MENU( file_menu ), file_quit );
gtk_widget_show( file_quit );
file_item = gtk_menu_item_new_with_label( "File" );
gtk_menu_item_set_submenu( GTK_MENU_ITEM( file_item ), file_menu );
gtk_widget_show( file_item );
gtk_menu_bar_append( GTK_MENU_BAR( menu_bar ), file_item );
gtk_container_add( GTK_CONTAINER( window ), menu_bar );
gtk_widget_show( menu_bar );
}
GtkWidget *createMenu()
{
//建立菜单条并把第一级菜单项放入
GtkWidget *menubar=gtk_menu_bar_new();//建立菜单条
GtkWidget *menuitem[2];
menuitem[0]=gtk_menu_item_new_with_label("文件");//建立菜单项
gtk_menu_bar_append(GTK_MENU_BAR(menubar),menuitem[0]);//把菜单项加入到菜单条中
menuitem[1]=gtk_menu_item_new_with_label("帮助");
gtk_menu_bar_append(GTK_MENU_BAR(menubar),menuitem[1]);
GtkWidget *menu[2];
//建立menuitem[0]的子菜单
menu[0]=gtk_menu_new();//建立菜单
GtkWidget *menuitem0_0=gtk_menu_item_new_with_label("退出");
gtk_menu_shell_append(GTK_MENU_SHELL(menu[0]),menuitem0_0);//把菜单项加入到菜单中
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem[0]),menu[0]);//最后把菜单menu1粘到菜单项menuitem1上
//如法炮制menuitem[1]的子菜单
menu[1]=gtk_menu_new();
GtkWidget *menuitem1_0=gtk_menu_item_new_with_label("关于");
gtk_menu_shell_append(GTK_MENU_SHELL(menu[1]),menuitem1_0);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem[1]),menu[1]);
//连接信号和函数
gtk_signal_connect(GTK_OBJECT(menuitem0_0),"activate",GTK_SIGNAL_FUNC(gtk_main_quit),NULL);
gtk_signal_connect(GTK_OBJECT(menuitem1_0),"activate",GTK_SIGNAL_FUNC(about_system),NULL);
return menubar;
}
static GtkWidget*
CreateMenuBarWidget()
{
GtkWidget* widget = gtk_menu_bar_new();
AddToWindowContainer(widget);
return widget;
}
static void create_menubar() {
browser->menubar = gtk_menu_bar_new();
browser->bookmark_menu_item = gtk_image_menu_item_new_from_stock(GTK_STOCK_CDROM, NULL);
gtk_menu_item_set_label(GTK_MENU_ITEM(browser->bookmark_menu_item), _("Bookmarks"));
update_bookmark_menu();
gtk_menu_shell_append(GTK_MENU_SHELL(browser->menubar), browser->bookmark_menu_item);
}
GtkMenuItemImpl::MenuPieces* GtkMenuItemImpl::Realize(bool is_menu_bar)
{
MenuPieces* pieces = new MenuPieces();
if (this->parent == NULL) // top-level
{
if (is_menu_bar)
pieces->menu = gtk_menu_bar_new();
else
pieces->menu = gtk_menu_new();
}
else
{
this->MakeMenuPieces(*pieces);
}
/* Realize this widget's children */
if (this->IsSubMenu() || this->parent == NULL)
{
std::vector<GtkMenuItemImpl*>::iterator i = this->children.begin();
while (i != this->children.end())
{
MenuPieces* child_pieces = (*i)->Realize(false);
child_pieces->parent_menu = pieces->menu;
gtk_menu_shell_append(
GTK_MENU_SHELL(pieces->menu),
child_pieces->item);
gtk_widget_show(child_pieces->item);
i++;
}
}
this->instances.push_back(pieces);
return pieces;
}
GtkWidget* CreateMenuBar() {
GtkWidget* menu_bar = gtk_menu_bar_new();
GtkWidget* debug_menu = CreateMenu(menu_bar, "Tests");
AddMenuEntry(debug_menu, "Get Source",
G_CALLBACK(GetSourceActivated));
AddMenuEntry(debug_menu, "Get Text",
G_CALLBACK(GetTextActivated));
AddMenuEntry(debug_menu, "Popup Window",
G_CALLBACK(PopupWindowActivated));
AddMenuEntry(debug_menu, "Request",
G_CALLBACK(RequestActivated));
AddMenuEntry(debug_menu, "Plugin Info",
G_CALLBACK(PluginInfoActivated));
AddMenuEntry(debug_menu, "Zoom In",
G_CALLBACK(ZoomInActivated));
AddMenuEntry(debug_menu, "Zoom Out",
G_CALLBACK(ZoomOutActivated));
AddMenuEntry(debug_menu, "Zoom Reset",
G_CALLBACK(ZoomResetActivated));
AddMenuEntry(debug_menu, "Begin Tracing",
G_CALLBACK(BeginTracingActivated));
AddMenuEntry(debug_menu, "End Tracing",
G_CALLBACK(EndTracingActivated));
AddMenuEntry(debug_menu, "Other Tests",
G_CALLBACK(OtherTestsActivated));
return menu_bar;
}
void make_menus(GtkWidget *box)
{
GtkWidget *menu, *menu_bar, *root_menu, *menu_items;
/* FILE menu */
menu = gtk_menu_new ();
menu_items = gtk_menu_item_new_with_label ("Open");
gtk_menu_append (GTK_MENU (menu), menu_items);
gtk_signal_connect_object (GTK_OBJECT (menu_items), "activate",
GTK_SIGNAL_FUNC(open_func), NULL);
gtk_widget_show(menu_items);
menu_items = gtk_menu_item_new_with_label ("Exit");
gtk_menu_append (GTK_MENU (menu), menu_items);
gtk_signal_connect_object (GTK_OBJECT (menu_items), "activate",
GTK_SIGNAL_FUNC(exit_func), NULL);
gtk_widget_show(menu_items);
root_menu = gtk_menu_item_new_with_label ("File");
gtk_widget_show (root_menu);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (root_menu), menu);
menu_bar = gtk_menu_bar_new ();
gtk_box_pack_start (GTK_BOX (box), menu_bar, FALSE, FALSE, 0);
gtk_widget_show (menu_bar);
gtk_menu_bar_append (GTK_MENU_BAR (menu_bar), root_menu);
/* OPTIONS menu */
menu = gtk_menu_new ();
menu_items = gtk_menu_item_new_with_label ("Options");
gtk_menu_append (GTK_MENU (menu), menu_items);
gtk_signal_connect_object (GTK_OBJECT (menu_items), "activate",
GTK_SIGNAL_FUNC(open_options_window), NULL);
gtk_widget_show(menu_items);
// root_menu = gtk_menu_item_new_with_label ("Options");
// gtk_widget_show (root_menu);
root_menu = gtk_menu_item_new_with_label ("Options");
gtk_widget_show (root_menu);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (root_menu), menu);
gtk_menu_bar_append (GTK_MENU_BAR (menu_bar), root_menu);
/* HELP menu */
menu = gtk_menu_new ();
menu_items = gtk_menu_item_new_with_label ("About");
gtk_menu_append (GTK_MENU (menu), menu_items);
gtk_signal_connect_object (GTK_OBJECT (menu_items), "activate",
GTK_SIGNAL_FUNC(open_about_menu), NULL);
gtk_widget_show(menu_items);
menu_items = gtk_menu_item_new_with_label ("Help");
gtk_menu_append (GTK_MENU (menu), menu_items);
gtk_signal_connect_object (GTK_OBJECT (menu_items), "activate",
GTK_SIGNAL_FUNC(open_help_menu), NULL);
gtk_widget_show(menu_items);
root_menu = gtk_menu_item_new_with_label ("Help");
gtk_widget_show (root_menu);
//gtk_menu_item_right_justify(GTK_MENU_ITEM(root_menu)); //(for later)
gtk_menu_item_set_submenu (GTK_MENU_ITEM (root_menu), menu);
gtk_menu_bar_append (GTK_MENU_BAR (menu_bar), root_menu);
}
GtkWidget *
gu_menubar_add(gu_window_t *gw, GtkWidget *parent)
{
GtkAccelGroup *accel_group;
GtkWidget *menubar;
accel_group = gtk_accel_group_new();
menubar = gtk_menu_bar_new();
gtk_box_pack_start(GTK_BOX(parent), menubar, FALSE, TRUE, 0);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar),
gu_menubar_File(gw, accel_group));
gtk_menu_shell_append(GTK_MENU_SHELL(menubar),
gu_menubar_View(gw, accel_group));
gtk_menu_shell_append(GTK_MENU_SHELL(menubar),
gu_menubar_Go(gw, accel_group));
gtk_menu_shell_append(GTK_MENU_SHELL(menubar),
gu_menubar_Help(gw, accel_group));
gtk_window_add_accel_group(GTK_WINDOW(gw->gw_window), accel_group);
return menubar;
}
wxColor DrawingUtils::GetMenuBarBgColour()
{
#ifdef __WXGTK__
static bool intitialized(false);
static wxColour textColour(wxSystemSettings::GetColour(wxSYS_COLOUR_MENUBAR));
if( !intitialized ) {
// try to get the background colour from a menu
GtkWidget *menuBar = gtk_menu_bar_new();
#ifdef __WXGTK3__
GdkRGBA col;
GtkStyleContext* context = gtk_widget_get_style_context( menuBar );
gtk_style_context_get_background_color(context, GTK_STATE_FLAG_NORMAL, &col);
textColour = wxColour(col);
#else
GtkStyle *def = gtk_rc_get_style( menuBar );
if(!def)
def = gtk_widget_get_default_style();
if(def) {
GdkColor col = def->bg[GTK_STATE_NORMAL];
textColour = wxColour(col);
}
#endif
gtk_widget_destroy( menuBar );
intitialized = true;
}
return textColour;
#else
return wxSystemSettings::GetColour(wxSYS_COLOUR_MENUBAR);
#endif
}
GtkMenuBar* menu_new(gpointer userData)
{
GtkWidget* pMenuBar = NULL;
GtkWidget* pMenuFile = NULL;
GtkWidget* pMenuItemFile = NULL;
pMenuBar = gtk_menu_bar_new();
pMenuFile = gtk_menu_new();
pMenuItemFile = gtk_menu_item_new_with_mnemonic("_File");
menu_item_new(GTK_MENU(pMenuFile), "_New", G_CALLBACK(map_editor_new_file), userData);
menu_item_new(GTK_MENU(pMenuFile), "_Open", G_CALLBACK(map_editor_open_file), userData);
menu_item_new(GTK_MENU(pMenuFile), "_Save", G_CALLBACK(map_editor_save), userData);
menu_item_new(GTK_MENU(pMenuFile), "Save _As", G_CALLBACK(map_editor_save_as), userData);
menu_item_new(GTK_MENU(pMenuFile), "_Close", G_CALLBACK(map_editor_close), userData);
menu_item_new(GTK_MENU(pMenuFile), "_Quit", G_CALLBACK(map_editor_quit), userData);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItemFile), pMenuFile);
gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItemFile);
pMenuFile = gtk_menu_new();
pMenuItemFile = gtk_menu_item_new_with_mnemonic("_?");
menu_item_new(GTK_MENU(pMenuFile), "_Help", G_CALLBACK(NULL), userData);
menu_item_new(GTK_MENU(pMenuFile), "_About", G_CALLBACK(NULL), userData);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItemFile), pMenuFile);
gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItemFile);
return GTK_MENU_BAR(pMenuBar);
}
GtkWidget* construct_menu( void )
{
GtkWidget* bar;
GtkWidget* fileItem, *editItem, *viewItem, *aboutItem;
GtkWidget* fileMenu, *openItem, *saveItem, *exportOBJItem, *quitItem;
GtkWidget* exportSubMenu;
bar = gtk_menu_bar_new();
fileItem = gtk_menu_item_new_with_label( "Plik" );
fileMenu = gtk_menu_new();
openItem = gtk_menu_item_new_with_label( "Otwórz" );
gtk_menu_shell_append( GTK_MENU_SHELL( fileMenu ), openItem );
saveItem = gtk_menu_item_new_with_label( "Zapisz" );
gtk_menu_shell_append( GTK_MENU_SHELL( fileMenu ), saveItem );
exportOBJItem = gtk_menu_item_new_with_label( "Eksportuj" );
gtk_menu_shell_append( GTK_MENU_SHELL( fileMenu ), exportOBJItem );
quitItem = gtk_menu_item_new_with_label( "Zakończ" );
gtk_menu_shell_append( GTK_MENU_SHELL( fileMenu ), quitItem );
editItem = gtk_menu_item_new_with_label( "Edycja" );
viewItem = gtk_menu_item_new_with_label( "Widok" );
aboutItem = gtk_menu_item_new_with_label( "O programie" );
gtk_menu_bar_append( bar, fileItem );
gtk_menu_bar_append( bar, editItem );
gtk_menu_bar_append( bar, viewItem );
gtk_menu_bar_append( bar, aboutItem );
gtk_menu_item_set_submenu( GTK_MENU_ITEM( fileItem ), fileMenu );
g_signal_connect( G_OBJECT( quitItem ), "activate", (GtkSignalFunc) gtk_main_quit, NULL );
return bar;
}
/***********************************************************************
* Create *
***********************************************************************/
GtkWidget *widget_menubar_create(
AttributeSet *Attr, tag_attr *attr, gint Type)
{
gint n;
GtkWidget *root_menu;
GtkWidget *widget;
stackelement s;
#ifdef DEBUG_TRANSITS
fprintf(stderr, "%s(): Entering.\n", __func__);
#endif
widget = gtk_menu_bar_new();
s = pop();
for (n = 0; n < s.nwidgets; ++n) {
root_menu = s.widgets[n];
gtk_menu_shell_append(GTK_MENU_SHELL(widget), root_menu);
}
#ifdef DEBUG_TRANSITS
fprintf(stderr, "%s(): Exiting.\n", __func__);
#endif
return widget;
}
int main (int argc, char *argv[])
{
GtkWidget *win = NULL;
g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING, (GLogFunc) gtk_false, NULL);
gtk_init (&argc, &argv);
g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING, g_log_default_handler, NULL);
global_menu_bar = gtk_menu_bar_new();
form_element_t *form = read_83_form("./Form.xml");
if (!form) {
fprintf(stderr, "failed to open Form.xml!\n");
return 1;
}
win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width (GTK_CONTAINER (win), 8);
gtk_window_set_title (GTK_WINDOW (win), "1C 8.3 Managed Form in GTK+");
gtk_window_set_position (GTK_WINDOW (win), GTK_WIN_POS_CENTER);
gtk_widget_realize (win);
g_signal_connect (win, "destroy", gtk_main_quit, NULL);
GtkWidget *w = gtk_vbox_new(false, 0);
gtk_box_pack_start(GTK_BOX(w), global_menu_bar, false, false, 0);
gtk_box_pack_start(GTK_BOX(w), form->widget, true, true, 0);
gtk_container_add (GTK_CONTAINER (win), w);
gtk_widget_show_all (win);
gtk_main ();
return 0;
}
GtkWidget *menubar_create(GtkWidget * window)
{
GtkWidget *menubar;
GtkWidget *submenu;
GtkWidget *submenu_item;
GtkAccelGroup *accel_group;
(void)window;
menubar = gtk_menu_bar_new();
accel_group = gtk_accel_group_new();
gtk_window_add_accel_group(GTK_WINDOW(window), accel_group);
submenu = gtk_menu_new();
submenu_item = gtk_menu_item_new_with_mnemonic(_("_File"));
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), submenu_item);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(submenu_item), submenu);
create_file_menu_items(GTK_MENU_SHELL(submenu), accel_group);
submenu = gtk_menu_new();
submenu_item = gtk_menu_item_new_with_mnemonic(_("_Edit"));
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), submenu_item);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(submenu_item), submenu);
create_edit_menu_items(GTK_MENU_SHELL(submenu));
submenu = gtk_menu_new();
submenu_item = gtk_menu_item_new_with_mnemonic(_("_Help"));
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), submenu_item);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(submenu_item), submenu);
create_help_menu_items(GTK_MENU_SHELL(submenu), accel_group);
return menubar;
}
int gnoclMenuBarCmd( ClientData data, Tcl_Interp *interp,
int objc, Tcl_Obj * const objv[] )
{
int ret;
GtkMenuBar *menuBar;
if( gnoclParseOptions( interp, objc, objv, menuBarOptions )
!= TCL_OK )
{
gnoclClearOptions( menuBarOptions );
return TCL_ERROR;
}
menuBar = GTK_MENU_BAR( gtk_menu_bar_new( ) );
gtk_widget_show( GTK_WIDGET( menuBar ) );
ret = gnoclSetOptions( interp, menuBarOptions, G_OBJECT( menuBar ), -1 );
if( ret == TCL_OK )
ret = configure( interp, menuBar, menuBarOptions );
gnoclClearOptions( menuBarOptions );
if( ret != TCL_OK )
{
gtk_widget_destroy( GTK_WIDGET( menuBar ) );
return TCL_ERROR;
}
return gnoclRegisterWidget( interp, GTK_WIDGET( menuBar ), menuBarFunc );
}
// 构造GUI函数。
// 输入：void
// 返回值：void
void construct_GUI()
{
background = gdk_pixbuf_new_from_file("res/background.jpg",NULL);
A_pic = gdk_pixbuf_new_from_file("res/A.png",NULL);
B_pic = gdk_pixbuf_new_from_file("res/B.png",NULL);
main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request(main_window,627,570);
gtk_window_set_resizable(GTK_WINDOW(main_window),FALSE);
gtk_window_set_title(GTK_WINDOW(main_window),("Tic Tac toe"));
g_signal_connect(G_OBJECT(main_window),"destroy",G_CALLBACK(gtk_main_quit),NULL);
GtkWidget * layout = gtk_layout_new(NULL,NULL);
gtk_container_add(GTK_CONTAINER(main_window),layout);
GtkWidget * menubar = gtk_menu_bar_new();
GtkWidget * menu1 = gtk_menu_new();
GtkWidget * option = gtk_menu_item_new_with_mnemonic("option");
GtkWidget * player = gtk_image_menu_item_new_with_label("player first");
GtkWidget * computer = gtk_image_menu_item_new_with_label("computer first");
GtkWidget * sep = gtk_separator_menu_item_new();
g_signal_connect(G_OBJECT(player),"activate",G_CALLBACK(player_first),NULL);
g_signal_connect(G_OBJECT(computer),"activate",G_CALLBACK(computer_first),NULL);
GtkWidget * quit = gtk_image_menu_item_new_with_label("quit");
g_signal_connect(G_OBJECT(quit),"activate",G_CALLBACK(gtk_main_quit),NULL);
GtkWidget * menu2 = gtk_menu_new();
GtkWidget * help = gtk_menu_item_new_with_mnemonic("help");
GtkWidget * about = gtk_image_menu_item_new_with_label("about..");
g_signal_connect(G_OBJECT(about),"activate",G_CALLBACK(about_pressed),NULL);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(option),menu1);
gtk_menu_shell_append(GTK_MENU_SHELL(menu1),player);
gtk_menu_shell_append(GTK_MENU_SHELL(menu1),computer);
gtk_menu_shell_append(GTK_MENU_SHELL(menu1),sep);
gtk_menu_shell_append(GTK_MENU_SHELL(menu1),quit);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(help),menu2);
gtk_menu_shell_append(GTK_MENU_SHELL(menu2),about);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar),option);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar),help);
gtk_layout_put(GTK_LAYOUT(layout),menubar,0,0);
gtk_widget_set_size_request(menubar,627,20);
draw_window = gtk_drawing_area_new();
gtk_layout_put(GTK_LAYOUT(layout),draw_window,0,20);
gtk_widget_set_size_request(draw_window,627,570);
g_signal_connect(draw_window,"expose-event",G_CALLBACK(window_drawing),NULL);
gtk_widget_set_events(draw_window,gtk_widget_get_events(draw_window)|GDK_BUTTON_PRESS_MASK);
g_signal_connect(G_OBJECT(draw_window),"button-press-event",G_CALLBACK(when_key_pressed),NULL);
gtk_widget_show_all(main_window);
}
int main(int argc, char** argv) {
GtkWidget* w;
GtkWidget* box;
GtkWidget* p;
GtkWidget* f;
GtkWidget* menu;
GtkWidget* item;
GtkWidget* sub;
gtk_init(&argc, &argv);
// creates the window
w = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(w), "ev.view");
gtk_window_resize(GTK_WINDOW(w), 640, 480);
box = gtk_vbox_new(FALSE, 0);
// set menues
menu = gtk_menu_bar_new();
gtk_box_pack_start(GTK_BOX(box), menu, FALSE, TRUE, 0);
// File
item = gtk_menu_item_new_with_label("File");
sub = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), sub);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
newMenuItem(sub, "Open data...", G_CALLBACK(menuOpenData), w);
itemRecons = newMenuItem(sub, "Open reconstruction...", G_CALLBACK(menuOpenRec), w);
gtk_widget_set_sensitive(GTK_WIDGET(itemRecons), FALSE);
newMenuItem(sub, "Quit", G_CALLBACK(menuQuit), NULL);
// Map
item = gtk_menu_item_new_with_label("Map");
sub = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), sub);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
newMenuItem(sub, "Open raster...", G_CALLBACK(menuOpenRaster), NULL);
// Layout
p = gtk_hpaned_new();
gtk_widget_set_size_request(p, 100, -1);
f = gtk_frame_new(NULL);
gtk_paned_pack1(GTK_PANED(p), f, TRUE, FALSE);
gtk_widget_set_size_request(f, 50, -1);
initTree(f);
f = gtk_frame_new(NULL);
gtk_paned_pack2(GTK_PANED(p), f, TRUE, FALSE);
gtk_widget_set_size_request(f, 50, -1);
initMap(f);
gtk_box_pack_start(GTK_BOX(box), p, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(w), box);
gtk_widget_show_all(w);
gtk_widget_add_events(w, GDK_KEY_PRESS_MASK);
g_signal_connect(G_OBJECT(w), "key_press_event", G_CALLBACK(keyPress), w);
gtk_main();
return 0;
}
GtkWidget *menu_create()
{
GtkWidget *menu, *menu_item, *file_menu, *edit_menu, *help_menu = NULL;
menu = gtk_menu_bar_new();
/* BEGIN FILE MENU */
file_menu = gtk_menu_new();
menu_item = gtk_menu_item_new_with_mnemonic("_New");
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu),menu_item);
menu_item = gtk_menu_item_new_with_mnemonic("_Open");
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu),menu_item);
menu_item = gtk_menu_item_new_with_mnemonic("_Save");
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu),menu_item);
menu_item = gtk_menu_item_new_with_mnemonic("Save _As");
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu),menu_item);
menu_item = gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu),menu_item);
menu_item = gtk_menu_item_new_with_mnemonic("E_xit");
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu),menu_item);
/* END FILE MENU */
/* BEGIN EDIT MENU */
edit_menu = gtk_menu_new();
menu_item = gtk_menu_item_new_with_mnemonic("_Cup");
gtk_menu_shell_append(GTK_MENU_SHELL(edit_menu),menu_item);
menu_item = gtk_menu_item_new_with_mnemonic("C_opy");
gtk_menu_shell_append(GTK_MENU_SHELL(edit_menu),menu_item);
menu_item = gtk_menu_item_new_with_mnemonic("_Paste");
gtk_menu_shell_append(GTK_MENU_SHELL(edit_menu),menu_item);
/* END EDIT MENU */
/* BEGIN HELP MENU */
help_menu = gtk_menu_new();
menu_item = gtk_menu_item_new_with_mnemonic("_Help");
gtk_menu_shell_append(GTK_MENU_SHELL(help_menu),menu_item);
menu_item = gtk_menu_item_new_with_mnemonic("_About");
gtk_menu_shell_append(GTK_MENU_SHELL(help_menu),menu_item);
g_signal_connect(G_OBJECT(menu_item),"activate",G_CALLBACK(about_show),NULL);
/* END HELP MENU */
menu_item = gtk_menu_item_new_with_mnemonic("_File");
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menu_item);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item),file_menu);
menu_item = gtk_menu_item_new_with_mnemonic("_Edit");
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menu_item);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item),edit_menu);
menu_item = gtk_menu_item_new_with_mnemonic("_Help");
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menu_item);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item),help_menu);
return menu;
}
/**
* create_gens_window_menubar(): Create the menu bar.
*/
void gens_window_create_menubar(void)
{
if (gens_menu_bar != NULL)
{
// Menu bar already exists. Delete it.
gtk_widget_destroy(gens_menu_bar);
gens_menu_clear();
}
if (!vdraw_get_fullscreen() && Settings.showMenuBar)
{
// Create a menu bar.
gens_menu_bar = gtk_menu_bar_new();
gtk_widget_show(gens_menu_bar);
gtk_box_pack_start(GTK_BOX(gens_vbox_main), gens_menu_bar, FALSE, FALSE, 0);
}
else
{
// Create a popup menu.
gens_menu_bar = gtk_menu_new();
}
// Connect the menu "deactivate" signal.
// For whatever reason, GtkMenuShell has a "deactivate" signal,
// but not an "activate" signal.
g_signal_connect((gpointer)gens_menu_bar, "deactivate",
G_CALLBACK(gens_menu_deactivate), NULL);
// Accelerator Group.
static GtkAccelGroup *gens_menu_accel_group = NULL;
if (gens_menu_accel_group != NULL)
{
// Delete the accelerator group.
gtk_window_remove_accel_group(GTK_WINDOW(gens_window), gens_menu_accel_group);
g_object_unref(gens_menu_accel_group);
}
// Create an accelerator group.
gens_menu_accel_group = gtk_accel_group_new();
// Parse the menus.
gens_menu_parse(&gmiMain[0], GTK_MENU_SHELL(gens_menu_bar), gens_menu_accel_group);
// Add the accel group.
gtk_window_add_accel_group(GTK_WINDOW(gens_window), gens_menu_accel_group);
// Synchronize the menus.
Sync_Gens_Window();
#ifdef GDK_WINDOWING_QUARTZ
// Set the menu bar as the MacOS X menu bar.
if (!vdraw_get_fullscreen() && Settings.showMenuBar)
ige_mac_menu_set_menu_bar(GTK_MENU_SHELL(gens_menu_bar));
#endif
}
void create_menu(GtkWidget *win,GtkWidget *vbox,GtkWidget *reader)
{
GtkWidget *bar;
GtkWidget *menu;
GtkWidget *item;
GtkAccelGroup *accel_group;
accel_group=gtk_accel_group_new();
gtk_window_add_accel_group(GTK_WINDOW(win),accel_group);
bar=gtk_menu_bar_new();
gtk_box_pack_start(GTK_BOX(vbox),bar,FALSE,FALSE,0);
menu=gtk_menu_new();
/*创建文件菜单*/
item=gtk_menu_item_new_with_mnemonic("文件(_F)");
gtk_menu_shell_append(GTK_MENU_SHELL(bar),item);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),menu);
/*从文件中加载内容*/
item=gtk_image_menu_item_new_from_stock(GTK_STOCK_OPEN,accel_group);
gtk_menu_shell_append(GTK_MENU_SHELL(menu),item);
g_signal_connect(G_OBJECT(item),"activate",
G_CALLBACK(duoyi_read_from_file),reader);
/*退出程序*/
item=gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT,accel_group);
gtk_menu_shell_append(GTK_MENU_SHELL(menu),item);
g_signal_connect(G_OBJECT(item),"activate",
G_CALLBACK(duoyi_quit),NULL);
/*创建编辑菜单，添加首选项*/
menu=gtk_menu_new();
item=gtk_menu_item_new_with_mnemonic("编辑(_E)");
gtk_menu_shell_append(GTK_MENU_SHELL(bar),item);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),menu);
item=gtk_image_menu_item_new_from_stock(GTK_STOCK_PREFERENCES,accel_group);
gtk_menu_shell_append(GTK_MENU_SHELL(menu),item);
g_signal_connect(G_OBJECT(item),"activate",
G_CALLBACK(duoyi_preferences),NULL);
/*创建帮助菜单*/
menu=gtk_menu_new();
item=gtk_menu_item_new_with_mnemonic("帮助(_H)");
gtk_menu_shell_append(GTK_MENU_SHELL(bar),item);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),menu);
item=gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT,accel_group);
gtk_menu_shell_append(GTK_MENU_SHELL(menu),item);
g_signal_connect(G_OBJECT(item),"activate",
G_CALLBACK(duoyi_about_dialog),NULL);
item=gtk_image_menu_item_new_from_stock(GTK_STOCK_HELP,accel_group);
gtk_menu_shell_append(GTK_MENU_SHELL(menu),item);
g_signal_connect(G_OBJECT(item),"activate",
G_CALLBACK(duoyi_help_dialog),NULL);
}
/**
* 创建菜单条.
* @return 菜单条
*/
GtkWidget *DialogPeer::CreateMenuBar()
{
GtkWidget *menubar;
menubar = gtk_menu_bar_new();
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), CreateFileMenu());
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), CreateToolMenu());
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), CreateHelpMenu());
return menubar;
}
int main (int argc, char *argv[]) {
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *menubar;
GtkWidget *viewmenu;
GtkWidget *view;
GtkWidget *tog_stat;
GtkWidget *statusbar;
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), "view statusbar");
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), vbox);
menubar = gtk_menu_bar_new();
viewmenu = gtk_menu_new();
view = gtk_menu_item_new_with_label("View");
// check menu item
tog_stat = gtk_check_menu_item_new_with_label ("View Statusbar");
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(tog_stat), TRUE);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(view), viewmenu);
gtk_menu_shell_append(GTK_MENU_SHELL(viewmenu), tog_stat);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), view);
gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 3);
statusbar = gtk_statusbar_new();
gtk_box_pack_end(GTK_BOX(vbox), statusbar, FALSE, TRUE, 1);
g_signal_connect_swapped(G_OBJECT(window), "destroy",
G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(G_OBJECT(tog_stat), "activate",
G_CALLBACK(toggle_statusbar), statusbar);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
static GtkWidget* MenuBarWidget()
{
static GtkWidget* s_widget;
if (s_widget == NULL)
{
s_widget = gtk_menu_bar_new();
gtk_container_add(ContainerWidget(), s_widget);
gtk_widget_ensure_style(s_widget);
}
return s_widget;
}
int main(int argc,char *argv[])
{
GtkWidget *wnd;
GtkWidget *menu;
GtkWidget *menu_bar;
GtkWidget *menu_item;
GtkWidget *top_item;
GtkWidget *vbox;
gtk_init (&argc, &argv);
wnd= gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(wnd),"P20.1 how to use menu");
gtk_widget_set_size_request(wnd,350,150);
gtk_container_set_border_width(GTK_CONTAINER(wnd),5);
vbox=gtk_vbox_new(FALSE,0);
gtk_container_add(GTK_CONTAINER(wnd),vbox);
gtk_widget_show(vbox);
menu_bar=gtk_menu_bar_new();
gtk_box_pack_start(GTK_BOX(vbox),menu_bar,FALSE,FALSE,2);
gtk_widget_show(menu_bar);
menu=gtk_menu_new();
menu_item=gtk_menu_item_new_with_label("Open");
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menu_item);
g_signal_connect(G_OBJECT(menu_item),"activate",
GTK_SIGNAL_FUNC(cb_active_open),NULL);
gtk_widget_show(menu_item);
menu_item=gtk_menu_item_new_with_label("Save");
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menu_item);
g_signal_connect(G_OBJECT(menu_item),"activate",
GTK_SIGNAL_FUNC(cb_active_save),NULL);
gtk_widget_show(menu_item);
menu_item=gtk_menu_item_new_with_label("Close");
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menu_item);
g_signal_connect(G_OBJECT(menu_item),"activate",
GTK_SIGNAL_FUNC(cb_active_close),NULL);
gtk_widget_show(menu_item);
top_item=gtk_menu_item_new_with_label("File");
gtk_widget_show(top_item);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(top_item),menu);
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar),top_item);
g_signal_connect(G_OBJECT(wnd),"delete_event",
G_CALLBACK(release_resource),NULL);
gtk_widget_show(wnd);
gtk_main();
return 0;
}
GtkWidget* CreateMenuBar() {
GtkWidget* menu_bar = gtk_menu_bar_new();
GtkWidget* debug_menu = CreateMenu(menu_bar, "Tests");
AddMenuEntry(debug_menu, "Get Source",
G_CALLBACK(GetSourceActivated));
AddMenuEntry(debug_menu, "Get Text",
G_CALLBACK(GetTextActivated));
AddMenuEntry(debug_menu, "JS Binding",
G_CALLBACK(JSBindngActivated));
AddMenuEntry(debug_menu, "JS Extension",
G_CALLBACK(JSExtensionActivated));
AddMenuEntry(debug_menu, "JS Execute",
G_CALLBACK(JSExecuteActivated));
AddMenuEntry(debug_menu, "Performance Tests",
G_CALLBACK(PerformanceActivated));
AddMenuEntry(debug_menu, "Dialogs",
G_CALLBACK(DialogsActivated));
AddMenuEntry(debug_menu, "Request",
G_CALLBACK(RequestActivated));
AddMenuEntry(debug_menu, "Local Storage",
G_CALLBACK(LocalStorageActivated));
AddMenuEntry(debug_menu, "XMLHttpRequest",
G_CALLBACK(XMLHttpRequestActivated));
AddMenuEntry(debug_menu, "DOM Access",
G_CALLBACK(DOMAccessActivated));
AddMenuEntry(debug_menu, "Scheme Handler",
G_CALLBACK(SchemeHandlerActivated));
AddMenuEntry(debug_menu, "Popup Window",
G_CALLBACK(PopupWindowActivated));
AddMenuEntry(debug_menu, "Accelerated 2D Canvas",
G_CALLBACK(Accelerated2DCanvasActivated));
AddMenuEntry(debug_menu, "Accelerated Layers",
G_CALLBACK(AcceleratedLayersActivated));
AddMenuEntry(debug_menu, "WebGL",
G_CALLBACK(WebGLActivated));
AddMenuEntry(debug_menu, "Zoom In",
G_CALLBACK(ZoomInActivated));
AddMenuEntry(debug_menu, "Zoom Out",
G_CALLBACK(ZoomOutActivated));
AddMenuEntry(debug_menu, "Zoom Reset",
G_CALLBACK(ZoomResetActivated));
AddMenuEntry(debug_menu, "Drag & Drop",
G_CALLBACK(DragDropActivated));
AddMenuEntry(debug_menu, "Geolocation",
G_CALLBACK(GeolocationActivated));
AddMenuEntry(debug_menu, "Show DevTools",
G_CALLBACK(ShowDevtoolsActivated));
AddMenuEntry(debug_menu, "Plugin Info",
G_CALLBACK(PluginInfoActivated));
return menu_bar;
}
int main (int argc, char *argv[]) {
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *menubar;
GtkWidget *filemenu;
GtkWidget *file;
GtkWidget *quit;
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");
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), vbox);
// NB menubar and menus derived from same widget (menu shell). Menu
// items are only valid children for menus (used to implment submenus)
// create a menubar and a menu
menubar = gtk_menu_bar_new();
filemenu = gtk_menu_new();
file = gtk_menu_item_new_with_label("File");
quit = gtk_menu_item_new_with_label("Quit");
// implement a file menu (submenu of menubar)
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), filemenu);
// implement menu items
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);
g_signal_connect_swapped(G_OBJECT(window), "destroy",
G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(G_OBJECT(quit), "activate",
G_CALLBACK(gtk_main_quit), NULL);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
GtkWidget *
gtk_model_menu_create_menu_bar (GMenuModel *model,
GActionObservable *actions,
GtkAccelGroup *accels)
{
GtkWidget *menubar;
menubar = gtk_menu_bar_new ();
gtk_model_menu_bind (GTK_MENU_SHELL (menubar), model, actions, accels, FALSE);
return menubar;
}
static int gtkMenuMapMethod(Ihandle* ih)
{
if (iupMenuIsMenuBar(ih))
{
/* top level menu used for MENU attribute in IupDialog (a menu bar) */
#ifdef HILDON
Ihandle *pih;
ih->handle = gtk_menu_new();
if (!ih->handle)
return IUP_ERROR;
pih = iupChildTreeGetNativeParent(ih);
hildon_window_set_menu(HILDON_WINDOW(pih->handle), GTK_MENU(ih->handle));
#else
ih->handle = gtk_menu_bar_new();
if (!ih->handle)
return IUP_ERROR;
iupgtkBaseAddToParent(ih);
#endif
}
else
{
ih->handle = gtk_menu_new();
if (!ih->handle)
return IUP_ERROR;
if (ih->parent)
{
/* parent is a submenu */
gtk_menu_item_set_submenu((GtkMenuItem*)ih->parent->handle, ih->handle);
g_signal_connect(G_OBJECT(ih->handle), "map", G_CALLBACK(gtkMenuMap), ih);
g_signal_connect(G_OBJECT(ih->handle), "unmap", G_CALLBACK(gtkMenuUnMap), ih);
}
else
{
/* top level menu used for IupPopup */
iupAttribSetStr(ih, "_IUPGTK_POPUP_MENU", "1");
g_signal_connect(G_OBJECT(ih->handle), "map", G_CALLBACK(gtkMenuMap), ih);
g_signal_connect(G_OBJECT(ih->handle), "unmap", G_CALLBACK(gtkPopupMenuUnMap), ih);
}
}
gtk_widget_add_events(ih->handle, GDK_KEY_PRESS_MASK);
g_signal_connect(G_OBJECT(ih->handle), "key-press-event", G_CALLBACK(gtkMenuKeyPressEvent), ih);
ih->serial = iupMenuGetChildId(ih);
gtk_widget_show(ih->handle);
return IUP_NOERROR;
}
