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