自学教程：C++ GTK_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;}

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 voidgtk_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 voidgtk_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  */voidcreate_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 voidpanel_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);}

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

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

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

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

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

intmain(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 voidgtk_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);}