static void
gimp_action_set_proxy (GimpAction *action,
GtkWidget *proxy)
{
if (! GTK_IS_IMAGE_MENU_ITEM (proxy))
return;
if (action->color)
{
GtkWidget *area;
area = gtk_image_menu_item_get_image (GTK_IMAGE_MENU_ITEM (proxy));
if (GIMP_IS_COLOR_AREA (area))
{
gimp_color_area_set_color (GIMP_COLOR_AREA (area), action->color);
}
else
{
gint width, height;
area = gimp_color_area_new (action->color,
GIMP_COLOR_AREA_SMALL_CHECKS, 0);
gimp_color_area_set_draw_border (GIMP_COLOR_AREA (area), TRUE);
gtk_icon_size_lookup_for_settings (gtk_widget_get_settings (proxy),
GTK_ICON_SIZE_MENU,
&width, &height);
gtk_widget_set_size_request (area, width, height);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (proxy), area);
gtk_widget_show (area);
}
}
else if (action->viewable)
{
GtkWidget *view;
view = gtk_image_menu_item_get_image (GTK_IMAGE_MENU_ITEM (proxy));
if (GIMP_IS_VIEW (view) &&
g_type_is_a (G_TYPE_FROM_INSTANCE (action->viewable),
GIMP_VIEW (view)->renderer->viewable_type))
{
gimp_view_set_viewable (GIMP_VIEW (view), action->viewable);
}
else
{
GtkIconSize size;
gint width, height;
gint border_width;
if (GIMP_IS_IMAGEFILE (action->viewable))
{
size = GTK_ICON_SIZE_LARGE_TOOLBAR;
border_width = 0;
}
else
{
size = GTK_ICON_SIZE_MENU;
border_width = 1;
}
gtk_icon_size_lookup_for_settings (gtk_widget_get_settings (proxy),
size, &width, &height);
view = gimp_view_new_full (action->context, action->viewable,
width, height, border_width,
FALSE, FALSE, FALSE);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (proxy), view);
gtk_widget_show (view);
}
}
else
{
GtkWidget *image;
image = gtk_image_menu_item_get_image (GTK_IMAGE_MENU_ITEM (proxy));
if (GIMP_IS_VIEW (image) || GIMP_IS_COLOR_AREA (image))
{
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (proxy), NULL);
g_object_notify (G_OBJECT (action), "icon-name");
}
}
{
GtkWidget *child = gtk_bin_get_child (GTK_BIN (proxy));
if (GTK_IS_LABEL (child))
{
GtkLabel *label = GTK_LABEL (child);
gtk_label_set_ellipsize (label, action->ellipsize);
gtk_label_set_max_width_chars (label, action->max_width_chars);
}
}
}
static void
create_popup_menu (ViewerCbInfo * info)
{
GtkWidget *popup_menu;
GtkWidget *menu_item;
GtkWidget *stock;
popup_menu = gtk_menu_new ();
gtk_menu_set_accel_group (GTK_MENU (popup_menu), info->accel_group);
if (info->base_uri) {
menu_item = gtk_image_menu_item_new_with_label (_("Copy SVG location"));
stock = gtk_image_new_from_stock (GTK_STOCK_COPY, GTK_ICON_SIZE_MENU);
gtk_widget_show (stock);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item), stock);
g_signal_connect (menu_item, "activate", G_CALLBACK (copy_svg_location), info);
gtk_widget_show (menu_item);
gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), menu_item);
gtk_widget_add_accelerator (menu_item, "activate", info->accel_group, GDK_C,
GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
}
menu_item = gtk_image_menu_item_new_from_stock (GTK_STOCK_SAVE, NULL);
g_signal_connect (menu_item, "activate", G_CALLBACK (save_svg), info);
gtk_widget_show (menu_item);
gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), menu_item);
gtk_widget_add_accelerator (menu_item, "activate", info->accel_group, GDK_S, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
menu_item = gtk_image_menu_item_new_with_label (_("Save as PNG"));
stock = gtk_image_new_from_stock (GTK_STOCK_SAVE_AS, GTK_ICON_SIZE_MENU);
gtk_widget_show (stock);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item), stock);
g_signal_connect (menu_item, "activate", G_CALLBACK (save_pixbuf), info);
gtk_widget_show (menu_item);
gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), menu_item);
gtk_widget_add_accelerator (menu_item, "activate", info->accel_group, GDK_S,
GDK_CONTROL_MASK | GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE);
#if GTK_CHECK_VERSION(2,10,0)
menu_item = gtk_image_menu_item_new_from_stock (GTK_STOCK_PRINT, NULL);
g_signal_connect (menu_item, "activate", G_CALLBACK (print_pixbuf), info);
gtk_widget_show (menu_item);
gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), menu_item);
gtk_widget_add_accelerator (menu_item, "activate", info->accel_group, GDK_P, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
#endif
menu_item = gtk_image_menu_item_new_from_stock (GTK_STOCK_ZOOM_IN, NULL);
g_signal_connect (menu_item, "activate", G_CALLBACK (zoom_in), info);
gtk_widget_show (menu_item);
gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), menu_item);
gtk_widget_add_accelerator (menu_item, "activate", info->accel_group, GDK_plus,
GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
menu_item = gtk_image_menu_item_new_from_stock (GTK_STOCK_ZOOM_OUT, NULL);
g_signal_connect (menu_item, "activate", G_CALLBACK (zoom_out), info);
gtk_widget_show (menu_item);
gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), menu_item);
gtk_widget_add_accelerator (menu_item, "activate", info->accel_group, GDK_minus,
GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
info->popup_menu = popup_menu;
}
static GtkWidget *
build_suggestion_menu (PlumaAutomaticSpellChecker *spell, const gchar *word)
{
GtkWidget *topmenu, *menu;
GtkWidget *mi;
GSList *suggestions;
GSList *list;
gchar *label_text;
topmenu = menu = gtk_menu_new();
suggestions = pluma_spell_checker_get_suggestions (spell->spell_checker, word, -1);
list = suggestions;
if (suggestions == NULL)
{
/* no suggestions. put something in the menu anyway... */
GtkWidget *label;
/* Translators: Displayed in the "Check Spelling" dialog if there are no suggestions for the current misspelled word */
label = gtk_label_new (_("(no suggested words)"));
mi = gtk_menu_item_new ();
gtk_widget_set_sensitive (mi, FALSE);
gtk_container_add (GTK_CONTAINER(mi), label);
gtk_widget_show_all (mi);
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), mi);
}
else
{
gint count = 0;
/* build a set of menus with suggestions. */
while (suggestions != NULL)
{
GtkWidget *label;
if (count == 10)
{
/* Separator */
mi = gtk_menu_item_new ();
gtk_widget_show (mi);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
mi = gtk_menu_item_new_with_mnemonic (_("_More..."));
gtk_widget_show (mi);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (mi), menu);
count = 0;
}
label_text = g_strdup_printf ("<b>%s</b>", (gchar*) suggestions->data);
label = gtk_label_new (label_text);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
mi = gtk_menu_item_new ();
gtk_container_add (GTK_CONTAINER(mi), label);
gtk_widget_show_all (mi);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
g_object_set_qdata_full (G_OBJECT (mi),
suggestion_id,
g_strdup (suggestions->data),
(GDestroyNotify)g_free);
g_free (label_text);
g_signal_connect (mi,
"activate",
G_CALLBACK (replace_word),
spell);
count++;
suggestions = g_slist_next (suggestions);
}
}
/* free the suggestion list */
suggestions = list;
while (list)
{
g_free (list->data);
list = g_slist_next (list);
}
g_slist_free (suggestions);
/* Separator */
mi = gtk_menu_item_new ();
gtk_widget_show (mi);
gtk_menu_shell_append (GTK_MENU_SHELL (topmenu), mi);
/* Ignore all */
mi = gtk_image_menu_item_new_with_mnemonic (_("_Ignore All"));
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (mi),
gtk_image_new_from_icon_name ("go-bottom",
GTK_ICON_SIZE_MENU));
g_signal_connect (mi,
"activate",
G_CALLBACK(ignore_all),
spell);
gtk_widget_show_all (mi);
gtk_menu_shell_append (GTK_MENU_SHELL (topmenu), mi);
/* + Add to Dictionary */
mi = gtk_image_menu_item_new_with_mnemonic (_("_Add"));
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (mi),
gtk_image_new_from_icon_name ("list-add",
GTK_ICON_SIZE_MENU));
g_signal_connect (mi,
"activate",
G_CALLBACK (add_to_dictionary),
spell);
gtk_widget_show_all (mi);
gtk_menu_shell_append (GTK_MENU_SHELL (topmenu), mi);
return topmenu;
}
void
nemo_menus_append_bookmark_to_menu (NemoWindow *window,
NemoBookmark *bookmark,
const char *parent_path,
const char *parent_id,
guint index_in_parent,
GtkActionGroup *action_group,
guint merge_id,
GCallback refresh_callback,
NemoBookmarkFailedCallback failed_callback)
{
BookmarkHolder *bookmark_holder;
char action_name[128];
const char *name;
char *path;
GIcon *icon;
GtkAction *action;
GtkWidget *menuitem;
g_assert (NEMO_IS_WINDOW (window));
g_assert (NEMO_IS_BOOKMARK (bookmark));
bookmark_holder = bookmark_holder_new (bookmark, window, refresh_callback, failed_callback);
name = nemo_bookmark_get_name (bookmark);
/* Create menu item with pixbuf */
icon = nemo_bookmark_get_icon (bookmark);
g_snprintf (action_name, sizeof (action_name), "%s%d", parent_id, index_in_parent);
action = gtk_action_new (action_name,
name,
_("Go to the location specified by this bookmark"),
NULL);
g_object_set_data_full (G_OBJECT (action), "menu-icon",
icon,
g_object_unref);
g_signal_connect_data (action, "activate",
G_CALLBACK (activate_bookmark_in_menu_item),
bookmark_holder,
bookmark_holder_free_cover, 0);
gtk_action_group_add_action (action_group,
GTK_ACTION (action));
g_object_unref (action);
gtk_ui_manager_add_ui (window->details->ui_manager,
merge_id,
parent_path,
action_name,
action_name,
GTK_UI_MANAGER_MENUITEM,
FALSE);
path = g_strdup_printf ("%s/%s", parent_path, action_name);
menuitem = gtk_ui_manager_get_widget (window->details->ui_manager,
path);
gtk_image_menu_item_set_always_show_image (GTK_IMAGE_MENU_ITEM (menuitem),
TRUE);
g_free (path);
}
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;
}
}
static void create_menu()
{
GtkWidget *i;
gchar *s;
menu = GTK_MENU(gtk_menu_new());
g_assert(menu != NULL);
s = toutf("_Dostêpny");
i = gtk_image_menu_item_new_with_mnemonic(s);
g_free(s);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), i);
g_signal_connect_swapped(G_OBJECT(i), "activate",
G_CALLBACK(menu_item_cb), "1");
gtk_widget_show(i);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(i),
get_status_icon_new(TLEN_PRESENCE_AVAILABLE));
s = toutf("_Porozmawiajmy");
i = gtk_image_menu_item_new_with_mnemonic(s);
g_free(s);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), i);
g_signal_connect_swapped(G_OBJECT(i), "activate",
G_CALLBACK(menu_item_cb), "2");
gtk_widget_show(i);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(i),
get_status_icon_new(TLEN_PRESENCE_CHATTY));
s = toutf("_Jestem zajêty");
i = gtk_image_menu_item_new_with_mnemonic(s);
g_free(s);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), i);
g_signal_connect_swapped(G_OBJECT(i), "activate",
G_CALLBACK(menu_item_cb), "3");
gtk_widget_show(i);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(i),
get_status_icon_new(TLEN_PRESENCE_DND));
s = toutf("_Zaraz wracam");
i = gtk_image_menu_item_new_with_mnemonic(s);
g_free(s);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), i);
g_signal_connect_swapped(G_OBJECT(i), "activate",
G_CALLBACK(menu_item_cb), "4");
gtk_widget_show(i);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(i),
get_status_icon_new(TLEN_PRESENCE_AWAY));
s = toutf("_Wrócê pó¼niej");
i = gtk_image_menu_item_new_with_mnemonic(s);
g_free(s);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), i);
g_signal_connect_swapped(G_OBJECT(i), "activate",
G_CALLBACK(menu_item_cb), "5");
gtk_widget_show(i);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(i),
get_status_icon_new(TLEN_PRESENCE_EXT_AWAY));
s = toutf("_Niewidoczny");
i = gtk_image_menu_item_new_with_mnemonic(s);
g_free(s);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), i);
g_signal_connect_swapped(G_OBJECT(i), "activate",
G_CALLBACK(menu_item_cb), "6");
gtk_widget_show(i);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(i),
get_status_icon_new(TLEN_PRESENCE_INVISIBLE));
s = toutf("Niedostêpn_y");
i = gtk_image_menu_item_new_with_mnemonic(s);
g_free(s);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), i);
g_signal_connect_swapped(G_OBJECT(i), "activate",
G_CALLBACK(menu_item_cb), "7");
gtk_widget_show(i);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(i),
get_status_icon_new(TLEN_PRESENCE_UNAVAILABLE));
/* separator */
i = gtk_menu_item_new();
gtk_container_add(GTK_CONTAINER(menu), i);
gtk_widget_set_sensitive(i, FALSE);
gtk_widget_show(i);
s = toutf("_Ustaw stan opisowy");
i = gtk_menu_item_new_with_mnemonic(s);
g_free(s);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), i);
g_signal_connect_swapped(G_OBJECT(i), "activate",
G_CALLBACK(menu_item_cb), "8");
gtk_widget_show(i);
/* separator */
i = gtk_menu_item_new();
gtk_container_add(GTK_CONTAINER(menu), i);
gtk_widget_set_sensitive(i, FALSE);
gtk_widget_show(i);
s = toutf("_Koniec");
i = gtk_menu_item_new_with_mnemonic(s);
g_free(s);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), i);
g_signal_connect_swapped(G_OBJECT(i), "activate",
G_CALLBACK(menu_item_cb), "9");
gtk_widget_show(i);
}
static void
gnumeric_create_popup_menu_list (GSList *elements,
GnumericPopupMenuHandler handler,
gpointer user_data,
int display_filter,
int sensitive_filter,
GdkEventButton *event)
{
GtkWidget *menu, *item;
char const *trans;
menu = gtk_menu_new ();
for (; elements != NULL ; elements = elements->next)
{
GnumericPopupMenuElement const *element = elements->data;
char const * const name = element->name;
char const * const pix_name = element->pixmap;
item = NULL;
if (element->display_filter != 0 &&
!(element->display_filter & display_filter))
continue;
if (name != NULL && *name != '\0')
{
trans = _(name);
item = gtk_image_menu_item_new_with_mnemonic (trans);
if (element->sensitive_filter != 0 &&
(element->sensitive_filter & sensitive_filter))
gtk_widget_set_sensitive (GTK_WIDGET (item), FALSE);
if (pix_name != NULL)
{
GtkWidget *image = gtk_image_new_from_stock (pix_name,
GTK_ICON_SIZE_MENU);
gtk_widget_show (image);
gtk_image_menu_item_set_image (
GTK_IMAGE_MENU_ITEM (item),
image);
}
}
else
{
/* separator */
item = gtk_menu_item_new ();
gtk_widget_set_sensitive (item, FALSE);
}
if (element->index != 0)
{
g_signal_connect (G_OBJECT (item),
"activate",
G_CALLBACK (&popup_item_activate), user_data);
g_object_set_data (
G_OBJECT (item), "descriptor", (gpointer)(element));
g_object_set_data (
G_OBJECT (item), "handler", (gpointer)handler);
}
gtk_widget_show (item);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
}
gnumeric_popup_menu (GTK_MENU (menu), event);
}
static void
xfmpc_lists_init (XfmpcLists *lists)
{
XfmpcListsPrivate *priv = lists->priv = GET_PRIVATE (lists);
lists->preferences = xfmpc_preferences_get ();
lists->mpdclient = xfmpc_mpdclient_get ();
/* === Tree model === */
priv->store = gtk_list_store_new (N_COLUMNS,
G_TYPE_INT,
GDK_TYPE_PIXBUF,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_BOOLEAN,
G_TYPE_INT);
/* === Tree view === */
priv->treeview = gtk_tree_view_new ();
gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview)), GTK_SELECTION_MULTIPLE);
gtk_tree_view_set_rubber_banding (GTK_TREE_VIEW (priv->treeview), TRUE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (priv->treeview), TRUE);
gtk_tree_view_set_search_column (GTK_TREE_VIEW (priv->treeview), COLUMN_NAME);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->treeview), FALSE);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (priv->treeview), TRUE);
gtk_tree_view_set_model (GTK_TREE_VIEW (priv->treeview), GTK_TREE_MODEL (priv->store));
g_object_unref (priv->store);
/* Columns */
GtkCellRenderer *cell = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->treeview),
-1, "", cell,
"pixbuf", COLUMN_PIXBUF,
NULL);
cell = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (cell),
"ellipsize", PANGO_ELLIPSIZE_END,
NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->treeview),
-1, "Filename", cell,
"text", COLUMN_NAME,
NULL);
/* Scrolled window */
GtkWidget *scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_ALWAYS);
/* Menu */
priv->menu = gtk_menu_new ();
/* Menu -> Add */
GtkWidget *mi = gtk_image_menu_item_new_from_stock (GTK_STOCK_ADD, NULL);
gtk_menu_shell_append (GTK_MENU_SHELL (priv->menu), mi);
g_signal_connect_swapped (mi, "activate",
G_CALLBACK (xfmpc_lists_add_playlist), lists);
/* Menu -> Replace */
mi = gtk_image_menu_item_new_with_mnemonic (_("Replace"));
gtk_menu_shell_append (GTK_MENU_SHELL (priv->menu), mi);
g_signal_connect_swapped (mi, "activate",
G_CALLBACK (xfmpc_lists_replace_playlist), lists);
GtkWidget *image = gtk_image_new_from_stock (GTK_STOCK_UNDO, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (mi), image);
/* Menu -> Separator */
mi = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL (priv->menu), mi);
/* Menu -> Create */
mi = gtk_image_menu_item_new_from_stock (GTK_STOCK_NEW, NULL);
gtk_menu_shell_append (GTK_MENU_SHELL (priv->menu), mi);
g_signal_connect_swapped (mi, "activate",
G_CALLBACK (xfmpc_lists_create), lists);
/* Menu -> Edit */
mi = gtk_image_menu_item_new_from_stock (GTK_STOCK_EDIT, NULL);
gtk_menu_shell_append (GTK_MENU_SHELL (priv->menu), mi);
g_signal_connect_swapped (mi, "activate",
G_CALLBACK (xfmpc_lists_edit), lists);
/* Menu -> Remove */
mi = gtk_image_menu_item_new_from_stock (GTK_STOCK_DELETE, NULL);
gtk_menu_shell_append (GTK_MENU_SHELL (priv->menu), mi);
g_signal_connect_swapped (mi, "activate",
G_CALLBACK (xfmpc_lists_delete), lists);
xfmpc_menu_add(xfmpc_menu_get(), priv->menu);
gtk_widget_show_all (priv->menu);
/* === Containers === */
gtk_container_add (GTK_CONTAINER (scrolled), priv->treeview);
gtk_box_pack_start (GTK_BOX (lists), scrolled, TRUE, TRUE, 0);
/* === Signals === */
g_signal_connect_swapped (lists->mpdclient, "connected",
G_CALLBACK (xfmpc_lists_reload), lists);
/* Tree view */
g_signal_connect_swapped (priv->treeview, "row-activated",
G_CALLBACK (xfmpc_lists_add_playlist), lists);
g_signal_connect_swapped (priv->treeview, "key-press-event",
G_CALLBACK (cb_key_pressed), lists);
g_signal_connect_swapped (priv->treeview, "button-press-event",
G_CALLBACK (cb_button_pressed), lists);
g_signal_connect_swapped (priv->treeview, "popup-menu",
G_CALLBACK (cb_popup_menu), lists);
}
GtkWidget* gtk_menu_item_new_with_image(const gchar* label, GtkWidget *image) {
GtkWidget* menu_item = gtk_image_menu_item_new_with_mnemonic(label);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_item), image);
return menu_item;
}
static void
notebook_popup_menu_show (CajaNavigationWindowPane *pane,
GdkEventButton *event)
{
GtkWidget *popup;
GtkWidget *item;
GtkWidget *image;
int button, event_time;
gboolean can_move_left, can_move_right;
CajaNotebook *notebook;
notebook = CAJA_NOTEBOOK (pane->notebook);
can_move_left = caja_notebook_can_reorder_current_child_relative (notebook, -1);
can_move_right = caja_notebook_can_reorder_current_child_relative (notebook, 1);
popup = gtk_menu_new();
item = gtk_menu_item_new_with_mnemonic (_("_New Tab"));
g_signal_connect (item, "activate",
G_CALLBACK (notebook_popup_menu_new_tab_cb),
pane);
gtk_menu_shell_append (GTK_MENU_SHELL (popup),
item);
gtk_menu_shell_append (GTK_MENU_SHELL (popup),
gtk_separator_menu_item_new ());
item = gtk_menu_item_new_with_mnemonic (_("Move Tab _Left"));
g_signal_connect (item, "activate",
G_CALLBACK (notebook_popup_menu_move_left_cb),
pane);
gtk_menu_shell_append (GTK_MENU_SHELL (popup),
item);
gtk_widget_set_sensitive (item, can_move_left);
item = gtk_menu_item_new_with_mnemonic (_("Move Tab _Right"));
g_signal_connect (item, "activate",
G_CALLBACK (notebook_popup_menu_move_right_cb),
pane);
gtk_menu_shell_append (GTK_MENU_SHELL (popup),
item);
gtk_widget_set_sensitive (item, can_move_right);
gtk_menu_shell_append (GTK_MENU_SHELL (popup),
gtk_separator_menu_item_new ());
item = gtk_image_menu_item_new_with_mnemonic (_("_Close Tab"));
image = gtk_image_new_from_stock (GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
g_signal_connect (item, "activate",
G_CALLBACK (notebook_popup_menu_close_cb), pane);
gtk_menu_shell_append (GTK_MENU_SHELL (popup),
item);
gtk_widget_show_all (popup);
if (event)
{
button = event->button;
event_time = event->time;
}
else
{
button = 0;
event_time = gtk_get_current_event_time ();
}
/* TODO is this correct? */
gtk_menu_attach_to_widget (GTK_MENU (popup),
pane->notebook,
NULL);
gtk_menu_popup (GTK_MENU (popup), NULL, NULL, NULL, NULL,
button, event_time);
}
/**
* thunar_dnd_ask:
* @widget : the widget on which the drop was performed.
* @folder : the #ThunarFile to which the @path_list is being dropped.
* @path_list : the #GFile<!---->s of the files being dropped to @file.
* @timestamp : the time of the drop event.
* @actions : the list of actions supported for the drop.
*
* Pops up a menu that asks the user to choose one of the
* @actions or to cancel the drop. If the user chooses a
* valid #GdkDragAction from @actions, then this action is
* returned. Else if the user cancels the drop, 0 will be
* returned.
*
* This method can be used to implement a response to the
* #GDK_ACTION_ASK action on drops.
*
* Return value: the selected #GdkDragAction or 0 to cancel.
**/
GdkDragAction
thunar_dnd_ask (GtkWidget *widget,
ThunarFile *folder,
GList *path_list,
guint timestamp,
GdkDragAction dnd_actions)
{
static const GdkDragAction dnd_action_items[] = { GDK_ACTION_COPY, GDK_ACTION_MOVE, GDK_ACTION_LINK };
static const gchar *dnd_action_names[] = { N_ ("_Copy here"), N_ ("_Move here"), N_ ("_Link here") };
static const gchar *dnd_action_icons[] = { "stock_folder-copy", "stock_folder-move", NULL };
ThunarxProviderFactory *factory;
GdkDragAction dnd_action = 0;
ThunarFile *file;
GtkWidget *window;
GtkWidget *image;
GtkWidget *menu;
GtkWidget *item;
GList *file_list = NULL;
GList *providers = NULL;
GList *actions = NULL;
GList *lp;
guint n;
_thunar_return_val_if_fail (thunar_file_is_directory (folder), 0);
_thunar_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
/* connect to the provider factory */
factory = thunarx_provider_factory_get_default ();
/* prepare the popup menu */
menu = gtk_menu_new ();
/* append the various items */
for (n = 0; n < G_N_ELEMENTS (dnd_action_items); ++n)
if (G_LIKELY ((dnd_actions & dnd_action_items[n]) != 0))
{
item = gtk_image_menu_item_new_with_mnemonic (_(dnd_action_names[n]));
g_object_set_data (G_OBJECT (item), I_("dnd-action"), GUINT_TO_POINTER (dnd_action_items[n]));
g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (dnd_action_selected), &dnd_action);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
/* add image to the menu item */
if (G_LIKELY (dnd_action_icons[n] != NULL))
{
image = gtk_image_new_from_icon_name (dnd_action_icons[n], GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
}
}
/* append the separator */
item = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
/* determine the toplevel window the widget belongs to */
window = gtk_widget_get_toplevel (widget);
if (G_LIKELY (window != NULL && gtk_widget_get_toplevel (window)))
{
/* check if we can resolve all paths */
for (lp = path_list; lp != NULL; lp = lp->next)
{
/* try to resolve this path */
file = thunar_file_cache_lookup (lp->data);
if (G_LIKELY (file != NULL))
file_list = g_list_prepend (file_list, file);
else
break;
}
/* check if we resolved all paths (and have atleast one file) */
if (G_LIKELY (file_list != NULL && lp == NULL))
{
/* load the menu providers from the provider factory */
providers = thunarx_provider_factory_list_providers (factory, THUNARX_TYPE_MENU_PROVIDER);
/* load the dnd actions offered by the menu providers */
for (lp = providers; lp != NULL; lp = lp->next)
{
/* merge the actions from this provider */
actions = g_list_concat (actions, thunarx_menu_provider_get_dnd_actions (lp->data, window, THUNARX_FILE_INFO (folder), file_list));
g_object_unref (G_OBJECT (lp->data));
}
g_list_free (providers);
/* check if we have atleast one action */
if (G_UNLIKELY (actions != NULL))
{
/* add menu items for all actions */
for (lp = actions; lp != NULL; lp = lp->next)
{
/* add a menu item for the action */
item = gtk_action_create_menu_item (lp->data);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
g_object_unref (G_OBJECT (lp->data));
gtk_widget_show (item);
}
g_list_free (actions);
/* append another separator */
item = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
}
}
}
/* append the cancel item */
item = gtk_image_menu_item_new_from_stock (GTK_STOCK_CANCEL, NULL);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
/* run the menu on the widget's screen (takes over the floating reference of menu) */
thunar_gtk_menu_run (GTK_MENU (menu), widget, NULL, NULL, 3, timestamp);
/* cleanup */
g_object_unref (G_OBJECT (factory));
g_list_free_full (file_list, g_object_unref);
return dnd_action;
}
void wxMenu::GtkAppend(wxMenuItem* mitem, int pos)
{
GtkWidget *menuItem;
switch (mitem->GetKind())
{
case wxITEM_SEPARATOR:
menuItem = gtk_separator_menu_item_new();
break;
case wxITEM_CHECK:
menuItem = gtk_check_menu_item_new_with_label("");
break;
case wxITEM_RADIO:
{
// See if we need to create a new radio group for this item or
// add it to an existing one.
wxMenuItem* radioGroupItem = NULL;
const size_t numItems = GetMenuItemCount();
const size_t n = pos == -1 ? numItems - 1 : size_t(pos);
if (n != 0)
{
wxMenuItem* const itemPrev = FindItemByPosition(n - 1);
if ( itemPrev->GetKind() == wxITEM_RADIO )
{
// Appending an item after an existing radio item puts
// it into the same radio group.
radioGroupItem = itemPrev;
}
}
if (radioGroupItem == NULL && n != numItems - 1)
{
wxMenuItem* const itemNext = FindItemByPosition(n + 1);
if ( itemNext->GetKind() == wxITEM_RADIO )
{
// Inserting an item before an existing radio item
// also puts it into the existing radio group.
radioGroupItem = itemNext;
}
}
GSList* group = NULL;
if ( radioGroupItem )
{
group = gtk_radio_menu_item_get_group(
GTK_RADIO_MENU_ITEM(radioGroupItem->GetMenuItem())
);
}
menuItem = gtk_radio_menu_item_new_with_label(group, "");
}
break;
default:
wxFAIL_MSG("unexpected menu item kind");
// fall through
case wxITEM_NORMAL:
const wxBitmap& bitmap = mitem->GetBitmap();
const char* stockid;
if (bitmap.IsOk())
{
// always use pixbuf, because pixmap mask does not
// work with disabled images in some themes
GtkWidget* image = gtk_image_new_from_pixbuf(bitmap.GetPixbuf());
menuItem = gtk_image_menu_item_new_with_label("");
gtk_widget_show(image);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menuItem), image);
}
else if ((stockid = wxGetStockGtkID(mitem->GetId())) != NULL)
// use stock bitmap for this item if available on the assumption
// that it never hurts to follow GTK+ conventions more closely
menuItem = gtk_image_menu_item_new_from_stock(stockid, NULL);
else
menuItem = gtk_menu_item_new_with_label("");
break;
}
mitem->SetMenuItem(menuItem);
gtk_menu_shell_insert(GTK_MENU_SHELL(m_menu), menuItem, pos);
gtk_widget_show( menuItem );
if ( !mitem->IsSeparator() )
{
mitem->SetGtkLabel();
g_signal_connect (menuItem, "select",
G_CALLBACK(menuitem_select), mitem);
g_signal_connect (menuItem, "deselect",
G_CALLBACK(menuitem_deselect), mitem);
if ( mitem->IsSubMenu() && mitem->GetKind() != wxITEM_RADIO && mitem->GetKind() != wxITEM_CHECK )
{
gtk_menu_item_set_submenu( GTK_MENU_ITEM(menuItem), mitem->GetSubMenu()->m_menu );
gtk_widget_show( mitem->GetSubMenu()->m_menu );
}
else
{
g_signal_connect(menuItem, "can_activate_accel",
G_CALLBACK(can_activate_accel), this);
g_signal_connect (menuItem, "activate",
G_CALLBACK(menuitem_activate),
mitem);
}
}
}
void gtkui_create() {
// Create the GTK+ Window
gtkui_image_paths();
GdkPixbuf *icon = gdk_pixbuf_new_from_file(iconpath, NULL);
char title[24];
snprintf(title, sizeof(title), "Nestopia UE %s", VERSION);
gtkwindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_icon(GTK_WINDOW(gtkwindow), icon);
gtk_window_set_title(GTK_WINDOW(gtkwindow), title);
gtk_window_set_resizable(GTK_WINDOW(gtkwindow), FALSE);
GtkWidget *box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add(GTK_CONTAINER(gtkwindow), box);
// Define the menubar and menus
GtkWidget *menubar = gtk_menu_bar_new();
// Define the File menu
GtkWidget *filemenu = gtk_menu_new();
GtkWidget *file = gtk_menu_item_new_with_mnemonic("_File");
GtkWidget *open = gtk_image_menu_item_new_from_stock(GTK_STOCK_OPEN, NULL);
GtkWidget *recent = gtk_image_menu_item_new_with_label("Open Recent");
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(recent), gtk_image_new_from_stock(GTK_STOCK_OPEN, GTK_ICON_SIZE_MENU));
GtkWidget *sep_open = gtk_separator_menu_item_new();
GtkWidget *stateload = gtk_image_menu_item_new_with_mnemonic("_Load State...");
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(stateload), gtk_image_new_from_stock(GTK_STOCK_GO_BACK, GTK_ICON_SIZE_MENU));
GtkWidget *statesave = gtk_image_menu_item_new_with_mnemonic("_Save State...");
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(statesave), gtk_image_new_from_stock(GTK_STOCK_SAVE, GTK_ICON_SIZE_MENU));
GtkWidget *quickload = gtk_image_menu_item_new_with_label("Quick Load");
GtkWidget *qloadmenu = gtk_menu_new();
GtkWidget *qload0 = gtk_image_menu_item_new_with_label("0");
GtkWidget *qload1 = gtk_image_menu_item_new_with_label("1");
GtkWidget *qload2 = gtk_image_menu_item_new_with_label("2");
GtkWidget *qload3 = gtk_image_menu_item_new_with_label("3");
GtkWidget *qload4 = gtk_image_menu_item_new_with_label("4");
GtkWidget *quicksave = gtk_image_menu_item_new_with_label("Quick Save");
GtkWidget *qsavemenu = gtk_menu_new();
GtkWidget *qsave0 = gtk_image_menu_item_new_with_label("0");
GtkWidget *qsave1 = gtk_image_menu_item_new_with_label("1");
GtkWidget *qsave2 = gtk_image_menu_item_new_with_label("2");
GtkWidget *qsave3 = gtk_image_menu_item_new_with_label("3");
GtkWidget *qsave4 = gtk_image_menu_item_new_with_label("4");
GtkWidget *sep_state = gtk_separator_menu_item_new();
GtkWidget *screenshot = gtk_image_menu_item_new_with_mnemonic("S_creenshot...");
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(screenshot), gtk_image_new_from_stock(GTK_STOCK_SELECT_COLOR, GTK_ICON_SIZE_MENU));
GtkWidget *sep_screenshot = gtk_separator_menu_item_new();
GtkWidget *movieload = gtk_image_menu_item_new_with_label("Load Movie...");
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(movieload), gtk_image_new_from_stock(GTK_STOCK_OPEN, GTK_ICON_SIZE_MENU));
GtkWidget *moviesave = gtk_image_menu_item_new_with_label("Record Movie...");
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(moviesave), gtk_image_new_from_stock(GTK_STOCK_MEDIA_RECORD, GTK_ICON_SIZE_MENU));
GtkWidget *moviestop = gtk_image_menu_item_new_with_label("Stop Movie");
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(moviestop), gtk_image_new_from_stock(GTK_STOCK_MEDIA_STOP, GTK_ICON_SIZE_MENU));
GtkWidget *sep_movie = gtk_separator_menu_item_new();
GtkWidget *quit = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, NULL);
// Set up the recently used items
GtkWidget *recent_items = gtk_recent_chooser_menu_new();
GtkRecentFilter *recent_filter = gtk_recent_filter_new();
gtk_recent_filter_add_pattern(recent_filter, "*.nes");
gtk_recent_filter_add_pattern(recent_filter, "*.fds");
gtk_recent_filter_add_pattern(recent_filter, "*.unf");
gtk_recent_filter_add_pattern(recent_filter, "*.unif");
gtk_recent_filter_add_pattern(recent_filter, "*.nsf");
gtk_recent_filter_add_pattern(recent_filter, "*.zip");
gtk_recent_filter_add_pattern(recent_filter, "*.7z");
gtk_recent_filter_add_pattern(recent_filter, "*.txz");
gtk_recent_filter_add_pattern(recent_filter, "*.tar.xz");
gtk_recent_filter_add_pattern(recent_filter, "*.xz");
gtk_recent_filter_add_pattern(recent_filter, "*.tgz");
gtk_recent_filter_add_pattern(recent_filter, "*.tar.gz");
gtk_recent_filter_add_pattern(recent_filter, "*.gz");
gtk_recent_filter_add_pattern(recent_filter, "*.tbz");
gtk_recent_filter_add_pattern(recent_filter, "*.tar.bz2");
gtk_recent_filter_add_pattern(recent_filter, "*.bz2");
gtk_recent_chooser_add_filter(GTK_RECENT_CHOOSER(recent_items), recent_filter);
// Populate the File menu
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), filemenu);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), open);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), recent);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(recent), recent_items);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), sep_open);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), stateload);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), statesave);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), quickload);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(quickload), qloadmenu);
gtk_menu_shell_append(GTK_MENU_SHELL(qloadmenu), qload0);
gtk_menu_shell_append(GTK_MENU_SHELL(qloadmenu), qload1);
gtk_menu_shell_append(GTK_MENU_SHELL(qloadmenu), qload2);
gtk_menu_shell_append(GTK_MENU_SHELL(qloadmenu), qload3);
gtk_menu_shell_append(GTK_MENU_SHELL(qloadmenu), qload4);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), quicksave);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(quicksave), qsavemenu);
gtk_menu_shell_append(GTK_MENU_SHELL(qsavemenu), qsave0);
gtk_menu_shell_append(GTK_MENU_SHELL(qsavemenu), qsave1);
gtk_menu_shell_append(GTK_MENU_SHELL(qsavemenu), qsave2);
gtk_menu_shell_append(GTK_MENU_SHELL(qsavemenu), qsave3);
gtk_menu_shell_append(GTK_MENU_SHELL(qsavemenu), qsave4);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), sep_state);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), screenshot);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), sep_screenshot);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), movieload);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), moviesave);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), moviestop);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), sep_movie);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), quit);
// Define the Emulator menu
GtkWidget *emulatormenu = gtk_menu_new();
GtkWidget *emu = gtk_menu_item_new_with_mnemonic("_Emulator");
GtkWidget *cont = gtk_image_menu_item_new_with_mnemonic("C_ontinue");
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(cont), gtk_image_new_from_stock(GTK_STOCK_MEDIA_PLAY, GTK_ICON_SIZE_MENU));
GtkWidget *pause = gtk_image_menu_item_new_from_stock(GTK_STOCK_MEDIA_PAUSE, NULL);
GtkWidget *sep_pause = gtk_separator_menu_item_new();
GtkWidget *resetsoft = gtk_image_menu_item_new_with_mnemonic("_Reset (Soft)");
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(resetsoft), gtk_image_new_from_stock(GTK_STOCK_REFRESH, GTK_ICON_SIZE_MENU));
GtkWidget *resethard = gtk_image_menu_item_new_with_mnemonic("Reset (_Hard)");
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(resethard), gtk_image_new_from_stock(GTK_STOCK_REFRESH, GTK_ICON_SIZE_MENU));
GtkWidget *sep_reset = gtk_separator_menu_item_new();
GtkWidget *fullscreen = gtk_image_menu_item_new_from_stock(GTK_STOCK_FULLSCREEN, NULL);
GtkWidget *sep_fullscreen = gtk_separator_menu_item_new();
GtkWidget *diskflip = gtk_image_menu_item_new_with_mnemonic("Flip FDS _Disk");
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(diskflip), gtk_image_new_from_stock(GTK_STOCK_FLOPPY, GTK_ICON_SIZE_MENU));
GtkWidget *diskswitch = gtk_image_menu_item_new_with_mnemonic("_Switch FDS Disk");
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(diskswitch), gtk_image_new_from_stock(GTK_STOCK_FLOPPY, GTK_ICON_SIZE_MENU));
GtkWidget *sep_disk = gtk_separator_menu_item_new();
GtkWidget *cheats = gtk_image_menu_item_new_with_mnemonic("Ch_eats...");
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(cheats), gtk_image_new_from_stock(GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_MENU));
GtkWidget *sep_cheats = gtk_separator_menu_item_new();
GtkWidget *configuration = gtk_image_menu_item_new_with_mnemonic("_Configuration...");
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(configuration), gtk_image_new_from_stock(GTK_STOCK_PREFERENCES, GTK_ICON_SIZE_MENU));
// Populate the Emulator menu
gtk_menu_item_set_submenu(GTK_MENU_ITEM(emu), emulatormenu);
gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), cont);
gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), pause);
gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), sep_pause);
gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), resetsoft);
gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), resethard);
gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), sep_reset);
gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), fullscreen);
gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), sep_fullscreen);
gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), diskflip);
gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), diskswitch);
gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), sep_disk);
gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), cheats);
gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), sep_cheats);
gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), configuration);
// Define the Help menu
GtkWidget *helpmenu = gtk_menu_new();
GtkWidget *help = gtk_menu_item_new_with_mnemonic("_Help");
GtkWidget *about = gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT, NULL);
// Populate the Help menu
gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), helpmenu);
gtk_menu_shell_append(GTK_MENU_SHELL(helpmenu), about);
// Put the menus into the menubar
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), file);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), emu);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), help);
// Create the DrawingArea/OpenGL context
drawingarea = gtk_drawing_area_new();
//gtk_widget_set_double_buffered(drawingarea, FALSE);
g_object_set_data(G_OBJECT(gtkwindow), "area", drawingarea);
// Set the Drawing Area to be the size of the game output
gtk_widget_set_size_request(drawingarea, rendersize.w, rendersize.h);
// Create the statusbar
GtkWidget *statusbar = gtk_statusbar_new();
// Pack the box with the menubar, drawingarea, and statusbar
gtk_box_pack_start(GTK_BOX(box), menubar, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(box), drawingarea, TRUE, TRUE, 0);
//gtk_box_pack_start(GTK_BOX(box), statusbar, FALSE, FALSE, 0);
// Make it dark if there's a dark theme
GtkSettings *gtksettings = gtk_settings_get_default();
g_object_set(G_OBJECT(gtksettings), "gtk-application-prefer-dark-theme", TRUE, NULL);
// Set up the Drag and Drop target
GtkTargetEntry target_entry[1];
target_entry[0].target = (gchar*)"text/uri-list";
target_entry[0].flags = 0;
target_entry[0].info = 0;
gtk_drag_dest_set(drawingarea, (GtkDestDefaults)(GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP),
target_entry, sizeof(target_entry) / sizeof(GtkTargetEntry), (GdkDragAction)(GDK_ACTION_MOVE | GDK_ACTION_COPY));
// Connect the signals
g_signal_connect(G_OBJECT(drawingarea), "drag-data-received",
G_CALLBACK(gtkui_drag_data), NULL);
g_signal_connect(G_OBJECT(gtkwindow), "delete_event",
G_CALLBACK(nst_schedule_quit), NULL);
// File menu
g_signal_connect(G_OBJECT(open), "activate",
G_CALLBACK(gtkui_file_open), NULL);
g_signal_connect(G_OBJECT(recent_items), "item-activated",
G_CALLBACK(gtkui_open_recent), NULL);
g_signal_connect(G_OBJECT(stateload), "activate",
G_CALLBACK(gtkui_state_load), NULL);
g_signal_connect(G_OBJECT(statesave), "activate",
G_CALLBACK(gtkui_state_save), NULL);
g_signal_connect(G_OBJECT(qload0), "activate",
G_CALLBACK(gtkui_state_quickload), gpointer(0));
g_signal_connect(G_OBJECT(qload1), "activate",
G_CALLBACK(gtkui_state_quickload), gpointer(1));
g_signal_connect(G_OBJECT(qload2), "activate",
G_CALLBACK(gtkui_state_quickload), gpointer(2));
g_signal_connect(G_OBJECT(qload3), "activate",
G_CALLBACK(gtkui_state_quickload), gpointer(3));
g_signal_connect(G_OBJECT(qload4), "activate",
G_CALLBACK(gtkui_state_quickload), gpointer(4));
g_signal_connect(G_OBJECT(qsave0), "activate",
G_CALLBACK(gtkui_state_quicksave), gpointer(0));
g_signal_connect(G_OBJECT(qsave1), "activate",
G_CALLBACK(gtkui_state_quicksave), gpointer(1));
g_signal_connect(G_OBJECT(qsave2), "activate",
G_CALLBACK(gtkui_state_quicksave), gpointer(2));
g_signal_connect(G_OBJECT(qsave3), "activate",
G_CALLBACK(gtkui_state_quicksave), gpointer(3));
g_signal_connect(G_OBJECT(qsave4), "activate",
G_CALLBACK(gtkui_state_quicksave), gpointer(4));
g_signal_connect(G_OBJECT(statesave), "activate",
G_CALLBACK(gtkui_state_save), NULL);
g_signal_connect(G_OBJECT(screenshot), "activate",
G_CALLBACK(gtkui_screenshot_save), NULL);
g_signal_connect(G_OBJECT(moviesave), "activate",
G_CALLBACK(gtkui_movie_save), NULL);
g_signal_connect(G_OBJECT(movieload), "activate",
G_CALLBACK(gtkui_movie_load), NULL);
g_signal_connect(G_OBJECT(moviestop), "activate",
G_CALLBACK(gtkui_movie_stop), NULL);
g_signal_connect(G_OBJECT(quit), "activate",
G_CALLBACK(nst_schedule_quit), NULL);
// Emulator menu
g_signal_connect(G_OBJECT(cont), "activate",
G_CALLBACK(nst_play), NULL);
g_signal_connect(G_OBJECT(pause), "activate",
G_CALLBACK(nst_pause), NULL);
g_signal_connect(G_OBJECT(resetsoft), "activate",
G_CALLBACK(gtkui_cb_reset), gpointer(0));
g_signal_connect(G_OBJECT(resethard), "activate",
G_CALLBACK(gtkui_cb_reset), gpointer(1));
g_signal_connect(G_OBJECT(fullscreen), "activate",
G_CALLBACK(video_toggle_fullscreen), NULL);
g_signal_connect(G_OBJECT(diskflip), "activate",
G_CALLBACK(nst_flip_disk), NULL);
g_signal_connect(G_OBJECT(diskswitch), "activate",
G_CALLBACK(nst_switch_disk), NULL);
g_signal_connect(G_OBJECT(cheats), "activate",
G_CALLBACK(gtkui_cheats), NULL);
g_signal_connect(G_OBJECT(configuration), "activate",
G_CALLBACK(gtkui_config), NULL);
// Help menu
g_signal_connect(G_OBJECT(about), "activate",
G_CALLBACK(gtkui_about), NULL);
// Key translation
g_signal_connect(G_OBJECT(gtkwindow), "key-press-event",
G_CALLBACK(gtkui_cb_convert_key), NULL);
g_signal_connect(G_OBJECT(gtkwindow), "key-release-event",
G_CALLBACK(gtkui_cb_convert_key), NULL);
// Mouse translation
gtk_widget_add_events(GTK_WIDGET(drawingarea), GDK_BUTTON_PRESS_MASK);
gtk_widget_add_events(GTK_WIDGET(drawingarea), GDK_BUTTON_RELEASE_MASK);
g_signal_connect(G_OBJECT(drawingarea), "button-press-event",
G_CALLBACK(gtkui_cb_convert_mouse), NULL);
g_signal_connect(G_OBJECT(drawingarea), "button-release-event",
G_CALLBACK(gtkui_cb_convert_mouse), NULL);
gtk_widget_show_all(gtkwindow);
}
/* Creates menu item. Text and image are read from xconf. Action
* depends on @menu. If @menu is NULL, action is to execute external
* command. Otherwise it is to pop up @menu menu */
static GtkWidget *
menu_create_item(xconf *xc, GtkWidget *menu, menu_priv *m)
{
gchar *name, *fname, *iname, *action, *cmd;
GtkWidget *mi;
cmd = name = fname = action = iname = NULL;
XCG(xc, "name", &name, str);
mi = gtk_image_menu_item_new_with_label(name ? name : "");
gtk_container_set_border_width(GTK_CONTAINER(mi), 0);
XCG(xc, "image", &fname, str);
fname = expand_tilda(fname);
XCG(xc, "icon", &iname, str);
if (fname || iname)
{
GdkPixbuf *pb;
if ((pb = fb_pixbuf_new(iname, fname, m->icon_size, m->icon_size,
FALSE)))
{
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(mi),
gtk_image_new_from_pixbuf(pb));
g_object_unref(G_OBJECT(pb));
}
}
g_free(fname);
if (menu)
{
gtk_menu_item_set_submenu(GTK_MENU_ITEM(mi), menu);
goto done;
}
XCG(xc, "action", &action, str);
if (action)
{
action = expand_tilda(action);
g_signal_connect_swapped(G_OBJECT(mi), "activate",
(GCallback)run_app, action);
g_object_set_data_full(G_OBJECT(mi), "activate",
action, g_free);
goto done;
}
XCG(xc, "command", &cmd, str);
if (cmd)
{
/* XXX: implement command API */
#if 0
command *tmp;
for (tmp = commands; tmp->name; tmp++)
if (!g_ascii_strcasecmp(cmd, tmp->name))
{
g_signal_connect(G_OBJECT(mi), "activate",
(GCallback)run_command, tmp->cmd);
goto done;
}
#endif
}
done:
return mi;
}
static GtkWidget *
make_menubar (void)
{
GtkWidget *w, *menu;
GtkWidget *menubar = gtk_menu_bar_new ();
/* FIXME: add translatable string here */
w = gtk_menu_item_new_with_label ("Menu");
gtk_menu_shell_append (GTK_MENU_SHELL (menubar), w);
gtk_widget_show (GTK_WIDGET (w));
menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (w), menu);
w = gtk_image_menu_item_new_with_mnemonic (_("Select _Language..."));
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (w),
gtk_image_new_from_icon_name ("preferences-desktop-locale", GTK_ICON_SIZE_MENU));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), w);
gtk_widget_show (GTK_WIDGET (w));
g_signal_connect (G_OBJECT (w), "activate",
G_CALLBACK (activate_button),
"language_button");
w = gtk_image_menu_item_new_with_mnemonic (_("Select _Session..."));
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (w),
gtk_image_new_from_icon_name ("user-desktop", GTK_ICON_SIZE_MENU));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), w);
gtk_widget_show (GTK_WIDGET (w));
g_signal_connect (G_OBJECT (w), "activate",
G_CALLBACK (activate_button),
"session_button");
greeter_system_append_system_menu (menu);
/* Add a quit/disconnect item when in xdmcp mode or flexi mode */
/* Do note that the order is important, we always want "Quit" for
* flexi, even if not local (non-local xnest). and Disconnect
* only for xdmcp */
if ( ! ve_string_empty (g_getenv ("MDM_FLEXI_SERVER"))) {
w = gtk_image_menu_item_new_with_mnemonic (_("_Quit"));
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (w),
gtk_image_new_from_icon_name ("system-log-out", GTK_ICON_SIZE_MENU));
} else if (ve_string_empty (g_getenv ("MDM_IS_LOCAL"))) {
w = gtk_image_menu_item_new_with_mnemonic (_("D_isconnect"));
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (w),
gtk_image_new_from_icon_name ("system-log-out", GTK_ICON_SIZE_MENU));
} else {
w = NULL;
}
if (w != NULL) {
GtkWidget *sep;
/* add separator before the quit */
sep = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL (menu), sep);
gtk_widget_show (GTK_WIDGET (sep));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), w);
gtk_widget_show (GTK_WIDGET (w));
g_signal_connect (G_OBJECT (w), "activate",
G_CALLBACK (gtk_main_quit), NULL);
}
g_signal_connect (G_OBJECT(gtk_menu_item_get_submenu(
gtk_container_get_children(GTK_CONTAINER(menubar))->data)), "selection-done", G_CALLBACK (menubar_done), NULL);
return menubar;
}
/* Generate the menu bar */
static GtkWidget *
nc_menu_bar_gen ( void )
{
struct MenuBarEntry
{
const char * name;
const char * image;
void (*handler)();
};
struct MenuBar
{
const char * name;
const struct MenuBarEntry * entries;
int count;
};
static const struct MenuBarEntry
menu_file[] =
{
{ "_New", GTK_STOCK_NEW, NULL },
{ "_Open", GTK_STOCK_OPEN, NULL },
{ "_Save", GTK_STOCK_SAVE, NULL },
{ "Save _As", GTK_STOCK_SAVE_AS, NULL },
{ NULL, NULL, NULL },
{ "_Quit", GTK_STOCK_QUIT, NULL }
};
static const struct MenuBarEntry
menu_help[] =
{
{ "About", GTK_STOCK_ABOUT, NULL }
};
static const struct MenuBar
menu[] =
{
{ "_File", menu_file, sizeof(menu_file) / sizeof(struct MenuBarEntry) },
{ "_Help", menu_help, sizeof(menu_help) / sizeof(struct MenuBarEntry) }
};
GtkWidget * menubar;
GtkWidget * item;
GtkWidget * submenu;
GtkWidget * image;
int i, j;
/* Create menu */
menubar = gtk_menu_bar_new();
/* Loop through each menu */
for( i = 0; i < sizeof(menu) / sizeof(struct MenuBar); i++ )
{
/* Create the item */
item = gtk_menu_item_new_with_mnemonic( menu[i].name );
gtk_container_add( GTK_CONTAINER(menubar), item );
/* Create submenu */
submenu = gtk_menu_new();
gtk_menu_item_set_submenu( GTK_MENU_ITEM(item), submenu );
/* Create items */
for( j = 0; j < menu[i].count; j++ )
{
const struct MenuBarEntry * f = &menu[i].entries[j];
/* Is it NULL? If so, it's a separator */
if( !f->name && !f->image )
{
item = gtk_separator_menu_item_new();
gtk_widget_set_sensitive( item, FALSE );
gtk_container_add( GTK_CONTAINER(submenu), item );
continue;
}
/* Create item */
item = gtk_image_menu_item_new_with_mnemonic( f->name );
gtk_container_add( GTK_CONTAINER(submenu), item );
/* Create image (if applicable) */
if( f->image )
{
image = gtk_image_new_from_stock( f->image, GTK_ICON_SIZE_MENU );
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(item), image );
}
/* Set handler (if applicable) */
if( f->handler )
g_signal_connect( G_OBJECT(item), "activate", G_CALLBACK(f->handler), NULL );
}
}
/* Show all */
gtk_widget_show_all( menubar );
/* Return it */
return menubar;
}
/** \brief Show satellite popup menu.
* \param sat Pointer to the satellite data.
* \param qth The current location.
* \param pview The GtkPolarView widget.
* \param event The mouse-click related event info
* \param toplevel The toplevel window or NULL.
*
*/
void
gtk_polar_view_popup_exec (sat_t *sat,
qth_t *qth,
GtkPolarView *pview,
GdkEventButton *event,
GtkWidget *toplevel)
{
GtkWidget *menu;
GtkWidget *menuitem;
GtkWidget *label;
GtkWidget *image;
gchar *buff;
sat_obj_t *obj = NULL;
gint *catnum;
menu = gtk_menu_new ();
/* first menu item is the satellite name, centered */
menuitem = gtk_image_menu_item_new ();
label = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5);
buff = g_strdup_printf ("<b>%s</b>", sat->nickname);
gtk_label_set_markup (GTK_LABEL (label), buff);
g_free (buff);
gtk_container_add (GTK_CONTAINER (menuitem), label);
image = gtk_image_new_from_stock (GTK_STOCK_INFO, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
/* attach data to menuitem and connect callback */
g_object_set_data (G_OBJECT (menuitem), "sat", sat);
g_object_set_data (G_OBJECT (menuitem), "qth", qth);
g_signal_connect (menuitem, "activate", G_CALLBACK (show_sat_info_menu_cb), toplevel);
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
/* separator */
menuitem = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
/* next pass and predict passes */
menuitem = gtk_image_menu_item_new_with_label (_("Show next pass"));
image = gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_FILL, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
g_object_set_data (G_OBJECT (menuitem), "sat", sat);
g_object_set_data (G_OBJECT (menuitem), "qth", qth);
g_signal_connect (menuitem, "activate", G_CALLBACK (show_next_pass_cb), pview);
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
menuitem = gtk_image_menu_item_new_with_label (_("Future passes"));
image = gtk_image_new_from_stock (GTK_STOCK_INDEX, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
g_object_set_data (G_OBJECT (menuitem), "sat", sat);
g_object_set_data (G_OBJECT (menuitem), "qth", qth);
g_signal_connect (menuitem, "activate", G_CALLBACK (show_next_passes_cb), pview);
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
/* separator */
menuitem = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
/* get sat obj since we'll need it for the remaining items */
catnum = g_new0 (gint, 1);
*catnum = sat->tle.catnr;
obj = SAT_OBJ (g_hash_table_lookup (pview->obj, catnum));
g_free (catnum);
/* show track */
menuitem = gtk_check_menu_item_new_with_label (_("Sky track"));
g_object_set_data (G_OBJECT (menuitem), "sat", sat);
g_object_set_data (G_OBJECT (menuitem), "qth", qth);
g_object_set_data (G_OBJECT (menuitem), "obj", obj);
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menuitem), obj->showtrack);
g_signal_connect (menuitem, "activate", G_CALLBACK (track_toggled), pview);
/* disable menu item if satellite is geostationary */
if (sat->otype == ORBIT_TYPE_GEO)
gtk_widget_set_sensitive (menuitem, FALSE);
/* target */
/* menuitem = gtk_check_menu_item_new_with_label (_("Set as target")); */
/* g_object_set_data (G_OBJECT (menuitem), "sat", sat); */
/* g_object_set_data (G_OBJECT (menuitem), "qth", qth); */
/* g_object_set_data (G_OBJECT (menuitem), "obj", obj); */
/* gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem); */
/* gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menuitem), obj->istarget); */
/* g_signal_connect (menuitem, "activate", G_CALLBACK (target_toggled), pview); */
gtk_widget_show_all (menu);
/* Note: event can be NULL here when called from view_onPopupMenu;
* gdk_event_get_time() accepts a NULL argument */
gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL,
(event != NULL) ? event->button : 0,
gdk_event_get_time ((GdkEvent*) event));
}
static void
gxk_menu_item_set_property (GObject *object,
guint param_id,
const GValue *value,
GParamSpec *pspec)
{
GxkMenuItem *self = GXK_MENU_ITEM (object);
GtkMenuItem *mitem = GTK_MENU_ITEM (object);
GtkBin *bin = GTK_BIN (self);
switch (param_id)
{
const gchar *string, *path;
gchar *accel;
gboolean vbool;
case MENU_ITEM_PROP_ULINE_LABEL:
if (bin->child)
gtk_container_remove (GTK_CONTAINER (self), bin->child);
string = g_value_get_string (value);
if (string)
{
GtkWidget *label = g_object_new (GTK_TYPE_ACCEL_LABEL,
"visible", TRUE,
"label", string,
"use-underline", TRUE,
"xalign", 0.0,
"accel-widget", self,
"parent", self,
NULL);
if (g_object_get_long (self, "gxk-title-style"))
gxk_widget_modify_as_title (label);
}
break;
case MENU_ITEM_PROP_STOCK_IMAGE:
string = g_value_get_string (value);
if (string)
{
GtkWidget *image = gtk_image_new_from_stock (string, GXK_ICON_SIZE_MENU);
if (image)
{
gtk_widget_show (image);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (self), image);
}
}
break;
case MENU_ITEM_PROP_KEEP_MENUBAR_IMAGE:
vbool = g_value_get_boolean (value);
g_object_set_long (self, "gxk-keep-menubar-image", vbool);
menu_item_keep_menubar_image (self);
break;
case MENU_ITEM_PROP_RIGHT_JUSTIFY:
gtk_menu_item_set_right_justified (mitem, g_value_get_boolean (value));
break;
case MENU_ITEM_PROP_TITLE_STYLE:
if (g_value_get_boolean (value))
{
gxk_widget_modify_as_title (GTK_WIDGET (self));
g_object_set_long (self, "gxk-title-style", 1);
if (bin->child)
gxk_widget_modify_as_title (bin->child);
}
break;
case MENU_ITEM_PROP_ACCEL_PATH:
path = g_value_get_string (value);
gtk_menu_item_set_accel_path (mitem, path);
accel = g_object_get_data (self, "gxk-menu-item-accel");
goto setup_accel;
case MENU_ITEM_PROP_ACCEL:
accel = g_value_dup_string (value);
g_object_set_data_full (self, "gxk-menu-item-accel", accel, g_free);
path = mitem->accel_path;
setup_accel:
if (accel && path)
{
GdkModifierType mods = 0;
guint keyval = 0;
if (accel)
gtk_accelerator_parse (accel, &keyval, &mods);
keyval = keyval != GDK_VoidSymbol ? keyval : 0;
gtk_accel_map_add_entry (path, keyval, mods);
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (self, param_id, pspec);
break;
}
}
bool wxMenu::GtkAppend(wxMenuItem *mitem, int pos)
{
GtkWidget *menuItem;
GtkWidget* prevRadio = m_prevRadio;
m_prevRadio = NULL;
switch (mitem->GetKind())
{
case wxITEM_SEPARATOR:
menuItem = gtk_separator_menu_item_new();
break;
case wxITEM_CHECK:
menuItem = gtk_check_menu_item_new_with_label("");
break;
case wxITEM_RADIO:
{
GSList* group = NULL;
if (prevRadio)
group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(prevRadio));
menuItem = gtk_radio_menu_item_new_with_label(group, "");
m_prevRadio = menuItem;
}
break;
default:
wxFAIL_MSG("unexpected menu item kind");
// fall through
case wxITEM_NORMAL:
const wxBitmap& bitmap = mitem->GetBitmap();
const char* stockid;
if (bitmap.IsOk())
{
// always use pixbuf, because pixmap mask does not
// work with disabled images in some themes
GtkWidget* image = gtk_image_new_from_pixbuf(bitmap.GetPixbuf());
menuItem = gtk_image_menu_item_new_with_label("");
gtk_widget_show(image);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menuItem), image);
}
else if ((stockid = wxGetStockGtkID(mitem->GetId())) != NULL)
// use stock bitmap for this item if available on the assumption
// that it never hurts to follow GTK+ conventions more closely
menuItem = gtk_image_menu_item_new_from_stock(stockid, NULL);
else
menuItem = gtk_menu_item_new_with_label("");
break;
}
mitem->SetMenuItem(menuItem);
gtk_menu_shell_insert(GTK_MENU_SHELL(m_menu), menuItem, pos);
gtk_widget_show( menuItem );
if ( !mitem->IsSeparator() )
{
mitem->SetGtkLabel();
g_signal_connect (menuItem, "select",
G_CALLBACK(menuitem_select), mitem);
g_signal_connect (menuItem, "deselect",
G_CALLBACK(menuitem_deselect), mitem);
if ( mitem->IsSubMenu() && mitem->GetKind() != wxITEM_RADIO && mitem->GetKind() != wxITEM_CHECK )
{
gtk_menu_item_set_submenu( GTK_MENU_ITEM(menuItem), mitem->GetSubMenu()->m_menu );
gtk_widget_show( mitem->GetSubMenu()->m_menu );
}
else
{
g_signal_connect(menuItem, "can_activate_accel",
G_CALLBACK(can_activate_accel), this);
g_signal_connect (menuItem, "activate",
G_CALLBACK(menuitem_activate),
mitem);
}
}
return true;
}
static GtkWidget *create_popup_menu(void)
{
GtkWidget *item, *menu, *image;
menu = gtk_menu_new();
image = gtk_image_new_from_stock(GTK_STOCK_NEW, GTK_ICON_SIZE_MENU);
gtk_widget_show(image);
item = gtk_image_menu_item_new_with_mnemonic(_("New Project"));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
g_signal_connect((gpointer) item, "activate", G_CALLBACK(on_new_project), NULL);
popup_items.new_project = item;
image = gtk_image_new_from_stock(GTK_STOCK_DELETE, GTK_ICON_SIZE_MENU);
gtk_widget_show(image);
item = gtk_image_menu_item_new_with_mnemonic(_("Delete Project"));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
g_signal_connect((gpointer) item, "activate", G_CALLBACK(on_delete_project), NULL);
popup_items.delete_project = item;
item = gtk_separator_menu_item_new();
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
image = gtk_image_new_from_stock(GTK_STOCK_ADD, GTK_ICON_SIZE_MENU);
gtk_widget_show(image);
item = gtk_image_menu_item_new_with_mnemonic(_("Add File"));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
g_signal_connect((gpointer) item, "activate", G_CALLBACK(on_add_file), NULL);
popup_items.add_file = item;
image = gtk_image_new_from_stock(GTK_STOCK_REMOVE, GTK_ICON_SIZE_MENU);
gtk_widget_show(image);
item = gtk_image_menu_item_new_with_mnemonic(_("Remove File"));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
g_signal_connect((gpointer) item, "activate", G_CALLBACK(on_remove_files), NULL);
popup_items.remove_files = item;
item = gtk_separator_menu_item_new();
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
image = gtk_image_new_from_stock(GTK_STOCK_PREFERENCES, GTK_ICON_SIZE_MENU);
gtk_widget_show(image);
item = gtk_image_menu_item_new_with_mnemonic(_("Preferences"));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
g_signal_connect((gpointer) item, "activate", G_CALLBACK(on_preferences), NULL);
popup_items.preferences = item;
item = gtk_separator_menu_item_new();
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
image = gtk_image_new_from_stock(GTK_STOCK_FIND, GTK_ICON_SIZE_MENU);
gtk_widget_show(image);
item = gtk_image_menu_item_new_with_mnemonic(_("Find in Project"));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
g_signal_connect((gpointer) item, "activate", G_CALLBACK(on_find_in_project), NULL);
popup_items.find_in_files = item;
item = gtk_separator_menu_item_new();
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
item = gtk_image_menu_item_new_with_mnemonic(_("H_ide Sidebar"));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item),
gtk_image_new_from_stock("gtk-close", GTK_ICON_SIZE_MENU));
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
g_signal_connect_swapped((gpointer) item, "activate",
G_CALLBACK(keybindings_send_command),
GINT_TO_POINTER(GEANY_KEYS_VIEW_SIDEBAR));
return menu;
}
XttTblGtk::XttTblGtk(GtkWidget* a_parent_wid, void* a_parent_ctx,
sevcli_tCtx a_sevcli, sevcli_sHistItem* itemlist, int item_cnt)
: XttTbl(a_parent_ctx, a_sevcli), parent_wid(a_parent_wid)
{
int sts;
pwr_tFileName fname;
toplevel = (GtkWidget*)g_object_new(GTK_TYPE_WINDOW, "default-height", 700,
"default-width", 500, "title", "SevXtt Navigator", NULL);
g_signal_connect(toplevel, "delete_event", G_CALLBACK(delete_event), this);
g_signal_connect(toplevel, "destroy", G_CALLBACK(destroy_event), this);
g_signal_connect(
toplevel, "focus-in-event", G_CALLBACK(xtttbl_focus_in_event), this);
CoWowGtk::SetWindowIcon(toplevel);
GtkWidget* vbox = gtk_vbox_new(FALSE, 0);
// Menu
// Accelerators
GtkAccelGroup* accel_g
= (GtkAccelGroup*)g_object_new(GTK_TYPE_ACCEL_GROUP, NULL);
gtk_window_add_accel_group(GTK_WINDOW(toplevel), accel_g);
GtkMenuBar* menu_bar = (GtkMenuBar*)g_object_new(GTK_TYPE_MENU_BAR, NULL);
// File entry
GtkWidget* file_print = gtk_image_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("_Print"));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(file_print),
gtk_image_new_from_stock("gtk-print", GTK_ICON_SIZE_MENU));
g_signal_connect(file_print, "activate", G_CALLBACK(activate_print), this);
GtkWidget* file_login
= gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Login"));
g_signal_connect(file_login, "activate", G_CALLBACK(activate_login), this);
GtkWidget* file_logout
= gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("Log_Out"));
g_signal_connect(file_logout, "activate", G_CALLBACK(activate_logout), this);
GtkWidget* file_close
= gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, accel_g);
g_signal_connect(file_close, "activate", G_CALLBACK(activate_close), this);
GtkMenu* file_menu = (GtkMenu*)g_object_new(GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_print);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_login);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_logout);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_close);
GtkWidget* file = gtk_menu_item_new_with_mnemonic("_File");
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), GTK_WIDGET(file_menu));
// Functions entry
GtkWidget* functions_opensevhist = gtk_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("_Open Process History"));
g_signal_connect(functions_opensevhist, "activate",
G_CALLBACK(activate_opensevhist), this);
gtk_widget_add_accelerator(functions_opensevhist, "activate", accel_g, 'g',
GdkModifierType(GDK_CONTROL_MASK), GTK_ACCEL_VISIBLE);
GtkWidget* functions_command
= gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("Co_mmand"));
g_signal_connect(
functions_command, "activate", G_CALLBACK(activate_command), this);
gtk_widget_add_accelerator(functions_command, "activate", accel_g, 'b',
GdkModifierType(GDK_CONTROL_MASK), GTK_ACCEL_VISIBLE);
GtkWidget* functions_delete_item = gtk_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("_Delete Item"));
g_signal_connect(functions_delete_item, "activate",
G_CALLBACK(activate_delete_item), this);
GtkMenu* functions_menu = (GtkMenu*)g_object_new(GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_opensevhist);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_command);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_delete_item);
GtkWidget* functions
= gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Functions"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), functions);
gtk_menu_item_set_submenu(
GTK_MENU_ITEM(functions), GTK_WIDGET(functions_menu));
// View menu
GtkWidget* view_tree_layout = gtk_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("_Tree Layout"));
g_signal_connect(
view_tree_layout, "activate", G_CALLBACK(activate_tree_layout), this);
GtkWidget* view_list_layout = gtk_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("_List Layout"));
g_signal_connect(
view_list_layout, "activate", G_CALLBACK(activate_list_layout), this);
GtkWidget* view_zoom_in = gtk_image_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("Zoom _In"));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(view_zoom_in),
gtk_image_new_from_stock("gtk-zoom-in", GTK_ICON_SIZE_MENU));
g_signal_connect(
view_zoom_in, "activate", G_CALLBACK(activate_zoom_in), this);
gtk_widget_add_accelerator(view_zoom_in, "activate", accel_g, 'i',
GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget* view_zoom_out = gtk_image_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("Zoom _Out"));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(view_zoom_out),
gtk_image_new_from_stock("gtk-zoom-out", GTK_ICON_SIZE_MENU));
g_signal_connect(
view_zoom_out, "activate", G_CALLBACK(activate_zoom_out), this);
gtk_widget_add_accelerator(view_zoom_out, "activate", accel_g, 'o',
GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget* view_zoom_reset = gtk_image_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("Zoom _Reset"));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(view_zoom_reset),
gtk_image_new_from_stock("gtk-zoom-100", GTK_ICON_SIZE_MENU));
g_signal_connect(
view_zoom_reset, "activate", G_CALLBACK(activate_zoom_reset), this);
GtkMenu* view_menu = (GtkMenu*)g_object_new(GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_tree_layout);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_list_layout);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_in);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_out);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_reset);
GtkWidget* view
= gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_View"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), view);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(view), GTK_WIDGET(view_menu));
// Help entry
GtkWidget* help_overview = gtk_image_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("_Overview"));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(help_overview),
gtk_image_new_from_stock("gtk-help", GTK_ICON_SIZE_MENU));
g_signal_connect(help_overview, "activate", G_CALLBACK(activate_help), this);
gtk_widget_add_accelerator(help_overview, "activate", accel_g, 'h',
GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget* help_project
= gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Project"));
g_signal_connect(
help_project, "activate", G_CALLBACK(activate_help_project), this);
GtkWidget* help_proview = gtk_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("_About Proview"));
g_signal_connect(
help_proview, "activate", G_CALLBACK(activate_help_proview), this);
GtkMenu* help_menu = (GtkMenu*)g_object_new(GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_overview);
gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_project);
gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_proview);
GtkWidget* help
= gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Help"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), help);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), GTK_WIDGET(help_menu));
// Toolbar
GtkToolbar* tools = (GtkToolbar*)g_object_new(GTK_TYPE_TOOLBAR, NULL);
GtkWidget* tools_opensevhist = gtk_button_new();
dcli_translate_filename(fname, "$pwr_exe/xtt_meth_trend.png");
gtk_container_add(
GTK_CONTAINER(tools_opensevhist), gtk_image_new_from_file(fname));
g_signal_connect(
tools_opensevhist, "clicked", G_CALLBACK(activate_opensevhist), this);
g_object_set(tools_opensevhist, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget(tools, tools_opensevhist,
CoWowGtk::translate_utf8("Open history item"), "");
GtkWidget* tools_zoom_in = gtk_button_new();
dcli_translate_filename(fname, "$pwr_exe/xtt_zoom_in.png");
gtk_container_add(
GTK_CONTAINER(tools_zoom_in), gtk_image_new_from_file(fname));
g_signal_connect(
tools_zoom_in, "clicked", G_CALLBACK(activate_zoom_in), this);
g_object_set(tools_zoom_in, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget(
tools, tools_zoom_in, CoWowGtk::translate_utf8("Zoom in"), "");
GtkWidget* tools_zoom_out = gtk_button_new();
dcli_translate_filename(fname, "$pwr_exe/xtt_zoom_out.png");
gtk_container_add(
GTK_CONTAINER(tools_zoom_out), gtk_image_new_from_file(fname));
g_signal_connect(
tools_zoom_out, "clicked", G_CALLBACK(activate_zoom_out), this);
g_object_set(tools_zoom_out, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget(
tools, tools_zoom_out, CoWowGtk::translate_utf8("Zoom out"), "");
GtkWidget* tools_zoom_reset = gtk_button_new();
dcli_translate_filename(fname, "$pwr_exe/xtt_zoom_reset.png");
gtk_container_add(
GTK_CONTAINER(tools_zoom_reset), gtk_image_new_from_file(fname));
g_signal_connect(
tools_zoom_reset, "clicked", G_CALLBACK(activate_zoom_reset), this);
g_object_set(tools_zoom_reset, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget(
tools, tools_zoom_reset, CoWowGtk::translate_utf8("Zoom reset"), "");
// Statusbar and cmd input
GtkWidget* statusbar = gtk_hbox_new(FALSE, 0);
msg_label = gtk_label_new("");
gtk_widget_set_size_request(msg_label, -1, 25);
cmd_prompt = gtk_label_new("xtt > ");
gtk_widget_set_size_request(cmd_prompt, -1, 25);
cmd_recall = new CoWowRecall();
cmd_entry = new CoWowEntryGtk(cmd_recall);
cmd_input = cmd_entry->widget();
gtk_widget_set_size_request(cmd_input, -1, 25);
g_signal_connect(
cmd_input, "activate", G_CALLBACK(valchanged_cmd_input), this);
gtk_box_pack_start(GTK_BOX(statusbar), msg_label, FALSE, FALSE, 20);
gtk_box_pack_start(GTK_BOX(statusbar), cmd_prompt, FALSE, FALSE, 20);
gtk_box_pack_start(GTK_BOX(statusbar), cmd_input, TRUE, TRUE, 20);
gtk_widget_show_all(statusbar);
tblnav
= new TblNavGtk(this, toplevel, itemlist, item_cnt, &brow_widget, &sts);
tblnav->message_cb = &XttTbl::message;
tblnav->is_authorized_cb = &XttTbl::is_authorized;
tblnav->command_cb = &XttTbl::command_cb;
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(menu_bar), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(tools), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(brow_widget), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(statusbar), FALSE, FALSE, 3);
gtk_container_add(GTK_CONTAINER(toplevel), vbox);
gtk_widget_show_all(toplevel);
g_object_set(cmd_prompt, "visible", FALSE, NULL);
g_object_set(cmd_input, "visible", FALSE, NULL);
// Create help window
CoXHelp* xhelp = new CoXHelpGtk(toplevel, this, xhelp_eUtility_Xtt, &sts);
CoXHelp::set_default(xhelp);
wow = new CoWowGtk(toplevel);
if (!is_authorized(pwr_mAccess_AllSev, 0))
open_login();
if (!quiet) {
if (cologin)
// Set login window as parent to warranty as focus is left to parent.
((CoWowGtk*)wow)->SetParent(((CoLoginGtk*)cologin)->widgets.toplevel);
wow->DisplayWarranty();
if (cologin)
((CoWowGtk*)wow)->SetParent(toplevel);
}
}
static gboolean
xfdesktop_volume_icon_populate_context_menu(XfdesktopIcon *icon,
GtkWidget *menu)
{
XfdesktopVolumeIcon *volume_icon = XFDESKTOP_VOLUME_ICON(icon);
GVolume *volume = volume_icon->priv->volume;
GtkWidget *mi, *img;
GMount *mount;
const gchar *icon_name, *icon_label;
icon_name = GTK_STOCK_OPEN;
img = gtk_image_new_from_stock(GTK_STOCK_OPEN, GTK_ICON_SIZE_MENU);
gtk_widget_show(img);
mi = gtk_image_menu_item_new_with_mnemonic(_("_Open"));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(mi), img);
gtk_widget_show(mi);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);
g_signal_connect_swapped(G_OBJECT(mi), "activate",
G_CALLBACK(xfdesktop_icon_activated), icon);
mi = gtk_separator_menu_item_new();
gtk_widget_show(mi);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);
mount = g_volume_get_mount(volume);
if(mount && g_volume_can_eject(volume)) {
icon_name = "media-eject";
icon_label = _("E_ject Volume");
xfdesktop_volume_icon_add_context_menu_option(icon, icon_name, icon_label,
menu, G_CALLBACK(xfdesktop_volume_icon_menu_eject));
}
if(mount && g_mount_can_unmount(mount)) {
icon_name = NULL;
icon_label = _("_Unmount Volume");
xfdesktop_volume_icon_add_context_menu_option(icon, icon_name, icon_label,
menu, G_CALLBACK(xfdesktop_volume_icon_menu_unmount));
}
if(!mount && g_volume_can_mount(volume)) {
icon_name = NULL;
icon_label = _("_Mount Volume");
xfdesktop_volume_icon_add_context_menu_option(icon, icon_name, icon_label,
menu, G_CALLBACK(xfdesktop_volume_icon_menu_mount));
}
if(mount)
g_object_unref(mount);
mi = gtk_separator_menu_item_new();
gtk_widget_show(mi);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);
icon_name = GTK_STOCK_PROPERTIES;
icon_label = _("P_roperties...");
if(!volume_icon->priv->file_info)
xfdesktop_volume_icon_add_context_menu_option(icon, icon_name, icon_label,
menu, NULL);
else {
xfdesktop_volume_icon_add_context_menu_option(icon, icon_name, icon_label,
menu, G_CALLBACK(xfdesktop_volume_icon_menu_properties));
}
return TRUE;
}
static void
deskmenu_construct_item (DeskmenuObject *dm_object)
{
DeskmenuItem *item = dm_object->current_item;
GtkWidget *menu_item, *submenu;
gchar *name, *icon, *command, *vpicon;
gboolean images;
gint w, h;
//constructs the items in menu
switch (item->type)
{
case DESKMENU_ITEM_LAUNCHER:
if (item->name_exec)
{
GtkWidget *label;
GHook *hook;
name = g_strstrip (item->name->str);
menu_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 (menu_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 (item->name)
name = g_strstrip (item->name->str);
else
name = "";
menu_item = gtk_image_menu_item_new_with_mnemonic (name);
}
if (item->icon)
{
icon = g_strstrip (item->icon->str);
if (item->icon_file)
{
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM(menu_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 (menu_item),
gtk_image_new_from_icon_name (icon, GTK_ICON_SIZE_MENU));
}
}
if (item->command_pipe)
{
command = g_strstrip (item->command->str);
if (item->cache_output)
{
g_object_set_data(G_OBJECT(menu_item), "cached", g_strdup("yes"));
}
else
{
g_object_set_data(G_OBJECT(menu_item), "cached", g_strdup("no"));
}
g_object_set_data(G_OBJECT(menu_item), "menu", dm_object);
g_signal_connect (G_OBJECT (menu_item), "activate",
G_CALLBACK (pipe_menu_recreate), g_strdup(command));
submenu = gtk_menu_new();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), submenu);
}
else
{
if (item->command)
{
command = g_strstrip (item->command->str);
g_signal_connect (G_OBJECT (menu_item), "activate",
G_CALLBACK (launcher_activated), g_strdup (command));
}
}
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu),
menu_item);
break;
#if HAVE_WNCK
case DESKMENU_ITEM_WINDOWLIST:
menu_item = gtk_image_menu_item_new_with_mnemonic ("_Windows");
images = FALSE;
gboolean this_vp = FALSE;
gboolean mini_only = FALSE;
if (item->icon)
{
images = TRUE;
icon = g_strstrip (item->icon->str);
if (item->icon_file)
{
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM(menu_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 (menu_item),
gtk_image_new_from_icon_name (icon,
GTK_ICON_SIZE_MENU)
);
}
}
if (item->thisvp
&& strcmp (g_strstrip (item->thisvp->str), "true") == 0)
this_vp = TRUE;
if (item->mini_only
&& strcmp (g_strstrip (item->mini_only->str), "true") == 0)
mini_only = TRUE;
g_object_set_data(G_OBJECT(menu_item), "windowlist", deskmenu_windowlist_initialize (images, this_vp, mini_only));
g_signal_connect (G_OBJECT (menu_item), "activate",
G_CALLBACK (refresh_windowlist_item), NULL);
submenu = gtk_menu_new();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), submenu);
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu), menu_item);
break;
case DESKMENU_ITEM_DESKTOPLIST:
menu_item = gtk_image_menu_item_new_with_mnemonic ("_Desktops");
gboolean file;
images = FALSE;
file = FALSE;
if (item->icon)
{
images = TRUE;
icon = g_strstrip (item->icon->str);
if (item->icon_file)
{
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM(menu_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 (menu_item),
gtk_image_new_from_icon_name (icon,
GTK_ICON_SIZE_MENU)
);
}
}
if (item->vpicon)
{
vpicon = g_strstrip (parse_expand_tilde(item->vpicon->str));
if (item->vpicon_file)
{
file = TRUE;
}
}
else
{
vpicon = "";
}
g_object_set_data(G_OBJECT(menu_item), "dplist", deskmenu_dplist_initialize (images, file, vpicon));
g_signal_connect (G_OBJECT (menu_item), "activate",
G_CALLBACK (refresh_desktoplist_item), NULL);
submenu = gtk_menu_new();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), submenu);
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu), menu_item);
break;
case DESKMENU_ITEM_VIEWPORTLIST:
menu_item = gtk_image_menu_item_new_with_mnemonic ("_Viewports");
gboolean wrap;
wrap = FALSE;
images = FALSE;
file = FALSE;
if (item->wrap && strcmp (g_strstrip (item->wrap->str), "true") == 0)
wrap = TRUE;
if (item->icon)
{
images = TRUE;
icon = g_strstrip (item->icon->str);
if (item->icon_file)
{
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM(menu_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 (menu_item),
gtk_image_new_from_icon_name (icon,
GTK_ICON_SIZE_MENU)
);
}
}
if (item->vpicon)
{
vpicon = g_strstrip (parse_expand_tilde(item->vpicon->str));
if (item->vpicon_file)
{
file = TRUE;
}
}
else
{
vpicon = "";
}
g_object_set_data(G_OBJECT(menu_item), "vplist", deskmenu_vplist_initialize (wrap, images, file, vpicon));
g_signal_connect (G_OBJECT (menu_item), "activate",
G_CALLBACK (refresh_viewportlist_item), NULL);
submenu = gtk_menu_new();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), submenu);
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu), menu_item);
break;
#endif
case DESKMENU_ITEM_RELOAD:
menu_item = gtk_image_menu_item_new_with_mnemonic ("Reload");
if (item->icon)
{
icon = g_strstrip (item->icon->str);
if (item->icon_file)
{
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM(menu_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 (menu_item),
gtk_image_new_from_icon_name (icon,
GTK_ICON_SIZE_MENU)
);
}
}
g_signal_connect (G_OBJECT (menu_item), "activate",
G_CALLBACK (quit), NULL);
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu),
menu_item);
break;
case DESKMENU_ITEM_DOCUMENTS:
menu_item = gtk_image_menu_item_new_with_mnemonic ("Recent Doc_uments");
gint limit, age;
gchar *sort_type;
images = FALSE;
sort_type = "least used";
age = 25;
if (item->icon)
{
images = TRUE;
icon = g_strstrip (item->icon->str);
if (item->icon_file)
{
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM(menu_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 (menu_item),
gtk_image_new_from_icon_name (icon,
GTK_ICON_SIZE_MENU)
);
}
}
if (item->age)
{
age = atoi(g_strstrip (item->age->str));
}
if (item->sort_type)
{
sort_type = g_strstrip (item->sort_type->str);
}
if (item->quantity)
{
limit = atoi(g_strstrip (item->quantity->str));
}
else
{
limit = -1;
}
if (item->command)
{
command = g_strstrip (item->command->str);
}
else
{
command = g_strdup ("xdg-open");
}
GtkWidget *docs = make_recent_documents_list(images, command, limit, age, sort_type);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item),
docs);
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu),
menu_item);
break;
default:
break;
}
}
void fx_head_popup_statemenu_func(GtkWidget* widget
, GdkEventButton* event , gpointer data)
{
FxMain* fxmain = (FxMain*)data;
User *user = fxmain->user;
GtkWidget *item;
GtkWidget *img;
GtkWidget *separator;
GdkCursor *cursor;
GtkWidget *presence_menu = gtk_menu_new();
if(event->type == GDK_ENTER_NOTIFY) {
cursor = gdk_cursor_new (GDK_HAND2);
gdk_window_set_cursor(widget->window , cursor);
return;
}
if(event->type == GDK_LEAVE_NOTIFY) {
cursor = gdk_cursor_new (GDK_LEFT_PTR);
gdk_window_set_cursor(widget->window , cursor);
return;
}
fx_head_create_presence_item(P_ONLINE , _("Online") , presence_menu , fxmain);
fx_head_create_presence_item(P_AWAY , _("Leave") , presence_menu , fxmain);
fx_head_create_presence_item(P_BUSY , _("Busy") , presence_menu , fxmain);
fx_head_create_presence_item(P_HIDDEN , _("Hide") , presence_menu , fxmain);
fx_head_create_presence_item(P_OFFLINE , _("Offline") , presence_menu , fxmain);
separator = gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(presence_menu) , separator);
fx_head_create_presence_item(P_OUTFORLUNCH , _("Eating out") , presence_menu , fxmain);
fx_head_create_presence_item(P_DONOTDISTURB , _("Do Not Disturb") , presence_menu , fxmain);
fx_head_create_presence_item(P_MEETING , _("Meeting") , presence_menu , fxmain);
fx_head_create_presence_item(P_ONTHEPHONE , _("Calling") , presence_menu , fxmain);
separator = gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(presence_menu) , separator);
item = gtk_check_menu_item_new_with_label(_("Receive SMS"));
if(strcmp(user->smsOnLineStatus , "0.00:00:00") &&
strcmp(user->smsOnLineStatus , "0.0:0:0"))
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item) , FALSE);
else
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item) , TRUE);
gtk_menu_shell_append(GTK_MENU_SHELL(presence_menu) , item);
g_signal_connect(item , "activate" , G_CALLBACK(fx_head_set_sms_clicked) , fxmain);
item = gtk_image_menu_item_new_with_label(_("Modify Profile"));
img = gtk_image_new_from_file(SKIN_DIR"edit.png");
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item) , img);
gtk_menu_shell_append(GTK_MENU_SHELL(presence_menu) , item);
g_signal_connect(item , "activate" , G_CALLBACK(fx_bottom_on_setting_clicked) , fxmain);
item = gtk_image_menu_item_new_with_label(_("Exit OpenFetion "));
img = gtk_image_new_from_file(SKIN_DIR"exit.png");
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item) , img);
gtk_menu_shell_append(GTK_MENU_SHELL(presence_menu) , item);
g_signal_connect(item , "activate" , G_CALLBACK(fx_main_destroy) , fxmain);
gtk_widget_show_all(presence_menu);
gtk_menu_popup(GTK_MENU(presence_menu) , NULL , NULL , NULL , NULL
, (event != NULL) ? event->button : 0 , gdk_event_get_time((GdkEvent*)event));
}
GtkWidget *
mate_panel_applet_create_menu (AppletInfo *info)
{
GtkWidget *menu;
GtkWidget *menuitem;
GList *l;
PanelWidget *panel_widget;
gboolean added_anything = FALSE;
panel_widget = mate_panel_applet_get_panel_widget (info);
menu = g_object_ref_sink (gtk_menu_new ());
/* connect the show & deactivate signal, so that we can "disallow" and
* "re-allow" autohide when the menu is shown/deactivated.
*/
g_signal_connect (menu, "show",
G_CALLBACK (applet_menu_show), info);
g_signal_connect (menu, "deactivate",
G_CALLBACK (applet_menu_deactivate), info);
for (l = info->user_menu; l; l = l->next) {
AppletUserMenu *user_menu = l->data;
if (user_menu->is_enabled_func && !user_menu->is_enabled_func ())
continue;
add_to_submenus (info, "", user_menu->name, user_menu,
menu, info->user_menu);
added_anything = TRUE;
}
if (!panel_lockdown_get_locked_down ()) {
GtkWidget *image;
gboolean locked;
gboolean lockable;
gboolean movable;
gboolean removable;
lockable = mate_panel_applet_lockable (info);
movable = mate_panel_applet_can_freely_move (info);
removable = panel_profile_id_lists_are_writable ();
locked = panel_widget_get_applet_locked (panel_widget, info->widget);
if (added_anything) {
menuitem = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
}
menuitem = gtk_image_menu_item_new_with_mnemonic (_("_Remove From Panel"));
image = gtk_image_new_from_icon_name ("list-remove",
GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem),
image);
g_signal_connect (menuitem, "activate",
G_CALLBACK (applet_remove_callback), info);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_set_sensitive (menuitem, (!locked || lockable) && removable);
menuitem = gtk_menu_item_new_with_mnemonic (_("_Move"));
g_signal_connect (menuitem, "activate",
G_CALLBACK (move_applet_callback), info);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_set_sensitive (menuitem, !locked && movable);
g_assert (info->move_item == NULL);
info->move_item = menuitem;
g_object_add_weak_pointer (G_OBJECT (menuitem),
(gpointer *) &info->move_item);
menuitem = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
menuitem = gtk_check_menu_item_new_with_mnemonic (_("Loc_k To Panel"));
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menuitem),
locked);
g_signal_connect (menuitem, "toggled",
G_CALLBACK (mate_panel_applet_lock), info);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_set_sensitive (menuitem, lockable);
added_anything = TRUE;
}
if ( ! added_anything) {
g_object_unref (menu);
return NULL;
}
/* Set up theme and transparency support */
GtkWidget *toplevel = gtk_widget_get_toplevel (menu);
/* Fix any failures of compiz/other wm's to communicate with gtk for transparency */
GdkScreen *screen = gtk_widget_get_screen(GTK_WIDGET(toplevel));
GdkVisual *visual = gdk_screen_get_rgba_visual(screen);
gtk_widget_set_visual(GTK_WIDGET(toplevel), visual);
/* Set menu and it's toplevel window to follow panel theme */
GtkStyleContext *context;
context = gtk_widget_get_style_context (GTK_WIDGET(toplevel));
gtk_style_context_add_class(context,"gnome-panel-menu-bar");
gtk_style_context_add_class(context,"mate-panel-menu-bar");
return menu;
}
static void
thunar_location_entry_button_clicked (GtkWidget *button,
ThunarLocationEntry *location_entry)
{
ThunarShortcutsModel *model;
ThunarIconFactory *icon_factory;
ThunarVfsVolume *volume;
GtkIconTheme *icon_theme;
const gchar *icon_name;
GtkTreeIter iter;
ThunarFile *file;
GtkWidget *image;
GtkWidget *item;
GtkWidget *menu;
GdkPixbuf *icon;
gint icon_size;
gint width;
_thunar_return_if_fail (THUNAR_IS_LOCATION_ENTRY (location_entry));
_thunar_return_if_fail (GTK_IS_TOGGLE_BUTTON (button));
/* allocate a new menu */
menu = gtk_menu_new ();
/* determine the icon theme and factory */
icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (button));
icon_factory = thunar_icon_factory_get_for_icon_theme (icon_theme);
/* determine the icon size for menus */
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &icon_size, &icon_size);
/* load the menu items from the shortcuts model */
model = thunar_shortcuts_model_get_default ();
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (model), &iter))
{
do
{
/* determine the file and volume for the item */
gtk_tree_model_get (GTK_TREE_MODEL (model), &iter,
THUNAR_SHORTCUTS_MODEL_COLUMN_FILE, &file,
THUNAR_SHORTCUTS_MODEL_COLUMN_VOLUME, &volume,
-1);
/* check if we have a separator here */
if (G_UNLIKELY (file == NULL && volume == NULL))
{
/* generate a separator the menu */
item = gtk_separator_menu_item_new ();
}
else if (G_UNLIKELY (volume != NULL))
{
/* generate an image menu item for the volume */
item = gtk_image_menu_item_new_with_label (thunar_vfs_volume_get_name (volume));
/* load the icon for the volume */
icon_name = thunar_vfs_volume_lookup_icon_name (volume, icon_theme);
icon = thunar_icon_factory_load_icon (icon_factory, icon_name, icon_size, NULL, FALSE);
if (G_LIKELY (icon != NULL))
{
/* generate an image for the menu item */
image = gtk_image_new_from_pixbuf (icon);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
g_object_unref (G_OBJECT (icon));
gtk_widget_show (image);
}
}
else
{
/* generate an image menu item for the file */
item = gtk_image_menu_item_new_with_label (thunar_file_get_display_name (file));
/* load the icon for the file and generate the image for the menu item */
icon = thunar_icon_factory_load_file_icon (icon_factory, file, THUNAR_FILE_ICON_STATE_DEFAULT, icon_size);
image = gtk_image_new_from_pixbuf (icon);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
g_object_unref (G_OBJECT (icon));
gtk_widget_show (image);
}
/* connect the file and volume to the item */
g_object_set_data_full (G_OBJECT (item), I_("thunar-vfs-volume"), volume, g_object_unref);
g_object_set_data_full (G_OBJECT (item), I_("thunar-file"), file, g_object_unref);
/* append the new item to the menu */
g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (thunar_location_entry_item_activated), location_entry);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
}
while (gtk_tree_model_iter_next (GTK_TREE_MODEL (model), &iter));
}
/* make sure the menu has atleast the same width as the location entry */
width = GTK_WIDGET (location_entry)->allocation.width - 2 * gtk_container_get_border_width (GTK_CONTAINER (location_entry));
if (G_LIKELY (menu->allocation.width < width))
gtk_widget_set_size_request (menu, width, -1);
/* select the first visible or selectable item in the menu */
gtk_menu_shell_select_first (GTK_MENU_SHELL (menu), TRUE);
/* enable the button, making sure that we do not recurse on the "clicked" signal by temporarily blocking the handler */
g_signal_handlers_block_by_func (G_OBJECT (button), G_CALLBACK (thunar_location_entry_button_clicked), location_entry);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
g_signal_handlers_unblock_by_func (G_OBJECT (button), G_CALLBACK (thunar_location_entry_button_clicked), location_entry);
/* run the menu, taking ownership over the menu object */
thunar_gtk_menu_run (GTK_MENU (menu), button, menu_position, location_entry, 1, gtk_get_current_event_time ());
/* disable the button, making sure that we do not recurse on the "clicked" signal by temporarily blocking the handler */
g_signal_handlers_block_by_func (G_OBJECT (button), G_CALLBACK (thunar_location_entry_button_clicked), location_entry);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
g_signal_handlers_unblock_by_func (G_OBJECT (button), G_CALLBACK (thunar_location_entry_button_clicked), location_entry);
/* clean up */
g_object_unref (G_OBJECT (icon_factory));
g_object_unref (G_OBJECT (model));
}
