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; }
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); }
void CreateMainWindow(GtkWidget **m_oWindow, GtkWidget **m_oMenuBar, GtkWidget **m_oFileItem, GtkWidget **m_oDSPItem) { // Main Window gtk_window_set_title(GTK_WINDOW(m_oWindow), "Benchmark Suite"); gtk_window_set_default_size(GTK_WINDOW(m_oWindow), 290, 200); gtk_window_set_position(GTK_WINDOW(m_oWindow), GTK_WIN_POS_CENTER); gtk_container_set_border_width(GTK_CONTAINER(m_oWindow), 5); gtk_menu_bar_append(GTK_MENU_BAR(m_oMenuBar), m_oFileItem); gtk_menu_bar_append(GTK_MENU_BAR(m_oMenuBar), m_oDSPItem); }
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 ); }
static void gtk_image_menu_item_get_preferred_height (GtkWidget *widget, gint *minimum, gint *natural) { GtkImageMenuItem *image_menu_item = GTK_IMAGE_MENU_ITEM (widget); GtkImageMenuItemPrivate *priv = image_menu_item->priv; gint child_height = 0; GtkPackDirection pack_dir; GtkWidget *parent; parent = gtk_widget_get_parent (widget); if (GTK_IS_MENU_BAR (parent)) pack_dir = gtk_menu_bar_get_child_pack_direction (GTK_MENU_BAR (parent)); else pack_dir = GTK_PACK_DIRECTION_LTR; if (priv->image && gtk_widget_get_visible (priv->image)) { GtkRequisition child_requisition; gtk_widget_get_preferred_size (priv->image, &child_requisition, NULL); child_height = child_requisition.height; } GTK_WIDGET_CLASS (gtk_image_menu_item_parent_class)->get_preferred_height (widget, minimum, natural); if (pack_dir == GTK_PACK_DIRECTION_RTL || pack_dir == GTK_PACK_DIRECTION_LTR) { *minimum = MAX (*minimum, child_height); *natural = MAX (*natural, child_height); } }
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); }
/** * Generate menubar menus. * * Generate the main menu structure and attach it to a menubar widget. */ struct nsgtk_bar_submenu *nsgtk_menu_bar_create(GtkMenuShell *menubar, GtkAccelGroup *group) { ; struct nsgtk_bar_submenu *nmenu; nmenu = malloc(sizeof(struct nsgtk_bar_submenu)); if (nmenu == NULL) { warn_user(messages_get("NoMemory"), 0); return NULL; } nmenu->bar_menu = GTK_MENU_BAR(menubar); nmenu->file_submenu = nsgtk_menu_file_submenu(group); ATTACH_PARENT(menubar, gtkFile, nmenu->file_submenu->file, group); nmenu->edit_submenu = nsgtk_menu_edit_submenu(group); ATTACH_PARENT(menubar, gtkEdit, nmenu->edit_submenu->edit, group); nmenu->view_submenu = nsgtk_menu_view_submenu(group); ATTACH_PARENT(menubar, gtkView, nmenu->view_submenu->view, group); nmenu->nav_submenu = nsgtk_menu_nav_submenu(group); ATTACH_PARENT(menubar, gtkNavigate, nmenu->nav_submenu->nav, group); nmenu->help_submenu = nsgtk_menu_help_submenu(group); ATTACH_PARENT(menubar, gtkHelp, nmenu->help_submenu->help, group); return nmenu; }
static void gtk_image_menu_item_get_preferred_width (GtkWidget *widget, gint *minimum, gint *natural) { GtkImageMenuItem *image_menu_item = GTK_IMAGE_MENU_ITEM (widget); GtkImageMenuItemPrivate *priv = image_menu_item->priv; GtkPackDirection pack_dir; GtkWidget *parent; parent = gtk_widget_get_parent (widget); if (GTK_IS_MENU_BAR (parent)) pack_dir = gtk_menu_bar_get_child_pack_direction (GTK_MENU_BAR (parent)); else pack_dir = GTK_PACK_DIRECTION_LTR; GTK_WIDGET_CLASS (gtk_image_menu_item_parent_class)->get_preferred_width (widget, minimum, natural); if ((pack_dir == GTK_PACK_DIRECTION_TTB || pack_dir == GTK_PACK_DIRECTION_BTT) && priv->image && gtk_widget_get_visible (priv->image)) { gint child_minimum, child_natural; gtk_widget_get_preferred_width (priv->image, &child_minimum, &child_natural); *minimum = MAX (*minimum, child_minimum); *natural = MAX (*natural, child_natural); } }
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 ); }
/** * Create toolbox component for distributed user interface */ void create_toolbox () { GtkWidget *window; GtkWidget *main_vbox; GtkWidget *wrapbox; GtkWidget *menubar; GtkAccelGroup *accel_group; #ifdef HAVE_GNOME window = gnome_app_new ("Dia", _("Diagram Editor")); #else window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_object_ref(window); gtk_window_set_title (GTK_WINDOW (window), "Dia v" VERSION); #endif gtk_window_set_role (GTK_WINDOW (window), "toolbox_window"); gtk_window_set_default_size(GTK_WINDOW(window), 146, 349); app_set_icon (GTK_WINDOW (window)); g_signal_connect (G_OBJECT (window), "delete_event", G_CALLBACK (toolbox_delete), window); g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (toolbox_destroy), window); main_vbox = gtk_vbox_new (FALSE, 1); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 1); #ifdef HAVE_GNOME gnome_app_set_contents(GNOME_APP(window), main_vbox); #else gtk_container_add (GTK_CONTAINER (window), main_vbox); #endif wrapbox = toolbox_create(); gtk_box_pack_end (GTK_BOX (main_vbox), wrapbox, TRUE, TRUE, 0); g_signal_connect (G_OBJECT (wrapbox), "drag_data_received", G_CALLBACK (dia_dnd_file_drag_data_received), NULL); /* userdata == NULL here intentionally */ gtk_widget_show (main_vbox); /* menus -- initialised afterwards, because initing the display menus * uses the tool buttons*/ menus_get_toolbox_menubar(&menubar, &accel_group); gtk_window_add_accel_group (GTK_WINDOW (window), accel_group); #ifdef HAVE_GNOME gnome_app_set_menus(GNOME_APP(window), GTK_MENU_BAR(menubar)); #else # ifdef HAVE_MAC_INTEGRATION _create_mac_integration (); # else gtk_box_pack_start (GTK_BOX (main_vbox), menubar, FALSE, TRUE, 0); gtk_widget_show (menubar); # endif #endif persistence_register_window(GTK_WINDOW(window)); toolbox_shell = window; }
static void matenu_menu_bar_real_forall_internal (GtkContainer* base, gboolean include_internals, GtkCallback callback, void* callback_target) { MatenuMenuBar * self; self = (MatenuMenuBar*) base; if (include_internals) { callback ((GtkWidget*) self->priv->_overflown_arrow, callback_target); } GTK_CONTAINER_CLASS (matenu_menu_bar_parent_class)->forall ((GtkContainer*) GTK_MENU_BAR (self), include_internals, callback, callback_target); }
static void panel_menu_bar_object_update_orientation (PanelMenuBarObject *menubar) { GtkPackDirection pack_direction; double text_angle; float text_xalign; float text_yalign; GList *children, *l; pack_direction = GTK_PACK_DIRECTION_LTR; text_angle = 0.0; text_xalign = 0.0; text_yalign = 0.5; switch (menubar->priv->orientation) { case PANEL_ORIENTATION_TOP: case PANEL_ORIENTATION_BOTTOM: break; case PANEL_ORIENTATION_LEFT: pack_direction = GTK_PACK_DIRECTION_BTT; text_angle = 90.0; text_xalign = 0.5; text_yalign = 0.0; break; case PANEL_ORIENTATION_RIGHT: pack_direction = GTK_PACK_DIRECTION_TTB; text_angle = 270.0; text_xalign = 0.5; text_yalign = 0.0; break; default: g_assert_not_reached (); break; } gtk_menu_bar_set_pack_direction (GTK_MENU_BAR (menubar), pack_direction); gtk_menu_bar_set_child_pack_direction (GTK_MENU_BAR (menubar), pack_direction); children = gtk_container_get_children (GTK_CONTAINER (menubar)); for (l = children; l != NULL; l = l->next) set_item_text_angle_and_alignment (GTK_WIDGET (l->data), text_angle, text_xalign, text_yalign); g_list_free (children); }
static void matenu_menu_bar_real_dispose (GObject* base) { MatenuMenuBar * self; self = (MatenuMenuBar*) base; if (!self->priv->disposed) { self->priv->disposed = TRUE; gtk_menu_shell_remove_all (self); } G_OBJECT_CLASS (matenu_menu_bar_parent_class)->dispose ((GObject*) GTK_MENU_BAR (self)); }
static void matenu_menu_bar_real_insert (GtkMenuShell* base, GtkWidget* child, gint position) { MatenuMenuBar * self; self = (MatenuMenuBar*) base; g_return_if_fail (child != NULL); GTK_MENU_SHELL_CLASS (matenu_menu_bar_parent_class)->insert ((GtkMenuShell*) GTK_MENU_BAR (self), child, position); if (MATENU_IS_MENU_ITEM (child)) { GtkWidget* _tmp0_; matenu_menu_item_set_gravity ((_tmp0_ = child, MATENU_IS_MENU_ITEM (_tmp0_) ? ((MatenuMenuItem*) _tmp0_) : NULL), matenu_menu_bar_get_gravity (self)); } }
static int menuBarFunc( ClientData data, Tcl_Interp *interp, int objc, Tcl_Obj * const objv[] ) { static const char *cmds[] = { "delete", "configure", "add", "addBegin", "addEnd", NULL }; enum cmdIdx { DeleteIdx, ConfigureIdx, AddIdx, BeginIdx, EndIdx }; GtkMenuBar *menuBar = GTK_MENU_BAR( data ); int idx; if( objc < 2 ) { Tcl_WrongNumArgs( interp, 1, objv, "command" ); return TCL_ERROR; } if( Tcl_GetIndexFromObj( interp, objv[1], cmds, "command", TCL_EXACT, &idx ) != TCL_OK ) return TCL_ERROR; switch( idx ) { case DeleteIdx: return gnoclDelete( interp, GTK_WIDGET( menuBar ), objc, objv ); case ConfigureIdx: { int ret = TCL_ERROR; if( gnoclParseAndSetOptions( interp, objc - 1, objv + 1, menuBarOptions, G_OBJECT( menuBar ) ) == TCL_OK ) { ret = configure( interp, menuBar, menuBarOptions ); } gnoclClearOptions( menuBarOptions ); return ret; } break; case AddIdx: case BeginIdx: case EndIdx: { if( objc != 3 ) { Tcl_WrongNumArgs( interp, 2, objv, "widget-list" ); return TCL_ERROR; } return gnoclMenuShellAddChildren( interp, GTK_MENU_SHELL( menuBar ), objv[2], idx != EndIdx ); } } return TCL_OK; }
static void panel_menu_bar_update_orientation(PanelMenuBar* menubar) { GtkPackDirection pack_direction; double text_angle; float text_xalign; float text_yalign; pack_direction = GTK_PACK_DIRECTION_LTR; text_angle = 0.0; text_xalign = 0.0; text_yalign = 0.5; switch (menubar->priv->orientation) { case PANEL_ORIENTATION_TOP: case PANEL_ORIENTATION_BOTTOM: break; case PANEL_ORIENTATION_LEFT: pack_direction = GTK_PACK_DIRECTION_BTT; text_angle = 90.0; text_xalign = 0.5; text_yalign = 0.0; break; case PANEL_ORIENTATION_RIGHT: pack_direction = GTK_PACK_DIRECTION_TTB; text_angle = 270.0; text_xalign = 0.5; text_yalign = 0.0; break; default: g_assert_not_reached(); break; } gtk_menu_bar_set_pack_direction(GTK_MENU_BAR(menubar), pack_direction); gtk_menu_bar_set_child_pack_direction(GTK_MENU_BAR(menubar), pack_direction); set_item_text_angle_and_alignment(menubar->priv->applications_item, text_angle, text_xalign, text_yalign); set_item_text_angle_and_alignment(menubar->priv->places_item, text_angle, text_xalign, text_yalign); set_item_text_angle_and_alignment(menubar->priv->desktop_item, text_angle, text_xalign, text_yalign); }
int clip_GTK_MENUBARSETSHADOWTYPE(ClipMachine * cm) { C_widget *cmnb = _fetch_cw_arg(cm); int shadow_type = _clip_parni(cm,2); CHECKCWID(cmnb,GTK_IS_MENU_BAR); CHECKOPT(2,NUMERIC_t); gtk_menu_bar_set_shadow_type(GTK_MENU_BAR(cmnb->widget), shadow_type); return 0; err: return 1; }
int clip_GTK_MENUBARPREPEND(ClipMachine * cm) { C_widget *cmnb = _fetch_cw_arg(cm); C_widget *cwid = _fetch_cwidget(cm,_clip_spar(cm,2)); CHECKCWID(cmnb,GTK_IS_MENU_BAR); CHECKARG2(2,MAP_t,NUMERIC_t); CHECKCWID(cwid,GTK_IS_WIDGET); gtk_menu_bar_prepend(GTK_MENU_BAR(cmnb->widget), cwid->widget); return 0; err: return 1; }
static GtkWidget * CreateMenuBar(void) { GtkWidget *menubar; GtkWidget *game_item, *game_menu; GtkWidget *info_item, *info_menu; GtkWidget *tearoff; menubar = gtk_menu_bar_new(); game_item = gtk_menu_item_new_with_label("Game"); game_menu = gtk_menu_new(); tearoff = gtk_tearoff_menu_item_new(); gtk_menu_append(GTK_MENU(game_menu), tearoff); new_menu_item(game_menu, DIALOG_NEWGAME); pausebutton = new_menu_item(game_menu, DIALOG_PAUSEGAME); new_menu_item(game_menu, DIALOG_WARPLEVEL); new_menu_item(game_menu, DIALOG_HIGHSCORE); new_menu_item(game_menu, DIALOG_QUITGAME); gtk_menu_bar_append(GTK_MENU_BAR(menubar), game_item); gtk_menu_item_set_submenu(GTK_MENU_ITEM(game_item), game_menu); info_item = gtk_menu_item_new_with_label("Info"); info_menu = gtk_menu_new(); tearoff = gtk_tearoff_menu_item_new(); gtk_menu_append(GTK_MENU(info_menu), tearoff); new_menu_item(info_menu, DIALOG_STORY); new_menu_item(info_menu, DIALOG_RULES); new_menu_item(info_menu, DIALOG_ABOUT); gtk_menu_bar_append(GTK_MENU_BAR(menubar), info_item); gtk_menu_item_set_submenu(GTK_MENU_ITEM(info_item), info_menu); return menubar; }
int clip_GTK_MENUBARINSERT(ClipMachine * cm) { C_widget *cmnb = _fetch_cw_arg(cm); C_widget *cwid = _fetch_cwidget(cm,_clip_spar(cm,2)); int position = _clip_parni(cm,3); CHECKCWID(cmnb,GTK_IS_MENU_BAR); CHECKARG2(2,MAP_t,NUMERIC_t); CHECKCWID(cwid,GTK_IS_WIDGET); CHECKOPT(3,NUMERIC_t); gtk_menu_bar_insert(GTK_MENU_BAR(cmnb->widget), cwid->widget, position); return 0; err: return 1; }
// Create a menu rtk_menu_t *rtk_menu_create(rtk_canvas_t *canvas, const char *label) { rtk_menu_t *menu; menu = malloc(sizeof(rtk_menu_t)); menu->canvas = canvas; menu->item = gtk_menu_item_new_with_label(label); menu->menu = gtk_menu_new(); gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu->item), menu->menu); gtk_menu_bar_append(GTK_MENU_BAR(canvas->menu_bar), menu->item); return menu; }
int clip_GTK_MENUBARPREPEND(ClipMachine * ClipMachineMemory) { C_widget *cmnb = _fetch_cw_arg(ClipMachineMemory); C_widget *cwid = _fetch_cwidget(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2)); CHECKCWID(cmnb, GTK_IS_MENU_BAR); CHECKARG2(2, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType); CHECKCWID(cwid, GTK_IS_WIDGET); gtk_menu_bar_prepend(GTK_MENU_BAR(cmnb->widget), cwid->widget); return 0; err: return 1; }
static void matenu_menu_bar_real_size_request (GtkWidget* base, GtkRequisition* req) { MatenuMenuBar * self; GtkRequisition _tmp0_ = {0}; GtkRequisition r; self = (MatenuMenuBar*) base; r = (_tmp0_.width = 0, _tmp0_.height = 0, _tmp0_); GTK_WIDGET_CLASS (matenu_menu_bar_parent_class)->size_request ((GtkWidget*) GTK_MENU_BAR (self), req); gtk_widget_size_request ((GtkWidget*) self->priv->_overflown_arrow, &r); if (r.width > (*req).width) { (*req).width = r.width; } if (r.height > (*req).height) { (*req).height = r.height; } }
GtkWidget *CreateBarSubMenu (GtkWidget *menu, char *szName) { GtkWidget *menuitem; GtkWidget *submenu; menuitem = gtk_menu_item_new_with_label (szName); gtk_menu_bar_append (GTK_MENU_BAR (menu), menuitem); gtk_widget_show (menuitem); submenu = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu); return (submenu); }
int main(int argc, char* argv[]) { GtkWidget *win; GtkCssProvider *cssprovider; /* Disable global menus */ g_unsetenv ("UBUNTU_MENUPROXY"); gtk_init(&argc, &argv); win = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_signal_connect(win, "realize", G_CALLBACK(on_realize), NULL); cssprovider = gtk_css_provider_new (); gtk_css_provider_load_from_data(cssprovider, "GtkMenuBar {\n" " -GtkMenuBar-internal-padding: 0;\n" " -GtkMenuBar-shadow-type: none;\n" "}\n" "GtkWidget {\n" " -GtkWidget-focus-line-width: 0;\n" " -GtkWidget-focus-padding: 0;\n" "}\n" ".menuitem {\n" " padding: 0px 0px 0px 0px;\n" "}\n", -1, NULL); gtk_style_context_add_provider_for_screen(gdk_screen_get_default(), GTK_STYLE_PROVIDER (cssprovider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); GtkWidget* menubar = gtk_menu_bar_new(); gtk_menu_bar_set_pack_direction(GTK_MENU_BAR(menubar), GTK_PACK_DIRECTION_RTL); int i; for(i = 0; indicators[i]; i++) { if (!load_module(indicators[i], menubar)) { g_error("Unable to load module"); } } GtkWidget* hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3); gtk_container_add(GTK_CONTAINER(win), hbox); gtk_box_pack_end(GTK_BOX(hbox), menubar, FALSE, FALSE, 0); g_signal_connect_after(menubar, "draw", G_CALLBACK(on_draw), NULL); g_signal_connect(win, "draw", G_CALLBACK(on_draw), NULL); gtk_widget_show_all(win); gdk_window_process_updates(gtk_widget_get_window(win), TRUE); gtk_widget_set_app_paintable(win, TRUE); gtk_main(); return 0; }
int main(int argc, char *argv[]) { gtk_init(&argc, &argv); gst_init(&argc, &argv); GMutex* lock; GList *list; builder = gtk_builder_new(); if (!gtk_builder_add_from_file(builder, "UI.glade", NULL)) { g_print("Error opening file"); return 0; } window = GTK_WIDGET(gtk_builder_get_object(builder, "window")); vBox = GTK_WIDGET(gtk_builder_get_object(builder, "vbox")); vBoxBottom = GTK_WIDGET(gtk_builder_get_object(builder, "vboxBottom")); hBoxToolbar = GTK_WIDGET(gtk_builder_get_object(builder, "hboxToolbar")); hBoxMain = GTK_WIDGET(gtk_builder_get_object(builder, "hboxMain")); // hBox = GTK_WIDGET (gtk_builder_get_object (builder, "hbox")); menu = GTK_MENU_BAR(gtk_builder_get_object(builder, "menubar")); FileItem = GTK_MENU_ITEM(gtk_builder_get_object(builder, "menuitemFile")); MenuFile = GTK_MENU(gtk_builder_get_object(builder, "menuFile")); video_output = GTK_WIDGET(gtk_builder_get_object(builder, "drawingarea")); hScale = GTK_HSCALE(gtk_builder_get_object(builder, "hscale")); hScaleAdjustment = GTK_ADJUSTMENT(gtk_builder_get_object(builder, "adjustment")); // button = GTK_WIDGET (gtk_builder_get_object (builder, "button" )); openMenu = GTK_IMAGE_MENU_ITEM(gtk_builder_get_object(builder, "imagemenuitemOpen")); quitMenu = GTK_IMAGE_MENU_ITEM(gtk_builder_get_object(builder, "imagemenuitemQuit")); toolBar = GTK_TOOLBAR(gtk_builder_get_object(builder, "toolbar")); buttonPlay = GTK_TOOL_BUTTON(gtk_builder_get_object(builder, "toolbuttonPlay")); buttonPause = GTK_TOOL_BUTTON(gtk_builder_get_object(builder, "toolbuttonPause")); buttonStop = GTK_TOOL_BUTTON(gtk_builder_get_object(builder, "toolbuttonStop")); volumeButton = GTK_VOLUME_BUTTON(gtk_builder_get_object(builder, "volumebutton")); seek_cb_signal = g_signal_connect (G_OBJECT (hScale), "value-changed", G_CALLBACK (seek_cb), NULL); g_signal_connect (G_OBJECT (hScale), "button-press-event", G_CALLBACK (slider_button_press_cb), NULL); g_signal_connect (G_OBJECT (hScale), "button-release-event", G_CALLBACK (slider_button_release_cb), NULL); gtk_builder_connect_signals(builder, NULL); g_object_unref(G_OBJECT(builder)); gtk_widget_show_all(window); // g_timeout_add(1, changeScroll, NULL); duration = GST_CLOCK_TIME_NONE; gtk_main(); gst_element_set_state (pipeline, GST_STATE_NULL); gst_object_unref (pipeline); return 0; }
GtkWidget * add_submenu (GtkWidget * menu_bar, gchar * label_text, GtkWidget * menu) { GtkWidget *menu_item; GtkWidget *label; menu_item = gtk_menu_item_new (); label = gtk_widget_new (GTK_TYPE_LABEL, "GtkWidget::visible", TRUE, "GtkWidget::parent", menu_item, "GtkMisc::xalign", 0.0, NULL); gtk_label_parse_uline (GTK_LABEL (label), label_text); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), menu); gtk_menu_bar_append (GTK_MENU_BAR (menu_bar), menu_item); gtk_widget_show (menu_item); return menu_item; }
int main(int argc, char *argv[]) { gtk_init(&argc, &argv); GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size(GTK_WINDOW(window), 200, 200); g_signal_connect(window, "destroy", G_CALLBACK(destroy), NULL); GtkWidget *menubar = gtk_menu_bar_new(); gtk_container_add(GTK_CONTAINER(window), menubar); GtkActionGroup *actiongroup = gtk_action_group_new("ActionGroup"); GtkAction *action = gtk_action_new("actionFile", "_File", NULL, NULL); gtk_action_group_add_action(GTK_ACTION_GROUP(actiongroup), action); GtkWidget *menuitemFile = gtk_action_create_menu_item(GTK_ACTION(action)); gtk_menu_bar_append(GTK_MENU_BAR(menubar), menuitemFile); GtkWidget *menu = gtk_menu_new(); gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitemFile), menu); GtkToggleAction *toggleaction; toggleaction = gtk_toggle_action_new("actionNew", "_New", "Create a new document", GTK_STOCK_NEW); gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(toggleaction), TRUE); gtk_action_group_add_action(GTK_ACTION_GROUP(actiongroup), GTK_ACTION(toggleaction)); GtkWidget *menuitemNew = gtk_action_create_menu_item(GTK_ACTION(toggleaction)); gtk_menu_append(GTK_MENU(menu), menuitemNew); toggleaction = gtk_toggle_action_new("actionOpen", "_Open", "Open a file", GTK_STOCK_OPEN); gtk_action_group_add_action(GTK_ACTION_GROUP(actiongroup), GTK_ACTION(toggleaction)); GtkWidget *menuitemOpen = gtk_action_create_menu_item(GTK_ACTION(toggleaction)); gtk_menu_append(GTK_MENU(menu), menuitemOpen); toggleaction = gtk_toggle_action_new("actionSave", "_Save", "Save a file", GTK_STOCK_SAVE); gtk_action_group_add_action(GTK_ACTION_GROUP(actiongroup), GTK_ACTION(toggleaction)); GtkWidget *menuitemSave = gtk_action_create_menu_item(GTK_ACTION(toggleaction)); gtk_menu_append(GTK_MENU(menu), menuitemSave); gtk_widget_show_all(window); gtk_main(); return 0; }
static void gtk_image_menu_item_size_request (GtkWidget *widget, GtkRequisition *requisition) { GtkImageMenuItem *image_menu_item; gint child_width = 0; gint child_height = 0; GtkPackDirection pack_dir; if (GTK_IS_MENU_BAR (widget->parent)) pack_dir = gtk_menu_bar_get_child_pack_direction (GTK_MENU_BAR (widget->parent)); else pack_dir = GTK_PACK_DIRECTION_LTR; image_menu_item = GTK_IMAGE_MENU_ITEM (widget); if (image_menu_item->image && gtk_widget_get_visible (image_menu_item->image)) { GtkRequisition child_requisition; gtk_widget_size_request (image_menu_item->image, &child_requisition); child_width = child_requisition.width; child_height = child_requisition.height; } GTK_WIDGET_CLASS (gtk_image_menu_item_parent_class)->size_request (widget, requisition); /* not done with height since that happens via the * toggle_size_request */ if (pack_dir == GTK_PACK_DIRECTION_LTR || pack_dir == GTK_PACK_DIRECTION_RTL) requisition->height = MAX (requisition->height, child_height); else requisition->width = MAX (requisition->width, child_width); /* Note that GtkMenuShell always size requests before * toggle_size_request, so toggle_size_request will be able to use * image_menu_item->image->requisition */ }
/* * CreateBarSubMenu * * Create a submenu within an existing submenu. (In other words, it's not * the menubar.) * * menu - existing submenu * szName - label to be given to the new submenu off of this submenu * * returns new menu widget */ GtkWidget *CreateBarSubMenu (GtkWidget *menu, char *szName) { GtkWidget *menuitem; GtkWidget *submenu; /* --- Create menu --- */ menuitem = gtk_menu_item_new_with_label (szName); /* --- Add it to the menubar --- */ gtk_menu_bar_append (GTK_MENU_BAR (menu), menuitem); gtk_widget_show (menuitem); /* --- Get a menu and attach to the menuitem --- */ submenu = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu); /* --- Viola! --- */ return (submenu); }