void wxMenu::Init()
{
m_popupShown = false;
m_accel = gtk_accel_group_new();
m_menu = gtk_menu_new();
// NB: keep reference to the menu so that it is not destroyed behind
// our back by GTK+ e.g. when it is removed from menubar:
g_object_ref_sink(m_menu);
m_owner = NULL;
// Tearoffs are entries, just like separators. So if we want this
// menu to be a tear-off one, we just append a tearoff entry
// immediately.
if ( m_style & wxMENU_TEAROFF )
{
GtkWidget *tearoff = gtk_tearoff_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(m_menu), tearoff);
}
// append the title as the very first entry if we have it
if ( !m_title.empty() )
{
Append(wxGTK_TITLE_ID, m_title);
AppendSeparator();
}
// "show" occurs for sub-menus which are not showing, so use "map" instead
g_signal_connect(m_menu, "map", G_CALLBACK(menu_map), this);
g_signal_connect(m_menu, "hide", G_CALLBACK(menu_hide), this);
}
void wxMenu::Init()
{
m_accel = gtk_accel_group_new();
m_menu = gtk_menu_new();
// NB: keep reference to the menu so that it is not destroyed behind
// our back by GTK+ e.g. when it is removed from menubar:
gtk_widget_ref(m_menu);
m_owner = NULL;
// Tearoffs are entries, just like separators. So if we want this
// menu to be a tear-off one, we just append a tearoff entry
// immediately.
if ( m_style & wxMENU_TEAROFF )
{
GtkWidget *tearoff = gtk_tearoff_menu_item_new();
gtk_menu_append(GTK_MENU(m_menu), tearoff);
}
m_prevRadio = NULL;
// append the title as the very first entry if we have it
if ( !m_title.empty() )
{
Append(wxGTK_TITLE_ID, m_title);
AppendSeparator();
}
}
void
create_freq_menu(void) {
GtkWidget *menuitem;
int i;
if (menu != NULL) {
gtk_widget_destroy(menu);
}
if (!nstations) {
menu = NULL;
return;
}
menu = gtk_menu_new();
gtk_menu_set_title(GTK_MENU(menu),"frequency menu");
menuitem = gtk_tearoff_menu_item_new();
gtk_menu_append(GTK_MENU(menu),menuitem);
gtk_widget_show(menuitem);
for (i=0; i < nstations; i++) {
menuitem = gtk_menu_item_new_with_label(stations[i].station_name);
gtk_menu_append(GTK_MENU(menu),menuitem);
gtk_signal_connect(GTK_OBJECT(menuitem),"activate",
GTK_SIGNAL_FUNC(freq_menu_activated),GINT_TO_POINTER(i));
}
gtk_widget_show_all(menu);
}
static void
pipe_menu_recreate (GtkWidget *item, gchar *command)
{
gchar *stdout_for_cmd;
gchar *cache_entries = g_object_get_data (G_OBJECT(item), "cached");
GtkWidget *submenu;
submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM(item));
if (submenu)
{
if (strcmp (cache_entries, "yes") != 0)
{
gtk_widget_destroy (submenu);
submenu = NULL;
}
}
if (!submenu)
{
submenu = gtk_menu_new();
if (g_spawn_command_line_sync (parse_expand_tilde(command), &stdout_for_cmd, NULL, NULL, NULL))
{
GError *error = NULL;
DeskmenuObject *dm_object = g_object_get_data (G_OBJECT(item), "menu");
dm_object->current_menu = submenu;
dm_object->make_from_pipe = TRUE;
if (gtk_menu_get_tearoff_state (GTK_MENU(dm_object->menu)))
{
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu),
gtk_tearoff_menu_item_new());
}
GMarkupParseContext *context = g_markup_parse_context_new (&parser,
0, dm_object, NULL);
g_markup_parse_context_parse (context, (const gchar *)stdout_for_cmd, strlen((const char *)stdout_for_cmd), &error);
g_markup_parse_context_free (context);
if (error)
{
g_print("%s", error->message); //spit out the message manually
if (dm_object->current_item)
{
//force reset
deskmenu_free_item(dm_object);
}
g_error_free (error);
}
g_free(stdout_for_cmd);
dm_object->make_from_pipe = FALSE;
}
else
{
GtkWidget *empty_item = gtk_menu_item_new_with_label ("Unable to get output");
gtk_widget_set_sensitive (empty_item, FALSE);
gtk_menu_shell_append (GTK_MENU_SHELL (submenu), empty_item);
}
gtk_widget_show_all(submenu);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), submenu);
}
}
/**
* Adds a teaoroff menuitem if there isn't one already and the gconf option is set
*/
void
gul_gui_setup_tearoff (GtkMenuShell *ms)
{
gboolean has_tearoff = eel_gconf_get_boolean ("/desktop/gnome/interface/menus_have_tearoff");
if (has_tearoff && !gul_gui_menu_shell_has_tearoff (ms))
{
GtkWidget *tearoff = gtk_tearoff_menu_item_new ();
gtk_widget_show (tearoff);
gtk_menu_shell_prepend (ms, tearoff);
}
}
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;
}
static GtkWidget *
build_menu(GtkWidget *sheet, Register_Window *rw)
{
GtkWidget *menu;
GtkWidget *item;
// GtkAccelGroup *accel_group;
int i;
if(sheet==NULL || rw==NULL)
{
printf("Warning build_menu(%x,%x)\n",(unsigned int)sheet,(unsigned int)rw);
return NULL;
}
menu=gtk_menu_new();
/* accel_group = gtk_accel_group_new ();
gtk_accel_group_attach (accel_group, GTK_OBJECT (rw->gui_obj.window));
gtk_menu_set_accel_group (GTK_MENU (menu), accel_group);
*/
item = gtk_tearoff_menu_item_new ();
gtk_menu_append (GTK_MENU (menu), item);
gtk_widget_show (item);
for (i=0; i < (sizeof(menu_items)/sizeof(menu_items[0])) ; i++){
item=gtk_menu_item_new_with_label(menu_items[i].name);
gtk_signal_connect(GTK_OBJECT(item),"activate",
(GtkSignalFunc) popup_activated,
&menu_items[i]);
GTK_WIDGET_SET_FLAGS (item, GTK_SENSITIVE | GTK_CAN_FOCUS);
if(rw->type == REGISTER_EEPROM && menu_items[i].id!=MENU_ADD_WATCH)
{
GTK_WIDGET_UNSET_FLAGS (item,
GTK_SENSITIVE | GTK_CAN_FOCUS);
}
gtk_widget_show(item);
gtk_menu_append(GTK_MENU(menu),item);
}
return menu;
}
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GtkMenuPeer_addTearOff
(JNIEnv *env, jobject obj)
{
void *ptr1;
GtkWidget *menu, *item;
gdk_threads_enter ();
ptr1 = NSA_GET_PTR (env, obj);
menu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (ptr1));
item = gtk_tearoff_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
gdk_threads_leave ();
}
void
go_combo_box_construct (GOComboBox *combo,
GtkWidget *display_widget,
GtkWidget *popdown_container,
G_GNUC_UNUSED GtkWidget *popdown_focus)
{
GtkWidget *tearable;
GtkWidget *vbox;
g_return_if_fail (GO_IS_COMBO_BOX (combo));
gtk_box_set_spacing (GTK_BOX (combo), 0);
gtk_box_set_homogeneous (GTK_BOX (combo), FALSE);
combo->priv->popdown_container = popdown_container;
combo->priv->display_widget = NULL;
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
tearable = gtk_tearoff_menu_item_new ();
g_signal_connect (tearable, "enter-notify-event",
G_CALLBACK (cb_tearable_enter_leave),
GINT_TO_POINTER (TRUE));
g_signal_connect (tearable, "leave-notify-event",
G_CALLBACK (cb_tearable_enter_leave),
GINT_TO_POINTER (FALSE));
g_signal_connect (tearable, "button-release-event",
G_CALLBACK (cb_tearable_button_release),
(gpointer) combo);
g_signal_connect (tearable, "parent-set",
G_CALLBACK (cb_tearable_parent_changed),
(gpointer) combo);
gtk_box_pack_start (GTK_BOX (vbox), tearable, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), popdown_container, TRUE, TRUE, 0);
combo->priv->tearable = tearable;
g_object_set (tearable, "no-show-all", TRUE, NULL);
go_combo_box_set_tearable (combo, FALSE);
go_combo_box_set_relief (combo, GTK_RELIEF_NORMAL);
go_combo_box_set_display (combo, display_widget);
gtk_container_add (GTK_CONTAINER (combo->priv->frame), vbox);
gtk_widget_show_all (combo->priv->frame);
}
GtkWidget *DialogPeer::CreateFileMenu()
{
GtkWidget *menushell, *window;
GtkWidget *menu, *menuitem;
window = GTK_WIDGET(g_datalist_get_data(&widset, "window-widget"));
menushell = gtk_menu_item_new_with_mnemonic(_("_File"));
menu = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menushell), menu);
menuitem = gtk_menu_item_new_with_label(_("Attach File"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
g_signal_connect_swapped(menuitem, "activate", G_CALLBACK(AttachRegular), this);
gtk_widget_add_accelerator(menuitem, "activate", accel,
GDK_S, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
menuitem = gtk_menu_item_new_with_label(_("Attach Folder"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
g_signal_connect_swapped(menuitem, "activate", G_CALLBACK(AttachFolder), this);
gtk_widget_add_accelerator(menuitem, "activate", accel,
GDK_D, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
menuitem = gtk_menu_item_new_with_label(_("Request Shared Resources"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
g_signal_connect_swapped(menuitem, "activate",
G_CALLBACK(AskSharedFiles), grpinf);
gtk_widget_add_accelerator(menuitem, "activate", accel,
GDK_R, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
menuitem = gtk_tearoff_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
menuitem = gtk_menu_item_new_with_label(_("Close"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
g_signal_connect_swapped(menuitem, "activate",
G_CALLBACK(gtk_widget_destroy), window);
gtk_widget_add_accelerator(menuitem, "activate", accel,
GDK_W, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
g_datalist_set_data(&widset, "file-menu",menu);
return menushell;
}
/**** Tearoff menu item constructor ****/
int
clip_GTK_TEAROFFMENUITEMNEW(ClipMachine * ClipMachineMemory)
{
ClipVar *cv = _clip_spar(ClipMachineMemory, 1);
GtkWidget *wid = NULL;
C_widget *cwid;
CHECKOPT(1, MAP_type_of_ClipVarType);
wid = gtk_tearoff_menu_item_new();
if (!wid)
goto err;
cwid = _register_widget(ClipMachineMemory, wid, cv);
_clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &cwid->obj);
return 0;
err:
return 1;
}
static GtkWidget *
create_menu (gint depth,
gboolean tearoff)
{
GtkWidget *menu;
GtkWidget *menuitem;
GSList *group;
char buf[32];
int i, j;
if (depth < 1)
return NULL;
menu = gtk_menu_new ();
group = NULL;
if (tearoff)
{
menuitem = gtk_tearoff_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
}
for (i = 0, j = 1; i < 5; i++, j++)
{
sprintf (buf, "item %2d - %d", depth, j);
menuitem = gtk_radio_menu_item_new_with_label (group, buf);
group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (menuitem));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
if (i == 3)
gtk_widget_set_sensitive (menuitem, FALSE);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (depth - 1, TRUE));
}
return menu;
}
static void
menushell_build_children (GladeXML *xml, GtkWidget *w,
GladeWidgetInfo *info)
{
int i, j;
MateUIInfo infos[2] = {
{ MATE_APP_UI_ITEM },
MATEUIINFO_END
};
for (i = 0; i < info->n_children; i++) {
GladeChildInfo *cinfo = &info->children[i];
GladeWidgetInfo *cwinfo = cinfo->child;
GtkWidget *child;
gchar *stock_name = NULL;
for (j = 0; j < cwinfo->n_properties; j++) {
if (!strcmp (cwinfo->properties[j].name, "stock_item")) {
stock_name = cwinfo->properties[j].value;
break;
}
}
if (!stock_name) {
/* this is a normal menu item */
child = glade_xml_build_widget (xml, cwinfo);
gtk_menu_shell_append (GTK_MENU_SHELL (w), child);
continue;
}
/* load the template MateUIInfo for this item */
if (!get_stock_uiinfo (stock_name, &infos[0])) {
/* failure ... */
if (!strncmp (stock_name, "MATEUIINFO_", 12))
stock_name += 12;
child = gtk_menu_item_new_with_label (stock_name);
glade_xml_set_common_params (xml, child, cwinfo);
gtk_menu_shell_append (GTK_MENU_SHELL(w), child);
continue;
}
/* we now have the template for this item. Now fill it in */
for (j = 0; j < cwinfo->n_properties; j++) {
const char *name = cwinfo->properties[j].name;
const char *value = cwinfo->properties[j].value;
if (!strcmp (name, "label"))
infos[0].label = _(value);
else if (!strcmp (name, "tooltip"))
infos[0].hint = _(value);
}
mate_app_fill_menu (GTK_MENU_SHELL(w), infos,
glade_xml_ensure_accel(xml), TRUE,
i);
child = infos[0].widget;
gtk_menu_item_remove_submenu(GTK_MENU_ITEM(child));
glade_xml_set_common_params(xml, child, cwinfo);
}
#if 0
if (uline)
glade_xml_pop_uline_accel(xml);
#endif
#if 0
if (strcmp(info->classname, "GtkMenuBar") != 0 &&
mate_preferences_get_menus_have_tearoff()) {
GtkWidget *tearoff = gtk_tearoff_menu_item_new();
gtk_menu_prepend(GTK_MENU(w), tearoff);
gtk_widget_show(tearoff);
}
#endif
}
/*! \brief Translate a resource tree into a menu structure
*
* \param [in] menu The GHidMainMenu widget to be acted on
* \param [in] shall The base menu shell (a menu bar or popup menu)
* \param [in] res The base of the resource tree
* */
void
ghid_main_menu_real_add_resource (GHidMainMenu *menu, GtkMenuShell *shell,
const Resource *res)
{
int i, j;
const Resource *tmp_res;
gchar mnemonic = 0;
for (i = 0; i < res->c; ++i)
{
const gchar *accel = NULL;
char *menu_label;
const char *res_val;
const Resource *sub_res = res->v[i].subres;
GtkAction *action = NULL;
switch (resource_type (res->v[i]))
{
case 101: /* name, subres: passthrough */
ghid_main_menu_real_add_resource (menu, shell, sub_res);
break;
case 1: /* no name, subres */
tmp_res = resource_subres (sub_res, "a"); /* accelerator */
res_val = resource_value (sub_res, "m"); /* mnemonic */
if (res_val)
mnemonic = res_val[0];
/* The accelerator resource will have two values, like
* a={"Ctrl-Q" "Ctrl<Key>q"}
* The first Gtk ignores. The second needs to be translated. */
if (tmp_res)
accel = check_unique_accel
(translate_accelerator (tmp_res->v[1].value));
/* Now look for the first unnamed value (not a subresource) to
* figure out the name of the menu or the menuitem. */
res_val = "button";
for (j = 0; j < sub_res->c; ++j)
if (resource_type (sub_res->v[j]) == 10)
{
res_val = _(sub_res->v[j].value);
break;
}
/* Hack '_' in based on mnemonic value */
if (!mnemonic)
menu_label = g_strdup (res_val);
else
{
char *post_ = strchr (res_val, mnemonic);
if (post_ == NULL)
menu_label = g_strdup (res_val);
else
{
GString *tmp = g_string_new ("");
g_string_append_len (tmp, res_val, post_ - res_val);
g_string_append_c (tmp, '_');
g_string_append (tmp, post_);
menu_label = g_string_free (tmp, FALSE);
}
}
/* If the subresource we're processing also has unnamed
* subresources, it's a submenu, not a regular menuitem. */
if (sub_res->flags & FLAG_S)
{
/* SUBMENU */
GtkWidget *submenu = gtk_menu_new ();
GtkWidget *item = gtk_menu_item_new_with_mnemonic (menu_label);
GtkWidget *tearoff = gtk_tearoff_menu_item_new ();
gtk_menu_shell_append (shell, item);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), submenu);
/* add tearoff to menu */
gtk_menu_shell_append (GTK_MENU_SHELL (submenu), tearoff);
/* recurse on the newly-added submenu */
ghid_main_menu_real_add_resource (menu,
GTK_MENU_SHELL (submenu),
sub_res);
}
else
{
/* NON-SUBMENU: MENU ITEM */
const char *checked = resource_value (sub_res, "checked");
const char *label = resource_value (sub_res, "sensitive");
const char *tip = resource_value (sub_res, "tip");
if (checked)
{
/* TOGGLE ITEM */
gchar *name = g_strdup_printf ("MainMenuAction%d",
action_counter++);
action = GTK_ACTION (gtk_toggle_action_new (name, menu_label,
tip, NULL));
/* checked=foo is a binary flag (checkbox)
* checked=foo,bar is a flag compared to a value (radio) */
gtk_toggle_action_set_draw_as_radio
(GTK_TOGGLE_ACTION (action), !!strchr (checked, ','));
}
else if (label && strcmp (label, "false") == 0)
{
/* INSENSITIVE ITEM */
GtkWidget *item = gtk_menu_item_new_with_label (menu_label);
gtk_widget_set_sensitive (item, FALSE);
gtk_menu_shell_append (shell, item);
}
else
{
/* NORMAL ITEM */
gchar *name = g_strdup_printf ("MainMenuAction%d", action_counter++);
action = gtk_action_new (name, menu_label, tip, NULL);
}
}
/* Connect accelerator, if there is one */
if (action)
{
GtkWidget *item;
gtk_action_set_accel_group (action, menu->accel_group);
gtk_action_group_add_action_with_accel (menu->action_group,
action, accel);
gtk_action_connect_accelerator (action);
g_signal_connect (G_OBJECT (action), "activate", menu->action_cb,
(gpointer) sub_res);
g_object_set_data (G_OBJECT (action), "resource",
(gpointer) sub_res);
item = gtk_action_create_menu_item (action);
gtk_menu_shell_append (shell, item);
menu->actions = g_list_append (menu->actions, action);
menu->special_key_cb (accel, action, sub_res);
}
/* Scan rest of resource in case there is more work */
for (j = 0; j < sub_res->c; j++)
{
const char *res_name;
/* named value = X resource */
if (resource_type (sub_res->v[j]) == 110)
{
res_name = sub_res->v[j].name;
/* translate bg, fg to background, foreground */
if (strcmp (res_name, "fg") == 0) res_name = "foreground";
if (strcmp (res_name, "bg") == 0) res_name = "background";
/* ignore special named values (m, a, sensitive) */
if (strcmp (res_name, "m") == 0
|| strcmp (res_name, "a") == 0
|| strcmp (res_name, "sensitive") == 0
|| strcmp (res_name, "tip") == 0)
break;
/* log checked and active special values */
if (action && strcmp (res_name, "checked") == 0)
g_object_set_data (G_OBJECT (action), "checked-flag",
sub_res->v[j].value);
else if (action && strcmp (res_name, "active") == 0)
g_object_set_data (G_OBJECT (action), "active-flag",
sub_res->v[j].value);
else
/* if we got this far it is supposed to be an X
* resource. For now ignore it and warn the user */
Message (_("The gtk gui currently ignores \"%s\""
"as part of a menuitem resource.\n"
"Feel free to provide patches\n"),
sub_res->v[j].value);
}
}
break;
case 10: /* no name, value */
/* If we get here, the resource is "-" or "@foo" for some foo */
if (res->v[i].value[0] == '@')
{
GList *children;
int pos;
children = gtk_container_get_children (GTK_CONTAINER (shell));
pos = g_list_length (children);
g_list_free (children);
if (strcmp (res->v[i].value, "@layerview") == 0)
{
menu->layer_view_shell = shell;
menu->layer_view_pos = pos;
}
else if (strcmp (res->v[i].value, "@layerpick") == 0)
{
menu->layer_pick_shell = shell;
menu->layer_pick_pos = pos;
}
else if (strcmp (res->v[i].value, "@routestyles") == 0)
{
menu->route_style_shell = shell;
menu->route_style_pos = pos;
}
else
Message (_("GTK GUI currently ignores \"%s\" in the menu\n"
"resource file.\n"), res->v[i].value);
}
else if (strcmp (res->v[i].value, "-") == 0)
{
GtkWidget *item = gtk_separator_menu_item_new ();
gtk_menu_shell_append (shell, item);
}
else if (i > 0)
{
/* This is an action-less menuitem. It is really only useful
* when you're starting to build a new menu and you're looking
* to get the layout right. */
GtkWidget *item
= gtk_menu_item_new_with_label (_(res->v[i].value));
gtk_menu_shell_append (shell, item);
}
break;
}
}
}
GtkWidget *menubar_new (GtkWidget *Window)
{
GtkWidget *Menu;
GtkItemFactory *ItemFactory;
GtkAccelGroup *AccelGroup;
gchar *AccelRC;
guint NbMenuEntries = sizeof (MenuEntries) / sizeof (MenuEntries[0]);
MsgBarToggleDisplay = FALSE;
ToolBarToggleDisplay = FALSE;
ToggleWordwrap = FALSE;
AccelGroup = gtk_accel_group_new();
ItemFactory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", AccelGroup);
gtk_item_factory_create_items (ItemFactory, NbMenuEntries,
MenuEntries, NULL);
gtk_window_add_accel_group (GTK_WINDOW (Window), AccelGroup);
Menu = gtk_tearoff_menu_item_new ();
gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget
(ItemFactory, "<main>/File")), Menu);
Menu = gtk_tearoff_menu_item_new ();
gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget
(ItemFactory, "<main>/File/Recent Files")), Menu);
Menu = gtk_tearoff_menu_item_new ();
gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget
(ItemFactory, "<main>/Edit")), Menu);
Menu = gtk_tearoff_menu_item_new ();
gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget
(ItemFactory, "<main>/Tools")), Menu);
Menu = gtk_tearoff_menu_item_new ();
gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget
(ItemFactory, "<main>/Tools/Conversions")), Menu);
Menu = gtk_tearoff_menu_item_new ();
gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget
(ItemFactory, "<main>/Settings")), Menu);
Menu = gtk_tearoff_menu_item_new ();
gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget
(ItemFactory, "<main>/Settings/Doc Tabs")), Menu);
if (MSGBAR_DISPLAY)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_widget
(ItemFactory,
"<main>/Settings/Msg Bar")),
TRUE);
if (TOOLBAR_DISPLAY)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_widget
(ItemFactory,
"<main>/Settings/Tool Bar")),
TRUE);
if (TOGGLE_WORDWRAP)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_widget
(ItemFactory,
"<main>/Settings/Wordwrap")),
TRUE);
if (TAB_POSITION == 1)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_widget
(ItemFactory,
"<main>/Settings/Doc Tabs/Top")),
TRUE);
if (TAB_POSITION == 2)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_widget
(ItemFactory,
"<main>/Settings/Doc Tabs/Bottom")),
TRUE);
if (TAB_POSITION == 3)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_widget
(ItemFactory,
"<main>/Settings/Doc Tabs/Left")),
TRUE);
if (TAB_POSITION == 4)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_widget
(ItemFactory,
"<main>/Settings/Doc Tabs/Right")),
TRUE);
Menu = gtk_tearoff_menu_item_new ();
gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget
(ItemFactory, "<main>/Settings/Scroll Bar")),
Menu);
if (SCROLLBAR_POSITION == 1)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_widget
(ItemFactory,
"<main>/Settings/Scroll Bar/Left")),
TRUE);
if (SCROLLBAR_POSITION == 2)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_widget
(ItemFactory,
"<main>/Settings/Scroll Bar/Right")),
TRUE);
Menu = gtk_tearoff_menu_item_new ();
gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget
(ItemFactory, "<main>/Languages")), Menu);
Menu = gtk_tearoff_menu_item_new ();
gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget
(ItemFactory, "<main>/Help")), Menu);
Menu = gtk_item_factory_get_widget (ItemFactory, "<main>");
AccelRC = g_strconcat (g_get_home_dir (), PATH_SEP_STRING, CONF_DIR,
PATH_SEP_STRING, "AccelRC", NULL);
gtk_item_factory_parse_rc (AccelRC);
g_free (AccelRC);
init_recent_files ();
init_languages_menu ();
gtk_menu_bar_set_shadow_type (GTK_MENU_BAR(Menu), GTK_SHADOW_NONE);
return (Menu);
}
void FillBSPMenu(){
GtkWidget *item, *menu; // menu points to a GtkMenu (not an item)
epair_t *ep;
GList *lst;
int i;
menu = GTK_WIDGET( g_object_get_data( G_OBJECT( g_qeglobals_gui.d_main_window ), "menu_bsp" ) );
while ( ( lst = gtk_container_children( GTK_CONTAINER( menu ) ) ) != NULL )
gtk_container_remove( GTK_CONTAINER( menu ), GTK_WIDGET( lst->data ) );
if ( g_PrefsDlg.m_bDetachableMenus ) {
item = gtk_tearoff_menu_item_new();
gtk_menu_append( GTK_MENU( menu ), item );
gtk_widget_set_sensitive( item, TRUE );
gtk_widget_show( item );
}
if ( g_qeglobals.bBSPFrontendPlugin ) {
CString str = g_BSPFrontendTable.m_pfnGetBSPMenu();
char cTemp[1024];
strcpy( cTemp, str );
char* token = strtok( cTemp, ",;" );
if ( token && *token == ' ' ) {
while ( *token == ' ' )
token++;
}
i = 0;
// first token is menu name
item = gtk_menu_get_attach_widget( GTK_MENU( menu ) );
gtk_label_set_text( GTK_LABEL( GTK_BIN( item )->child ), token );
token = strtok( NULL, ",;" );
while ( token != NULL )
{
g_BSPFrontendCommands = g_slist_append( g_BSPFrontendCommands, g_strdup( token ) );
item = gtk_menu_item_new_with_label( token );
gtk_widget_show( item );
gtk_container_add( GTK_CONTAINER( menu ), item );
gtk_signal_connect( GTK_OBJECT( item ), "activate",
GTK_SIGNAL_FUNC( HandleCommand ), GINT_TO_POINTER( CMD_BSPCOMMAND + i ) );
token = strtok( NULL, ",;" );
i++;
}
}
else
{
i = 0;
for ( ep = g_qeglobals.d_project_entity->epairs; ep; ep = ep->next )
{
if ( strncmp( ep->key, "bsp_", 4 ) == 0 ) {
bsp_commands[i] = ep->key;
item = gtk_menu_item_new_with_label( ep->key + 4 );
gtk_widget_show( item );
gtk_container_add( GTK_CONTAINER( menu ), item );
gtk_signal_connect( GTK_OBJECT( item ), "activate",
GTK_SIGNAL_FUNC( HandleCommand ), GINT_TO_POINTER( CMD_BSPCOMMAND + i ) );
i++;
}
}
}
}
static void
start_element (GMarkupParseContext *context,
const gchar *element_name,
const gchar **attr_names,
const gchar **attr_values,
gpointer user_data,
GError **error)
{
DeskmenuObject *dm_object = user_data;
DeskmenuElementType element_type;
const gchar **ncursor = attr_names, **vcursor = attr_values;
GtkWidget *item, *menu;
gint w, h;
element_type = GPOINTER_TO_INT (g_hash_table_lookup
(element_hash, element_name));
if ((dm_object->menu && !dm_object->current_menu)
|| (!dm_object->menu && element_type != DESKMENU_ELEMENT_MENU))
{
gint line_num, char_num;
g_markup_parse_context_get_position (context, &line_num, &char_num);
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
"Error on line %d char %d: Element '%s' declared outside of "
"toplevel menu element", line_num, char_num, element_name);
return;
}
switch (element_type)
{
case DESKMENU_ELEMENT_MENU:
if (dm_object->current_item != NULL)
{
gint line_num, char_num;
g_markup_parse_context_get_position (context, &line_num,
&char_num);
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
"Error on line %d char %d: Element 'menu' cannot be nested "
"inside of an item element", line_num, char_num);
return;
}
if (!dm_object->menu)
{
/*if (strcmp (*ncursor, "size") == 0) {
deskmenu->w = g_strdup (*vcursor);
deskmenu->h = g_strdup (*vcursor);
}
else {
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, deskmenu->w, deskmenu->h);
}*/
dm_object->menu = gtk_menu_new ();
g_object_set_data (G_OBJECT (dm_object->menu), "parent menu",
NULL);
dm_object->current_menu = dm_object->menu;
}
else
{
gchar *name = NULL;
gchar *icon = NULL;
gboolean name_exec = FALSE;
gboolean icon_file = FALSE;
while (*ncursor)
{
if (strcmp (*ncursor, "name") == 0)
name = g_strdup (*vcursor);
else if (strcmp (*ncursor, "icon") == 0)
icon = g_strdup (*vcursor);
else if ((strcmp (*ncursor, "mode") == 0)
&& (strcmp (*vcursor, "exec") == 0))
name_exec = TRUE;
else if ((strcmp (*ncursor, "mode1") == 0)
&& (strcmp (*vcursor, "file") == 0))
icon_file = TRUE;
else
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE,
"Unknown attribute: %s", *ncursor);
ncursor++;
vcursor++;
}
if (name_exec)
{
GtkWidget *label;
GHook *hook;
item = gtk_image_menu_item_new ();
label = gtk_label_new_with_mnemonic (NULL);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
g_object_set_data (G_OBJECT (label), "exec", g_strdup (name));
gtk_container_add (GTK_CONTAINER (item), label);
hook = g_hook_alloc (dm_object->show_hooks);
hook->data = (gpointer) label;
hook->func = (GHookFunc *) launcher_name_exec_update;
g_hook_append (dm_object->show_hooks, hook);
}
else
{
if (name)
item = gtk_image_menu_item_new_with_mnemonic (name);
else
item = gtk_image_menu_item_new_with_mnemonic ("");
}
if (icon)
{
if (icon_file)
{
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM(item),
gtk_image_new_from_pixbuf (gdk_pixbuf_new_from_file_at_size (parse_expand_tilde(icon), w, h, NULL)));
}
else {
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item),
gtk_image_new_from_icon_name (icon, GTK_ICON_SIZE_MENU));
}
}
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu), item);
menu = gtk_menu_new ();
g_object_set_data (G_OBJECT (menu), "parent menu",
dm_object->current_menu);
dm_object->current_menu = menu;
gtk_menu_item_set_submenu (GTK_MENU_ITEM (item),
dm_object->current_menu);
if (!dm_object->make_from_pipe)
{
GtkWidget *pin = gtk_tearoff_menu_item_new();
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu),
pin); //add a pin menu item
dm_object->pin_items = g_slist_prepend (dm_object->pin_items, pin);
}
else
{
if (gtk_menu_get_tearoff_state (GTK_MENU(dm_object->menu)))
{
GtkWidget *pin = gtk_tearoff_menu_item_new();
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu),
pin); //add a pin menu item
}
}
g_free (name);
g_free (icon);
}
break;
case DESKMENU_ELEMENT_SEPARATOR:
if (dm_object->current_item != NULL)
{
gint line_num, char_num;
g_markup_parse_context_get_position (context, &line_num,
&char_num);
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
"Error on line %d char %d: Element 'menu' cannot be nested "
"inside of an item element", line_num, char_num);
return;
}
else {
gchar *name = NULL;
gchar *icon = NULL;
gboolean name_exec = FALSE;
gboolean icon_file = FALSE;
gboolean decorate = FALSE;
gint w, h;
item = gtk_separator_menu_item_new();
while (*ncursor)
{
if (strcmp (*ncursor, "name") == 0)
{
name = g_strdup (*vcursor);
if (!decorate)
{
decorate = TRUE;
}
}
else if (strcmp (*ncursor, "icon") == 0)
{
icon = g_strdup (*vcursor);
if (!decorate)
{
decorate = TRUE;
}
}
else if ((strcmp (*ncursor, "mode") == 0)
&& (strcmp (*vcursor, "exec") == 0))
name_exec = TRUE;
else if ((strcmp (*ncursor, "mode1") == 0)
&& (strcmp (*vcursor, "file") == 0))
icon_file = TRUE;
else
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE,
"Unknown attribute: %s", *ncursor);
ncursor++;
vcursor++;
}
if (decorate)
{
GtkWidget *box = gtk_hbox_new (FALSE, 3);
gtk_container_add (GTK_CONTAINER(item), GTK_WIDGET(box));
if (name_exec)
{
GtkWidget *label;
GHook *hook;
label = gtk_label_new_with_mnemonic (NULL);
g_object_set_data (G_OBJECT (label), "exec", g_strdup (name));
gtk_box_pack_end (GTK_BOX(box), label, TRUE, FALSE, 0);
hook = g_hook_alloc (dm_object->show_hooks);
hook->data = (gpointer) label;
hook->func = (GHookFunc *) launcher_name_exec_update;
g_hook_append (dm_object->show_hooks, hook);
}
else
{
gtk_box_pack_end (GTK_BOX(box), gtk_label_new_with_mnemonic (name), TRUE, FALSE, 0);
}
if (icon)
{
GtkWidget *image;
if (icon_file)
{
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);
image = gtk_image_new_from_pixbuf (gdk_pixbuf_new_from_file_at_size (parse_expand_tilde(icon), w, h, NULL));
}
else {
image = gtk_image_new_from_icon_name (icon, GTK_ICON_SIZE_MENU);
}
gtk_box_pack_start (GTK_BOX(box), image, FALSE, FALSE, 0);
}
gtk_widget_set_state (item, GTK_STATE_PRELIGHT); /*derive colors from menu hover*/
g_free (name);
g_free (icon);
}
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu), item);
}
break;
case DESKMENU_ELEMENT_ITEM:
if (dm_object->current_item != NULL)
{
gint line_num, char_num;
g_markup_parse_context_get_position (context, &line_num,
&char_num);
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
"Error on line %d char %d: Element 'item' cannot be nested "
"inside of another item element", line_num, char_num);
return;
}
dm_object->current_item = g_slice_new0 (DeskmenuItem);
while (*ncursor)
{
if (strcmp (*ncursor, "type") == 0)
dm_object->current_item->type = GPOINTER_TO_INT
(g_hash_table_lookup (item_hash, *vcursor));
else
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE,
"Unknown attribute: %s", *ncursor);
ncursor++;
vcursor++;
}
break;
case DESKMENU_ELEMENT_NAME:
while (*ncursor)
{
if ((strcmp (*ncursor, "mode") == 0)
&& (strcmp (*vcursor, "exec") == 0))
dm_object->current_item->name_exec = TRUE;
ncursor++;
vcursor++;
} /* no break here to let it fall through */
case DESKMENU_ELEMENT_ICON:
while (*ncursor)
{
if ((strcmp (*ncursor, "mode1") == 0)
&& (strcmp (*vcursor, "file") == 0))
dm_object->current_item->icon_file = TRUE;
ncursor++;
vcursor++;
} /* no break here to let it fall through */
case DESKMENU_ELEMENT_VPICON:
while (*ncursor)
{
if ((strcmp (*ncursor, "mode1") == 0)
&& (strcmp (*vcursor, "file") == 0))
dm_object->current_item->vpicon_file = TRUE;
ncursor++;
vcursor++;
} /* no break here to let it fall through */
case DESKMENU_ELEMENT_COMMAND:
while (*ncursor)
{
if ((strcmp (*ncursor, "mode2") == 0)
&& (strcmp (*vcursor, "pipe") == 0))
dm_object->current_item->command_pipe = TRUE;
if (dm_object->current_item->command_pipe == TRUE
&& (strcmp (*ncursor, "cache") == 0)
&& (strcmp (*vcursor, "true") == 0))
dm_object->current_item->cache_output = TRUE;
ncursor++;
vcursor++;
} /* no break here to let it fall through */
case DESKMENU_ELEMENT_WRAP:
if (dm_object->current_item)
dm_object->current_item->current_element = element_type;
break;
case DESKMENU_ELEMENT_THISVP:
if (dm_object->current_item)
dm_object->current_item->current_element = element_type;
break;
case DESKMENU_ELEMENT_MINIONLY:
if (dm_object->current_item)
dm_object->current_item->current_element = element_type;
break;
case DESKMENU_ELEMENT_QUANTITY:
if (dm_object->current_item)
dm_object->current_item->current_element = element_type;
break;
case DESKMENU_ELEMENT_SORT:
if (dm_object->current_item)
dm_object->current_item->current_element = element_type;
break;
case DESKMENU_ELEMENT_AGE:
if (dm_object->current_item)
dm_object->current_item->current_element = element_type;
break;
default:
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_UNKNOWN_ELEMENT,
"Unknown element: %s", element_name);
break;
}
}
void make_menus(Viewer *viewer, GtkWidget *parent)
{
GtkWidget *menubar = gtk_menu_bar_new();
viewer->menu_bar = menubar;
gtk_box_pack_start(GTK_BOX(parent), menubar, FALSE, FALSE, 0);
GtkWidget *file_menuitem = gtk_menu_item_new_with_mnemonic("_File");
gtk_menu_bar_append(GTK_MENU_BAR(menubar), file_menuitem);
viewer->file_menu = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file_menuitem), viewer->file_menu);
/////////////////////
GtkWidget *renderers_menuitem = gtk_menu_item_new_with_mnemonic("_Renderers");
gtk_menu_bar_append(GTK_MENU_BAR(menubar), renderers_menuitem);
viewer->renderers_menu = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(renderers_menuitem), viewer->renderers_menu);
if (1) {
// tearoff
GtkWidget *tearoff = gtk_tearoff_menu_item_new();
gtk_menu_append (GTK_MENU(viewer->renderers_menu), tearoff);
gtk_widget_show (tearoff);
// separator
GtkWidget *sep = gtk_separator_menu_item_new ();
gtk_menu_append (GTK_MENU(viewer->renderers_menu), sep);
gtk_widget_show (sep);
// select all item
GtkWidget *select_all_mi = gtk_menu_item_new_with_mnemonic ("Select _All");
gtk_menu_append (GTK_MENU(viewer->renderers_menu), select_all_mi);
gtk_widget_show (select_all_mi);
// remove all item
GtkWidget *select_none_mi =
gtk_menu_item_new_with_mnemonic ("Select _None");
gtk_menu_append (GTK_MENU(viewer->renderers_menu), select_none_mi);
gtk_widget_show (select_none_mi);
g_signal_connect (G_OBJECT (select_all_mi), "activate",
G_CALLBACK (on_select_all_renderers_activate), viewer);
g_signal_connect (G_OBJECT (select_none_mi), "activate",
G_CALLBACK (on_select_no_renderers_activate), viewer);
}
/////////////////////
GtkWidget *event_handlers_menuitem = gtk_menu_item_new_with_mnemonic("_Input");
gtk_menu_bar_append(GTK_MENU_BAR(menubar), event_handlers_menuitem);
viewer->event_handlers_menu = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(event_handlers_menuitem), viewer->event_handlers_menu);
if (1) {
// tearoff
GtkWidget *tearoff = gtk_tearoff_menu_item_new();
gtk_menu_append (GTK_MENU(viewer->event_handlers_menu), tearoff);
gtk_widget_show (tearoff);
// separator
GtkWidget *sep = gtk_separator_menu_item_new ();
gtk_menu_append (GTK_MENU(viewer->event_handlers_menu), sep);
gtk_widget_show (sep);
// select all item
GtkWidget *select_all_mi = gtk_menu_item_new_with_mnemonic ("Select _All");
gtk_menu_append (GTK_MENU(viewer->event_handlers_menu), select_all_mi);
gtk_widget_show (select_all_mi);
// remove all item
GtkWidget *select_none_mi =
gtk_menu_item_new_with_mnemonic ("Select _None");
gtk_menu_append (GTK_MENU(viewer->event_handlers_menu), select_none_mi);
gtk_widget_show (select_none_mi);
g_signal_connect (G_OBJECT (select_all_mi), "activate",
G_CALLBACK (on_select_all_event_handlers_activate), viewer);
g_signal_connect (G_OBJECT (select_none_mi), "activate",
G_CALLBACK (on_select_no_event_handlers_activate), viewer);
}
/////////////////////
GtkWidget *mode_menuitem = gtk_menu_item_new_with_mnemonic("_Mode");
gtk_menu_bar_append(GTK_MENU_BAR(menubar), mode_menuitem);
viewer->mode_menu = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(mode_menuitem), viewer->mode_menu);
}
static VALUE
rg_initialize(VALUE self)
{
RBGTK_INITIALIZE(self, gtk_tearoff_menu_item_new());
return Qnil;
}
