void _HYPlatformWindow::_SetMenuBar(void)
{
_HYWindow* theParent = (_HYWindow*)this;
if (windowMB && menu_items == nil)
{
GtkAccelGroup * accel_group = gtk_accel_group_new();
menu_items = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<HY_WINDOW>",accel_group);
gtk_item_factory_create_items (menu_items, sizeof (hyphy_window_menu_file) / sizeof (hyphy_window_menu_file[0]), hyphy_window_menu_file, theParent);
gtk_item_factory_create_items (menu_items, sizeof (hyphy_window_menu_edit) / sizeof (hyphy_window_menu_edit[0]), hyphy_window_menu_edit, theParent);
gtk_window_add_accel_group (GTK_WINDOW (theWindow), accel_group);
windowMB = gtk_item_factory_get_widget (menu_items, "<HY_WINDOW>");
gtk_widget_show (windowMB);
gtk_widget_set_sensitive(gtk_item_factory_get_widget (menu_items,"<HY_WINDOW>/Edit/Undo"), FALSE);
gtk_widget_set_sensitive(gtk_item_factory_get_widget (menu_items,"<HY_WINDOW>/Edit/Copy"), FALSE);
gtk_widget_set_sensitive(gtk_item_factory_get_widget (menu_items,"<HY_WINDOW>/Edit/Cut"), FALSE);
gtk_widget_set_sensitive(gtk_item_factory_get_widget (menu_items,"<HY_WINDOW>/Edit/Paste"), FALSE);
gtk_widget_set_sensitive(gtk_item_factory_get_widget (menu_items,"<HY_WINDOW>/Edit/Clear"), FALSE);
gtk_widget_set_sensitive(gtk_item_factory_get_widget (menu_items,"<HY_WINDOW>/Edit/Select All"), FALSE);
}
else if (menu_items)
{
gtk_widget_set_sensitive(gtk_item_factory_get_widget (menu_items,"<HY_WINDOW>/File/Save"), theParent->IsSaveEnabled());
gtk_widget_set_sensitive(gtk_item_factory_get_widget (menu_items,"<HY_WINDOW>/File/Print"), theParent->IsPrintEnabled());
}
}
void _HYModelWindow::_SetMenuBar(void)
{
if (menu_items && !gtk_item_factory_get_item(menu_items,"<HY_WINDOW>/Model")) {
gtk_item_factory_delete_item (menu_items, "<HY_WINDOW>/File/Save");
gtk_item_factory_create_items (menu_items, sizeof (hyphy_parameter_model_window_menu) / sizeof (hyphy_parameter_model_window_menu[0]),
hyphy_parameter_model_window_menu, this);
GtkMenu * fileMenu = GTK_MENU (gtk_item_factory_get_widget (menu_items, "<HY_WINDOW>/File"));
gtk_menu_reorder_child (fileMenu, gtk_item_factory_get_item (menu_items, "<HY_WINDOW>/File/Save"), 0);
for (long k=0; k<rateOptions.lLength; k++) {
_String *thisItem = (_String*)rateOptions (k),
chopped,
type = "<CheckItem>";
GtkItemFactoryEntry aProcEntry = {NULL,NULL,(GtkItemFactoryCallback)hyphy_menu_item_callback,HY_MDL_WIN32_MENU_BASE+100+k,type.sData};
chopped = _String("/Model/Rate variation/")&*thisItem;
aProcEntry.path = chopped.sData;
gtk_item_factory_create_items (menu_items, 1, &aProcEntry, this);
}
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(gtk_item_factory_get_widget_by_action(menu_items,HY_MDL_WIN32_MENU_BASE+100+rateChoice)),
true);
gtk_widget_set_sensitive(gtk_item_factory_get_widget (menu_items,"<HY_WINDOW>/Edit/Copy"), true);
gtk_widget_set_sensitive(gtk_item_factory_get_widget (menu_items,"<HY_WINDOW>/Edit/Select All"), true);
}
}
void _HYConsoleWindow::_SetMenuBar(void)
{
if (menu_items && !gtk_item_factory_get_item(menu_items,"<HY_WINDOW>/Analysis")) {
gtk_item_factory_delete_item (menu_items, "<HY_WINDOW>/File/Open");
gtk_item_factory_delete_item (menu_items, "<HY_WINDOW>/File/Close");
gtk_item_factory_delete_item (menu_items, "<HY_WINDOW>/File/Switch to console");
gtk_item_factory_create_items (menu_items, sizeof (hyphy_console_window_menu_file) / sizeof (hyphy_console_window_menu_file[0]), hyphy_console_window_menu_file, this);
GtkMenu * fileMenu = GTK_MENU (gtk_item_factory_get_widget (menu_items, "<HY_WINDOW>/File"));
gtk_menu_reorder_child (fileMenu, gtk_item_factory_get_item (menu_items, "<HY_WINDOW>/File/New"), 0);
gtk_menu_reorder_child (fileMenu, gtk_item_factory_get_item (menu_items, "<HY_WINDOW>/File/Open"), 1);
gtk_menu_reorder_child (fileMenu, gtk_item_factory_get_item (menu_items, "<HY_WINDOW>/File/sep1"), 2);
gtk_widget_set_sensitive(gtk_item_factory_get_widget (menu_items,"<HY_WINDOW>/Edit/Clear"), true);
gtk_widget_set_sensitive(gtk_item_factory_get_widget (menu_items,"<HY_WINDOW>/Edit/Select All"), true);
gtk_widget_set_sensitive(gtk_item_factory_get_widget_by_action(menu_items,21), false);
gtk_widget_set_sensitive(gtk_item_factory_get_widget_by_action(menu_items,22), false);
gtk_widget_set_sensitive(gtk_item_factory_get_item (menu_items,"<HY_WINDOW>/Analysis/Results"), false);
gtk_widget_set_sensitive(gtk_item_factory_get_widget_by_action(menu_items,30), false);
for (long counter=0; counter<availablePostProcessors.countitems(); counter++) {
_String * postItem = (_String*)(*(_List*)availablePostProcessors(counter))(0);
if (!postItem->Equal (&menuSeparator)) {
postItem = (_String*)(*(_List*)availablePostProcessors(counter))(1);
_String tryFileName (*postItem);
FILE * tryFile = doFileOpen (tryFileName.getStr(), "r");
if (tryFile) {
fclose(tryFile);
} else {
availablePostProcessors.Delete(counter);
counter--;
}
}
}
if (availablePostProcessors.lLength) {
long sepCount = 0;
for (long counter=0; counter<availablePostProcessors.countitems(); counter++) {
_String * postItem = (_String*)(*(_List*)availablePostProcessors(counter))(0),
chopped = _String("/Analysis/Results/")&*postItem;
if (postItem->Equal (&menuSeparator)) {
GtkItemFactoryEntry aProcEntry = {NULL,NULL,NULL,0,"<Separator>"};
chopped = chopped & sepCount++;
aProcEntry.path = chopped.sData;
gtk_item_factory_create_items (menu_items, 1, &aProcEntry, this);
} else {
GtkItemFactoryEntry aProcEntry = {NULL,NULL,hyphy_menu_item_callback,1000+counter,"<Item>"};
aProcEntry.path = chopped.sData;
gtk_item_factory_create_items (menu_items, 1, &aProcEntry, this);
}
}
}
}
}
void get_main_menu(GtkWidget * window, GtkWidget ** menubar) {
GtkItemFactory *item_factory;
GtkAccelGroup *accel_group;
gint nmenu_items = sizeof(menu_items) / sizeof(menu_items[0]);
accel_group = gtk_accel_group_new();
/* This function initializes the item factory.
Param 1: The type of menu - can be GTK_TYPE_MENU_BAR, GTK_TYPE_MENU,
or GTK_TYPE_OPTION_MENU.
Param 2: The path of the menu.
Param 3: A pointer to a gtk_accel_group. The item factory sets up
the accelerator table while generating menus.
*/
item_factory = gtk_item_factory_new(GTK_TYPE_MENU_BAR, "<main>",
accel_group);
/* This function generates the menu items. Pass the item factory,
the number of items in the array, the array itself, and any
callback data for the the menu items. */
gtk_item_factory_create_items(item_factory, nmenu_items, menu_items,
NULL);
/* Attach the new accelerator group to the window. */
gtk_window_add_accel_group(GTK_WINDOW(window), accel_group);
if (menubar)
/* Finally, return the actual menu bar created by the item factory. */
*menubar = gtk_item_factory_get_widget(item_factory, "<main>");
}
void itemfact(int argc, char* argv[])
{
GtkWidget* window;
GtkWidget* box;
GtkWidget* menubar;
GtkAccelGroup* accel_group;
GtkItemFactory* item_factory;
gint n=15;
gtk_init(&argc, &argv);
window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), txt("Ìí¼Ó²Ëµ¥µÄ¿ì½Ý·½·¨"));
g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
accel_group=gtk_accel_group_new();
box=gtk_vbox_new(FALSE,0);
gtk_container_add(GTK_CONTAINER(window), box);
gtk_widget_show(box);
item_factory=gtk_item_factory_new(GTK_TYPE_MENU_BAR, "<main>", accel_group);
gtk_item_factory_create_items(item_factory, n, menu_items, NULL);
gtk_window_add_accel_group(GTK_WINDOW(window), accel_group);
menubar=gtk_item_factory_get_widget(item_factory, "<main>");
gtk_box_pack_start(GTK_BOX(box), menubar, FALSE, FALSE, 0);
gtk_widget_show(menubar);
gtk_widget_show(window);
gtk_main();
}
/* Returns a menubar widget made from the above menu */
static void create_menubar_menu()
{
GtkItemFactory *item_factory;
GtkAccelGroup *accel_group;
/* Make an accelerator group (shortcut keys) */
accel_group = gtk_accel_group_new ();
/* Make an ItemFactory (that makes a menubar) */
item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>",
accel_group);
/* This function generates the menu items. Pass the item factory,
the number of items in the array, the array itself, and any
callback data for the the menu items. */
gtk_item_factory_create_items (item_factory, nmenu_items, menu_items, NULL);
/* Attach the new accelerator group to the window. */
gtk_window_add_accel_group (GTK_WINDOW (bdk_window.fenster), accel_group);
/* Finally, return the actual menu bar created by the item factory. */
bdk_window.menubar = gtk_item_factory_get_widget (item_factory, "<main>");
gtk_box_pack_start (GTK_BOX (bdk_window.main_vbox), bdk_window.menubar, FALSE, TRUE, 0);
}
/* gui_menu_setup(window)
*
* Creates the menubar and attaches accelerators to the window passed in.
*
* Returns pointer to menu bar widget.
*/
GtkWidget *gui_menu_setup(
GtkWidget * window)
{
gint nmenu_items = sizeof(menu_items) / sizeof(menu_items[0]);
GtkItemFactory *item_factory;
GtkAccelGroup *accel_group;
accel_group = gtk_accel_group_new();
item_factory = gtk_item_factory_new(GTK_TYPE_MENU_BAR, "<main>",
accel_group);
/* This function generates the menu items. Pass the item factory,
the number of items in the array, the array itself, and any
callback data for the the menu items. */
gtk_item_factory_create_items(item_factory, nmenu_items, menu_items, NULL);
/* Attach the new accelerator group to the window. */
gtk_window_add_accel_group(GTK_WINDOW(window), accel_group);
/* Save the main window widget so we can attach dialogs to it, etc. */
main_window = window;
/* Finally, return the actual menu bar created by the item factory. */
return gtk_item_factory_get_widget(item_factory, "<main>");
}
_String HandlePullDown (_List& menuOptions, long l, long t,long startPos)
{
lastPopupMenuSelection = -1;
lastPopupMenuItemStrings.Clear();
if (lastPopupFactory) {
delete lastPopupFactory;
}
if (menuOptions.lLength) {
ListToPopUpMenu (menuOptions);
GtkWidget *menu;
int button = 0;
guint32 event_time = gtk_get_current_event_time ();
GtkItemFactory * menu_items = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<HY_POPUP>", NULL);
gtk_item_factory_create_items (menu_items, menuOptions.lLength, lastPopupFactory, menu);
menu = gtk_item_factory_get_widget (menu_items, "<HY_POPUP>/Popup");
g_signal_connect (menu, "selection-done", (GCallback)hyphy_popup_menu_close, menu_items);
lastPopupMenuSelection = -1;
gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, button, event_time);
gtk_main ();
gtk_widget_destroy (menu);
g_object_unref(menu_items);
if (lastPopupMenuSelection>=0) {
return *(_String*)menuOptions (lastPopupMenuSelection);
}
}
return empty;
}
static VALUE
ifact_create_items(VALUE self, VALUE ary)
{
VALUE entry, path, accel, type, func, data, extdata;
GtkItemFactoryEntry *entries;
guint i, len, n_menu_entries;
n_menu_entries = RARRAY_LEN(ary);
entries = ALLOC_N(GtkItemFactoryEntry, n_menu_entries);
for (i = 0; i < n_menu_entries; i++) {
entry = RARRAY_PTR(ary)[i];
len = RARRAY_LEN(entry);
Check_Type(entry, T_ARRAY);
path = RARRAY_PTR(entry)[0];
type = ((len > 1) ? RARRAY_PTR(entry)[1] : Qnil);
accel = ((len > 2) ? RARRAY_PTR(entry)[2] : Qnil);
extdata = ((len > 3) ? RARRAY_PTR(entry)[3] : Qnil);
func = ((len > 4) ? RARRAY_PTR(entry)[4] : Qnil);
data = ((len > 5) ? RARRAY_PTR(entry)[5] : Qnil);
create_factory_entry(&entries[i], self, path, type, accel, extdata, func, data);
}
gtk_item_factory_create_items (_SELF(self), n_menu_entries, entries, NULL);
g_free(entries);
return self;
}
/*
* menu_create:
* @ Create menu bar widget.
*
* window : Window widget that attach accel group.
* entries : Menu item entries.
* n_entries : Number of menu items.
* path : Root menu path.
* data : User data for menu callback.
* Return : Menubar widget.
*/
GtkWidget *
menubar_create (GtkWidget *window,
GtkItemFactoryEntry *entries,
guint n_entries,
const gchar *path,
gpointer data)
{
GtkItemFactory *factory;
GtkAccelGroup *accel_group;
GtkWidget *widget;
accel_group = gtk_accel_group_new ();
factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, path, accel_group);
#ifdef ENABLE_NLS
gtk_item_factory_set_translate_func (factory, (GtkTranslateFunc) gettext,
NULL, NULL);
#endif /* ENABLE_NLS */
gtk_item_factory_create_items (factory, n_entries, entries, data);
gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
widget = gtk_item_factory_get_widget (factory, path);
g_signal_connect (G_OBJECT (widget), "destroy",
G_CALLBACK (cb_menu_destroy), factory);
return widget;
}
void init_app( App *a )
{
GtkWidget *menubar;
GtkItemFactory *item_factory;
GtkAccelGroup *accel_group = gtk_accel_group_new();
signed int nitems = sizeof ( menu_items ) / sizeof ( menu_items[0] );
GtkWidget *vbox, *hbox;
// Create the top-level root window
a->rootwindow = gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_signal_connect( GTK_OBJECT( a->rootwindow ), "delete_event", gtk_main_quit,
NULL );
// A toplevel box to hold things
vbox = gtk_vbox_new( FALSE, 0 );
gtk_container_add( GTK_CONTAINER( a->rootwindow ), vbox );
// Construct the main menu structure
item_factory = gtk_item_factory_new( GTK_TYPE_MENU_BAR, "<main>", accel_group );
gtk_item_factory_create_items( item_factory, (guint) nitems, menu_items, NULL );
gtk_window_add_accel_group( GTK_WINDOW( a->rootwindow ), accel_group );
menubar = gtk_item_factory_get_widget( item_factory, "<main>" );
gtk_box_pack_start( GTK_BOX( vbox ), menubar, FALSE, FALSE, 0 );
gtk_widget_show( menubar );
// Fiddle with boxes to effect an indent from the edges of the root window
hbox = gtk_hbox_new( FALSE, 0 );
gtk_box_pack_start( GTK_BOX( vbox ), hbox, TRUE, TRUE, 10 );
vbox = gtk_vbox_new( FALSE, 10 );
gtk_box_pack_start( GTK_BOX( hbox ), vbox, TRUE, TRUE, 10 );
// Add an area to plot into
a->plotwindow = gtk_drawing_area_new();
a->plotwindow_pixmap = NULL;
#if TO_PIXMAP != 1
// Turn off double buffering if we are plotting direct to the plotwindow
// in setup_plot_drawable().
//
GTK_WIDGET_UNSET_FLAGS( a->plotwindow, GTK_DOUBLE_BUFFERED );
#endif
// By experiment, 3x3 seems to be the smallest size plplot can cope with.
// Here we utilise the side effect that gtk_widget_set_size_request()
// effectively sets the minimum size of the widget.
//
gtk_widget_set_size_request( a->plotwindow, 3, 3 );
gtk_box_pack_start( GTK_BOX( vbox ), a->plotwindow, TRUE, TRUE, 0 );
// Set the initial size of the application
gtk_window_set_default_size( GTK_WINDOW( a->rootwindow ), APP_INITIAL_WIDTH, APP_INITIAL_HEIGHT );
g_signal_connect( G_OBJECT( a->plotwindow ), "configure_event",
G_CALLBACK( ev_plotwindow_conf ), NULL );
g_signal_connect( G_OBJECT( a->plotwindow ), "expose_event",
G_CALLBACK( ev_plotwindow_expose ), NULL );
gtk_widget_show_all( a->rootwindow );
}
void _HYParameterTable::_SetMenuBar(void)
{
if (menu_items && !gtk_item_factory_get_widget(menu_items,"<HY_WINDOW>/Likelihood"))
{
gtk_item_factory_create_items (menu_items, sizeof (hyphy_parameter_table_window_menu) / sizeof (hyphy_parameter_table_window_menu[0]),
hyphy_parameter_table_window_menu, this);
_UpdateViewMenu();
gtk_widget_set_sensitive (gtk_item_factory_get_widget_by_action(menu_items,HY_WINDOW_MENU_ID_EDIT),undoCommands.lLength);
}
}
/*-----------------------------------------------------------------------------------------------------------------*/
void GetMainMenu(GtkWidget*window,GtkWidget **menubar)
{
GtkItemFactory *item_factory;
GtkAccelGroup *accel_group;
gint nmenu_items=sizeof(menu_items)/sizeof(menu_items[0]);
accel_group=gtk_accel_group_new();
item_factory=gtk_item_factory_new(GTK_TYPE_MENU_BAR,"<main>",accel_group);
gtk_item_factory_create_items(item_factory,nmenu_items,menu_items,NULL);
gtk_window_add_accel_group(GTK_WINDOW(window),accel_group);
if (menubar) *menubar=gtk_item_factory_get_widget(item_factory,"<main>");
}
void _HYDistributionChartWindow::_SetMenuBar(void)
{
if (menu_items && !gtk_item_factory_get_widget(menu_items,"<HY_WINDOW>/Categories")) {
_HYChartWindow::_SetMenuBar();
gtk_item_factory_create_items (menu_items, sizeof (hyphy_distro_window_menu) / sizeof (hyphy_distro_window_menu[0]), hyphy_distro_window_menu, this);
if (distribProcessors.lLength > 0) {
for (long k=0; k<distribProcessors.lLength; k++) {
_String *thisItem = (_String*)distribProcessors (k),
chopped = thisItem->Cut (thisItem->FindBackwards ('/',0,-1)+1,-1),
type = "<Item>";
GtkItemFactoryEntry aProcEntry = {NULL,NULL,(GtkItemFactoryCallback)hyphy_menu_item_callback,HY_CHARTD_WIN32_MENU_BASE+3+k,type.sData};
chopped = _String("/Categories/")&chopped;
aProcEntry.path = chopped.sData;
gtk_item_factory_create_items (menu_items, 1, &aProcEntry, this);
}
}
}
}
/* This is just directly from the gtk menubar tutorial. */
static GtkWidget *get_menubar_menu(GtkWidget *window)
{
GtkItemFactory *item_factory;
GtkAccelGroup *accel_group;
accel_group = gtk_accel_group_new();
item_factory = gtk_item_factory_new(GTK_TYPE_MENU_BAR, "<main>", accel_group);
gtk_item_factory_create_items(item_factory, nmenu_items, menu_items, NULL);
gtk_window_add_accel_group(GTK_WINDOW(window), accel_group);
return gtk_item_factory_get_widget(item_factory, "<main>");
}
/* Same again but return an option menu */
GtkWidget *get_option_menu( void )
{
GtkItemFactory *item_factory;
GtkWidget *option_menu;
/* Same again, not bothering with the accelerators */
item_factory = gtk_item_factory_new (GTK_TYPE_OPTION_MENU, "<main>",
NULL);
gtk_item_factory_create_items (item_factory, nmenu_items, menu_items, NULL);
option_menu = gtk_item_factory_get_widget (item_factory, "<main>");
return option_menu;
}
PRIVATE GtkWidget *build_popup(Control *c) {
GtkItemFactory *ifact;
GtkWidget *result;
int nitems = sizeof(popup_items) / sizeof(popup_items[0]);
ifact = gtk_item_factory_new(GTK_TYPE_MENU, "<seqnote-popup>", NULL);
gtk_item_factory_create_items(ifact, nitems, popup_items, c);
result = gtk_item_factory_get_widget(ifact, "<seqnote-popup>");
gtk_signal_connect(GTK_OBJECT(result), "destroy", GTK_SIGNAL_FUNC(kill_popup), ifact);
return result;
}
void _HYChartWindow::_SetMenuBar(void)
{
if (menu_items && !gtk_item_factory_get_widget(menu_items,"<HY_WINDOW>/Chart")) {
gtk_item_factory_create_items (menu_items, sizeof (hyphy_char_window_menu) / sizeof (hyphy_char_window_menu[0]), hyphy_char_window_menu, this);
GtkMenu *fileMenu = GTK_MENU(gtk_item_factory_get_widget(menu_items,"<HY_WINDOW>/File"));
gtk_menu_reorder_child(fileMenu,gtk_item_factory_get_widget_by_action(menu_items,HY_WINDOW_MENU_ID_FILE+3),1);
gtk_menu_reorder_child(fileMenu,gtk_item_factory_get_widget_by_action(menu_items,HY_WINDOW_MENU_ID_FILE+4),2);
gtk_menu_reorder_child(fileMenu,gtk_item_factory_get_widget_by_action(menu_items,HY_WINDOW_MENU_ID_FILE+5),4);
gtk_widget_set_sensitive(gtk_item_factory_get_widget_by_action(menu_items,HY_WINDOW_MENU_ID_EDIT+1),true);
gtk_widget_set_sensitive(gtk_item_factory_get_widget_by_action(menu_items,HY_WINDOW_MENU_ID_EDIT+3),true);
gtk_widget_set_sensitive(gtk_item_factory_get_widget_by_action(menu_items,HY_WINDOW_MENU_ID_EDIT+5),true);
/*InsertMenu (saveMenu, 0xFFFFFFFF, MF_BYPOSITION|MF_STRING, HY_WINDOW_MENU_ID_FILE+1, "Save &Chart\tCtrl-S");
InsertMenu (saveMenu, 0xFFFFFFFF, MF_BYPOSITION|MF_STRING, HY_WINDOW_MENU_ID_FILE+3, "Save &Graphic");
InsertMenu (saveMenu, 0xFFFFFFFF, MF_BYPOSITION|MF_STRING, HY_WINDOW_MENU_ID_FILE+4, "Save &Table");
InsertMenu (printMenu, 0xFFFFFFFF, MF_BYPOSITION|MF_STRING, HY_WINDOW_MENU_ID_FILE+2, "Print &Graphic\tCtrl-P");
InsertMenu (printMenu, 0xFFFFFFFF, MF_BYPOSITION|MF_STRING, HY_WINDOW_MENU_ID_FILE+5, "Print &Data");*/
for (long k=0; k<chartProcessors.lLength; k++) {
_String *thisItem = (_String*)chartProcessors (k),
chopped = thisItem->Cut (thisItem->FindBackwards ('/',0,-1)+1,-1),
type = "<Item>";
GtkItemFactoryEntry aProcEntry = {NULL,NULL,(GtkItemFactoryCallback)hyphy_menu_item_callback,HY_CHART_WIN32_MENU_BASE+5+k,type.sData};
chopped = _String("/Chart/Data Processing/")&chopped;
aProcEntry.path = chopped.sData;
gtk_item_factory_create_items (menu_items, 1, &aProcEntry, this);
}
//ModifyMenu (chartMenu, 0, MF_BYPOSITION|MF_POPUP, (UINT) saveMenu , "&Save");
//ModifyMenu (chartMenu, 1, MF_BYPOSITION|MF_POPUP, (UINT) printMenu , "&Print");
}
}
GtkWidget *popup_menu_new (void)
{
GtkItemFactory *ItemFactory;
GtkWidget *PopUpMenu;
guint NbMenuEntries;
NbMenuEntries = sizeof (PopUpMenuEntries) / sizeof (PopUpMenuEntries[0]);
ItemFactory = gtk_item_factory_new (GTK_TYPE_MENU, "<popup_main>", NULL);
gtk_item_factory_create_items (ItemFactory, NbMenuEntries,
PopUpMenuEntries, NULL);
PopUpMenu = gtk_item_factory_get_widget (ItemFactory, "<popup_main>");
return (PopUpMenu);
}
static void
dock_build ()
{
GtkWidget *image;
GtkWidget *eventbox;
dock = egg_tray_icon_new ("Pornview");
eventbox = gtk_event_box_new ();
image = pixbuf_create_pixmap_from_xpm_data (dock_xpm);
GTK_WIDGET_SET_FLAGS (image, GTK_NO_WINDOW);
image->requisition.width = 22;
image->requisition.height = 22;
gtk_widget_set_events (GTK_WIDGET (eventbox),
gtk_widget_get_events (eventbox) |
GDK_BUTTON_PRESS_MASK | GDK_EXPOSURE_MASK);
gtk_signal_connect (GTK_OBJECT (eventbox), "button_press_event",
GTK_SIGNAL_FUNC (cb_dock_clicked), NULL);
gtk_widget_show (eventbox);
/*
* add the status to the plug
*/
gtk_object_set_data (GTK_OBJECT (dock), "pixmapg", image);
gtk_container_add (GTK_CONTAINER (eventbox), image);
gtk_container_add (GTK_CONTAINER (dock), eventbox);
gtk_widget_show_all (GTK_WIDGET (dock));
/*
* add the popup menu
*/
popup_item_factory =
gtk_item_factory_new (GTK_TYPE_MENU, "<popup>", NULL);
#ifdef ENABLE_NLS
gtk_item_factory_set_translate_func (popup_item_factory,
(GtkTranslateFunc) gettext, NULL,
NULL);
#endif
gtk_item_factory_create_items (popup_item_factory,
dock_popupmenu_factory_count,
dock_popupmenu_factory, NULL);
popup_menu = gtk_item_factory_get_widget (popup_item_factory, "<popup>");
}
static int
create_menu_bar( GtkBox *parent, GtkAccelGroup *accel_group )
{
GtkWidget *menu_bar;
menu_factory = gtk_item_factory_new( GTK_TYPE_MENU_BAR, "<main>",
accel_group );
gtk_item_factory_create_items( menu_factory, menu_data_count, menu_data,
NULL);
menu_bar = gtk_item_factory_get_widget( menu_factory, "<main>" );
gtk_box_pack_start( parent, menu_bar, FALSE, FALSE, 0 );
return 0;
}
GtkWidget *getMenubarMenu(GtkWidget *window){
GtkAccelGroup *accel_group; //accelerator group widget
//Make an accelerator group (shortcut keys)
accel_group = gtk_accel_group_new();
//Make an ItemFactory (that makes a menubar)
item_factory = gtk_item_factory_new(GTK_TYPE_MENU_BAR, "<main>", accel_group);
//Generate the menu item
gtk_item_factory_create_items(item_factory, nmenu_items, menu_items, NULL);
//Attach the new accelerator group to the window
gtk_window_add_accel_group(GTK_WINDOW(window), accel_group);
//Return the actual menu bar created by item factory
return gtk_item_factory_get_widget(item_factory, "<main>");
}
void gtkui_create_tab_menu(void)
{
GtkAccelGroup *accel_group;
GtkWidget *context;
GtkItemFactory *if_tabs;
accel_group = gtk_accel_group_new ();
gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
/* context menu for notebook */
if_tabs = gtk_item_factory_new(GTK_TYPE_MENU, "<notebook>", accel_group);
gtk_item_factory_create_items(if_tabs, 5, tab_menu, NULL);
context = gtk_item_factory_get_widget(if_tabs, "<notebook>");
g_signal_connect(G_OBJECT(notebook), "button-press-event", G_CALLBACK(gtkui_context_menu), context);
}
GtkItemFactory *
planner_task_popup_new (PlannerTaskTree *tree)
{
GtkItemFactory *item_factory;
item_factory = gtk_item_factory_new (GTK_TYPE_MENU, "<main>", NULL);
gtk_item_factory_set_translate_func (item_factory,
task_tree_item_factory_trans,
NULL, NULL);
gtk_item_factory_create_items (item_factory,
G_N_ELEMENTS (popup_menu_items),
popup_menu_items, tree);
return item_factory;
}
/* Name is in the form "<panel>" */
GtkItemFactory*
menu_create(GtkItemFactoryEntry *def, int n_entries, const gchar *name, GtkAccelGroup *keys)
{
if (!keys) {
keys = gtk_accel_group_new();
gtk_accel_group_lock(keys);
}
GtkItemFactory* item_factory = gtk_item_factory_new(GTK_TYPE_MENU, name, keys);
GtkItemFactoryEntry* translated = def;//translate_entries(def, n_entries);
gtk_item_factory_create_items(item_factory, n_entries, translated, NULL);
//free_translated_entries(translated, n_entries);
return item_factory;
}
// Fonction de création du menu
void window_barre_menu()
{
GtkItemFactory * pItemFactory = NULL;
GtkAccelGroup * pAccel = NULL;
gint nb_menu_item = sizeof(menu_item) / sizeof(menu_item[0]);
if(ptr_window==NULL) return;
pAccel = gtk_accel_group_new();
pItemFactory = gtk_item_factory_new(GTK_TYPE_MENU_BAR,"<main>",pAccel);
gtk_item_factory_create_items(pItemFactory,nb_menu_item, menu_item,(GtkWidget*) ptr_window->win);
ptr_window->menu_bar = gtk_item_factory_get_widget(pItemFactory, "<main>");
gtk_window_add_accel_group(GTK_WINDOW(ptr_window->win), pAccel);
gtk_widget_show_all(ptr_window->menu_bar);
}
/* ugly foreigner source from sample */
GtkWidget* MainWindow::get_menubar_menu(GtkWidget *window)
{
GtkItemFactory *item_factory;
GtkAccelGroup *accel_group;
/* Создаём группу акселераторов (shortcut keys) */
accel_group = gtk_accel_group_new ();
/* Создаём ItemFactory (строку меню) */
item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", accel_group);
/* Эта функция генерирует пункты меню. Передает item factory,
номер пункта в массиве, массив непосредственно, а также любые
данные обратных вызовов для пунктов меню. */
gtk_item_factory_create_items (item_factory, nmenu_items, menu_items, NULL);
/* Прикрепляем новую группу акселераторов к окну. */
gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
/* Возвращаем фактически созданную производством пунктов (item factory) панель меню. */
return gtk_item_factory_get_widget (item_factory, "<main>");
}
static
void create_toplevel(GtkVi *vi)
{
GtkWidget *window;
GtkWidget *box, *menubar;
GtkWidget *vi_window;
gint nmenu_items = sizeof (menu_items) / sizeof (menu_items[0]);
GtkItemFactory *factory;
GtkAccelGroup *accel;
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
++n_toplevel;
box = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), box);
gtk_widget_show(box);
vi_window = gtk_vi_window_new(vi);
accel = gtk_accel_group_new();
factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", accel);
gtk_item_factory_create_items (factory, nmenu_items, menu_items, (gpointer)vi_window);
gtk_accel_group_attach(accel, GTK_OBJECT(window));
menubar = gtk_item_factory_get_widget (factory, "<main>");
gtk_widget_show(menubar);
gtk_box_pack_start(GTK_BOX(box), menubar, FALSE, FALSE, 0);
gtk_accel_group_attach(accel, GTK_OBJECT(vi_window));
gtk_widget_show(vi_window);
gtk_signal_connect(GTK_OBJECT(vi_window), "rename",
GTK_SIGNAL_FUNC(vi_rename),
window);
gtk_signal_connect(GTK_OBJECT(GTK_VI_WINDOW(vi_window)->vi_screen), "destroy",
GTK_SIGNAL_FUNC(vi_destroyed),
window);
gtk_box_pack_start(GTK_BOX(box), vi_window, TRUE, TRUE, 0);
/*
gtk_widget_grab_focus(GTK_WIDGET(vi->vi));
*/
gtk_widget_show(window);
}
static GtkWidget *
create_menubar (GtkWindow *window)
{
GtkItemFactory *item_factory;
GtkAccelGroup *accel_group=NULL;
GtkWidget *menubar;
accel_group = gtk_accel_group_new ();
item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>",
accel_group);
gtk_item_factory_create_items (item_factory,
G_N_ELEMENTS (menu_items),
menu_items, NULL);
gtk_window_add_accel_group (window, accel_group);
menubar = gtk_item_factory_get_widget (item_factory, "<main>");
return menubar;
}
/* Same as with get_menubar_menu() but just return a button with a signal to
call a popup menu */
GtkWidget *get_popup_menu( void )
{
GtkItemFactory *item_factory;
GtkWidget *button, *menu;
/* Same as before but don't bother with the accelerators */
item_factory = gtk_item_factory_new (GTK_TYPE_MENU, "<main>",
NULL);
gtk_item_factory_create_items (item_factory, nmenu_items, menu_items, NULL);
menu = gtk_item_factory_get_widget (item_factory, "<main>");
/* Make a button to activate the popup menu */
button = gtk_button_new_with_label ("Popup");
/* Make the menu popup when clicked */
g_signal_connect (G_OBJECT(button),
"event",
G_CALLBACK(popup_cb),
(gpointer) menu);
return button;
}
