static void contextMenuItemVisibilityChanged(GtkAction* action, GParamSpec*, WebContextMenuProxyGtk* contextMenuProxy)
{
GtkMenu* menu = contextMenuProxy->gtkMenu();
if (!menu)
return;
GUniquePtr<GList> items(gtk_container_get_children(GTK_CONTAINER(menu)));
bool previousVisibleItemIsNotASeparator = false;
GtkWidget* lastItemVisibleSeparator = 0;
for (GList* iter = items.get(); iter; iter = g_list_next(iter)) {
GtkWidget* widget = GTK_WIDGET(iter->data);
if (GTK_IS_SEPARATOR_MENU_ITEM(widget)) {
if (previousVisibleItemIsNotASeparator) {
gtk_widget_show(widget);
lastItemVisibleSeparator = widget;
previousVisibleItemIsNotASeparator = false;
} else
gtk_widget_hide(widget);
} else if (gtk_widget_get_visible(widget)) {
lastItemVisibleSeparator = 0;
previousVisibleItemIsNotASeparator = true;
}
}
if (lastItemVisibleSeparator)
gtk_widget_hide(lastItemVisibleSeparator);
}
/**
* Adds a separated menuitem if there isn't one at the end of the menushell
*/
void
gul_gui_add_separator_conditional (GtkMenuShell *ms)
{
GList *children;
GList *li;
gboolean add = TRUE;
children = gtk_container_get_children (GTK_CONTAINER (ms));
for (li = children; li; li = li->next)
{
if (!li->next && GTK_IS_SEPARATOR_MENU_ITEM (li->data))
{
add = FALSE;
break;
}
}
g_list_free (children);
if (add)
{
GtkWidget *sep = gtk_separator_menu_item_new ();
gtk_widget_show (sep);
gtk_menu_shell_append (ms, sep);
}
}
static gboolean
menuIsSelectable(GtkWidget *menu)
{
return !((!gtk_bin_get_child(GTK_BIN(menu)) &&
G_OBJECT_TYPE(menu) == GTK_TYPE_MENU_ITEM) ||
GTK_IS_SEPARATOR_MENU_ITEM(menu) ||
!gtk_widget_is_sensitive(menu) ||
!gtk_widget_get_visible(menu));
}
void
glade_gtk_menu_item_post_create (GladeWidgetAdaptor * adaptor,
GObject * object, GladeCreateReason reason)
{
if (GTK_IS_SEPARATOR_MENU_ITEM (object))
return;
if (gtk_bin_get_child (GTK_BIN (object)) == NULL)
{
GtkWidget *label = gtk_label_new ("");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_container_add (GTK_CONTAINER (object), label);
}
}
static void on_bookmarks_changed(FmBookmarks* bm, FmMainWin* win)
{
/* delete old items first. */
GList* mis = gtk_container_get_children(GTK_CONTAINER(win->bookmarks_menu));
GList* l;
for(l = mis;l;l=l->next)
{
GtkWidget* item = (GtkWidget*)l->data;
if( GTK_IS_SEPARATOR_MENU_ITEM(item) )
break;
gtk_widget_destroy(item);
}
g_list_free(mis);
create_bookmarks_menu(win);
}
G_MODULE_EXPORT void on_viewMenu_activate(
GtkObject *object,
gpointer user_data)
{
GtkMenuItem *item= GTK_MENU_ITEM(object);
if(gtk_menu_item_get_submenu(item) != NULL)
{
char buffer[100];
char *prefix= "Plot Window";
GtkMenu *menu= GTK_MENU(gtk_menu_item_get_submenu(item));
GList *initial_list = gtk_container_get_children(GTK_CONTAINER(menu));
// iterate the linked list and remove all the Plot Window entries...
GList *entry= initial_list;
while(entry)
{
if(GTK_IS_MENU_ITEM(entry->data) && !GTK_IS_SEPARATOR_MENU_ITEM(entry->data))
{
const char *existing_label= gtk_menu_item_get_label(GTK_MENU_ITEM(entry->data));
// fprintf(stderr, "Label %s\n", existing_label);
if(startswith(existing_label, prefix))
{
// fprintf(stderr, "Removing %s\n", existing_label);
// do we have to remove it explicitly, or can we just nuke and pave?
gtk_widget_destroy(GTK_WIDGET(entry->data));
}
}
entry= entry->next;
}
g_list_free(initial_list);
int ii;
for(ii= 0; ii<MAXIMUM_NUMBER_OF_WINDOWS; ii++)
{
if (wininfo.windows[ii]==1)
{
sprintf(buffer, "%s %d", prefix, ii+1);
GtkWidget *child= gtk_menu_item_new_with_label(buffer);
gtk_signal_connect (GTK_OBJECT (child), "activate", GTK_SIGNAL_FUNC (on_activate_plot_window), GINT_TO_POINTER (ii));
gtk_menu_shell_append(GTK_MENU_SHELL(menu), child);
gtk_widget_show(child);
}
}
}
}
void
glade_gtk_menu_item_add_child (GladeWidgetAdaptor * adaptor,
GObject * object, GObject * child)
{
g_return_if_fail (GTK_IS_MENU_ITEM (object));
g_return_if_fail (GTK_IS_MENU (child));
if (GTK_IS_SEPARATOR_MENU_ITEM (object))
{
g_warning
("You shouldn't try to add a GtkMenu to a GtkSeparatorMenuItem");
return;
}
g_object_set_data (child, "special-child-type", "submenu");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (object), GTK_WIDGET (child));
}
// Extract the ActionType from the menu item
ContextMenuItem::ContextMenuItem(GtkMenuItem* item)
: m_platformDescription()
{
if (GTK_IS_SEPARATOR_MENU_ITEM(item))
m_platformDescription.type = SeparatorType;
else if (gtk_menu_item_get_submenu(item))
m_platformDescription.type = SubmenuType;
else if (GTK_IS_CHECK_MENU_ITEM(item)) {
m_platformDescription.type = CheckableActionType;
m_platformDescription.checked = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(item));
} else
m_platformDescription.type = ActionType;
m_platformDescription.action = *static_cast<ContextMenuAction*>(g_object_get_data(G_OBJECT(item), WEBKIT_CONTEXT_MENU_ACTION));
m_platformDescription.subMenu = GTK_MENU(gtk_menu_item_get_submenu(item));
if (m_platformDescription.subMenu)
g_object_ref(m_platformDescription.subMenu);
}
static void
gail_menu_item_real_initialize (AtkObject *obj,
gpointer data)
{
GtkWidget *widget;
GtkWidget *parent;
ATK_OBJECT_CLASS (gail_menu_item_parent_class)->initialize (obj, data);
g_signal_connect (data,
"select",
G_CALLBACK (menu_item_select),
NULL);
g_signal_connect (data,
"deselect",
G_CALLBACK (menu_item_deselect),
NULL);
widget = GTK_WIDGET (data);
parent = gtk_widget_get_parent (widget);
if (GTK_IS_MENU (parent))
{
GtkWidget *parent_widget;
parent_widget = gtk_menu_get_attach_widget (GTK_MENU (parent));
if (!GTK_IS_MENU_ITEM (parent_widget))
parent_widget = gtk_widget_get_parent (widget);
if (parent_widget)
{
atk_object_set_parent (obj, gtk_widget_get_accessible (parent_widget));
}
}
g_object_set_data (G_OBJECT (obj), "atk-component-layer",
GINT_TO_POINTER (ATK_LAYER_POPUP));
if (GTK_IS_TEAROFF_MENU_ITEM (data))
obj->role = ATK_ROLE_TEAR_OFF_MENU_ITEM;
else if (GTK_IS_SEPARATOR_MENU_ITEM (data))
obj->role = ATK_ROLE_SEPARATOR;
else
obj->role = ATK_ROLE_MENU_ITEM;
}
static void
mateconf_bookmarks_key_changed (MateConfClient *client, guint cnxn_id, MateConfEntry *entry, gpointer user_data)
{
GList *child_list, *tmp;
GtkWidget *menu_item;
child_list = gtk_container_get_children (GTK_CONTAINER (user_data));
for (tmp = child_list; tmp; tmp = tmp->next) {
menu_item = tmp->data;
if (g_object_get_data (G_OBJECT (menu_item), "mateconf-key") != NULL ||
GTK_IS_SEPARATOR_MENU_ITEM (menu_item)) {
gtk_widget_destroy (menu_item);
}
}
mateconf_bookmarks_update_menu (GTK_WIDGET (user_data));
g_list_free (child_list);
}
/**
* Removes a separator menuitem if there is one at the end of the menushell
* Needed because the menushell for the context menu persists when not visible.
* If the context bookmarks becomes null in the interim, the separator will
* still be left at the end of the context menu. Ugly
*/
void
gul_gui_remove_separator_conditional(GtkMenuShell *ms)
{
GList *children;
GList *li;
GtkWidget *sep = NULL;
children = gtk_container_get_children(GTK_CONTAINER(ms));
for (li = children; li; li = li->next)
{
if (!li->next && GTK_IS_SEPARATOR_MENU_ITEM(li->data))
{
sep = GTK_WIDGET(li->data);
break;
}
}
g_list_free(children);
if (sep)
{
gtk_widget_destroy(sep);
}
}
gboolean
glade_gtk_menu_item_add_verify (GladeWidgetAdaptor *adaptor,
GtkWidget *container,
GtkWidget *child,
gboolean user_feedback)
{
if (!GTK_IS_MENU (child))
{
if (user_feedback)
{
GladeWidgetAdaptor *menu_adaptor =
glade_widget_adaptor_get_by_type (GTK_TYPE_MENU);
glade_util_ui_message (glade_app_get_window (),
GLADE_UI_INFO, NULL,
ONLY_THIS_GOES_IN_THAT_MSG,
glade_widget_adaptor_get_title (menu_adaptor),
glade_widget_adaptor_get_title (adaptor));
}
return FALSE;
}
else if (GTK_IS_SEPARATOR_MENU_ITEM (container))
{
if (user_feedback)
{
glade_util_ui_message (glade_app_get_window (),
GLADE_UI_INFO, NULL,
_("An object of type %s cannot have any children."),
glade_widget_adaptor_get_title (adaptor));
}
return FALSE;
}
return TRUE;
}
static void
matewnck_selector_insert_window (MatewnckSelector *selector, MatewnckWindow *window)
{
GtkWidget *item;
MatewnckScreen *screen;
MatewnckWorkspace *workspace;
int workspace_n;
int i;
screen = matewnck_selector_get_screen (selector);
workspace = matewnck_window_get_workspace (window);
if (!workspace && !matewnck_window_is_pinned (window))
return;
item = matewnck_selector_create_window (selector, window);
if (!workspace || workspace == matewnck_screen_get_active_workspace (screen))
{
/* window is pinned or in the current workspace
* => insert before the separator */
GList *l, *children;
i = 0;
children = gtk_container_get_children (GTK_CONTAINER (selector->priv->menu));
for (l = children; l; l = l->next)
{
if (GTK_IS_SEPARATOR_MENU_ITEM (l->data))
break;
i++;
}
g_list_free (children);
gtk_menu_shell_insert (GTK_MENU_SHELL (selector->priv->menu),
item, i);
}
else
{
workspace_n = matewnck_workspace_get_number (workspace);
if (workspace_n == matewnck_screen_get_workspace_count (screen) - 1)
/* window is in last workspace => just append */
gtk_menu_shell_append (GTK_MENU_SHELL (selector->priv->menu), item);
else
{
/* insert just before the next workspace item */
GList *l, *children;
i = 0;
children = gtk_container_get_children (GTK_CONTAINER (selector->priv->menu));
for (l = children; l; l = l->next)
{
int j;
j = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (l->data),
"matewnck-selector-workspace-n"));
if (j - 1 == workspace_n + 1)
break;
i++;
}
g_list_free (children);
gtk_menu_shell_insert (GTK_MENU_SHELL (selector->priv->menu),
item, i);
}
}
}
static void
matewnck_selector_make_menu_consistent (MatewnckSelector *selector)
{
GList *l, *children;
int workspace_n;
GtkWidget *workspace_item;
GtkWidget *separator;
gboolean separator_is_first;
gboolean separator_is_last;
gboolean visible_window;
workspace_n = -1;
workspace_item = NULL;
separator = NULL;
separator_is_first = FALSE;
separator_is_last = FALSE;
visible_window = FALSE;
children = gtk_container_get_children (GTK_CONTAINER (selector->priv->menu));
for (l = children; l; l = l->next)
{
int i;
i = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (l->data),
"matewnck-selector-workspace-n"));
if (i > 0)
{
workspace_n = i - 1;
/* we have two consecutive workspace items => hide the first */
if (workspace_item)
gtk_widget_hide (workspace_item);
workspace_item = GTK_WIDGET (l->data);
}
else if (GTK_IS_SEPARATOR_MENU_ITEM (l->data))
{
if (!visible_window)
separator_is_first = TRUE;
separator_is_last = TRUE;
separator = GTK_WIDGET (l->data);
}
else if (gtk_widget_get_visible (l->data) &&
l->data != selector->priv->no_windows_item)
{
separator_is_last = FALSE;
visible_window = TRUE;
/* if we know of a workspace item that was not shown */
if (workspace_item)
{
MatewnckWindow *window;
MatewnckWorkspace *workspace;
window = g_object_get_data (G_OBJECT (l->data),
"matewnck-selector-window");
if (window)
{
workspace = matewnck_window_get_workspace (window);
if (workspace &&
workspace_n == matewnck_workspace_get_number (workspace))
{
gtk_widget_show (workspace_item);
workspace_n = -1;
workspace_item = NULL;
}
}
}
} /* end if (normal item) */
}
g_list_free (children);
/* do we have a trailing workspace item to be hidden? */
if (workspace_item)
gtk_widget_hide (workspace_item);
if (separator)
{
if (separator_is_first || separator_is_last)
gtk_widget_hide (separator);
else
gtk_widget_show (separator);
}
if (visible_window)
gtk_widget_hide (selector->priv->no_windows_item);
else
gtk_widget_show (selector->priv->no_windows_item);
}
static void serializer_visit_menuitem (Serializer* self, GtkMenuItem* menuitem) {
char* _tmp0_;
gboolean _tmp2_ = FALSE;
g_return_if_fail (self != NULL);
g_return_if_fail (menuitem != NULL);
if (GTK_IS_TEAROFF_MENU_ITEM (menuitem)) {
return;
}
serializer_indent (self);
g_string_append (self->priv->sb, "<item");
g_string_append (self->priv->sb, _tmp0_ = g_markup_printf_escaped (" id=\"W%lu\"", (gulong) menuitem));
_g_free0 (_tmp0_);
if (self->priv->hybrid) {
g_string_append (self->priv->sb, " client-side=\"1\"");
}
g_string_erase (self->priv->label_sb, (gssize) 0, (gssize) (-1));
self->priv->last_item_empty = TRUE;
self->priv->guessed_type = NULL;
serializer_visit_container (self, (GtkContainer*) menuitem);
if (self->priv->label_sb->len > 0) {
char* _tmp1_;
g_string_append (self->priv->sb, _tmp1_ = g_markup_printf_escaped (" label=\"%s\"", self->priv->label_sb->str));
_g_free0 (_tmp1_);
self->priv->last_item_empty = FALSE;
}
if (GTK_IS_SEPARATOR_MENU_ITEM (menuitem)) {
_tmp2_ = TRUE;
} else {
_tmp2_ = gtk_bin_get_child ((GtkBin*) menuitem) == NULL;
}
if (_tmp2_) {
self->priv->guessed_type = "s";
self->priv->last_item_empty = FALSE;
}
if (GTK_IS_IMAGE_MENU_ITEM (menuitem)) {
GtkMenuItem* _tmp3_;
GtkWidget* _tmp4_;
GtkImage* image;
image = _g_object_ref0 ((_tmp4_ = gtk_image_menu_item_get_image ((_tmp3_ = menuitem, GTK_IS_IMAGE_MENU_ITEM (_tmp3_) ? ((GtkImageMenuItem*) _tmp3_) : NULL)), GTK_IS_IMAGE (_tmp4_) ? ((GtkImage*) _tmp4_) : NULL));
if (image != NULL) {
self->priv->guessed_type = "i";
serializer_append_icon_attribute (self, image);
self->priv->last_item_empty = FALSE;
}
_g_object_unref0 (image);
}
if (GTK_IS_CHECK_MENU_ITEM (menuitem)) {
GtkMenuItem* _tmp5_;
GtkCheckMenuItem* checkmenuitem;
checkmenuitem = _g_object_ref0 ((_tmp5_ = menuitem, GTK_IS_CHECK_MENU_ITEM (_tmp5_) ? ((GtkCheckMenuItem*) _tmp5_) : NULL));
if (gtk_check_menu_item_get_draw_as_radio (checkmenuitem)) {
self->priv->guessed_type = "r";
} else {
self->priv->guessed_type = "c";
}
if (!gtk_check_menu_item_get_inconsistent (checkmenuitem)) {
if (gtk_check_menu_item_get_active (checkmenuitem)) {
g_string_append (self->priv->sb, " state=\"1\"");
} else {
g_string_append (self->priv->sb, " state=\"0\"");
}
}
self->priv->last_item_empty = FALSE;
_g_object_unref0 (checkmenuitem);
}
if (gtk_widget_get_visible ((GtkWidget*) menuitem) == FALSE) {
g_string_append (self->priv->sb, " visible=\"0\"");
self->priv->last_item_empty = FALSE;
}
if (gtk_widget_get_sensitive ((GtkWidget*) menuitem) == FALSE) {
g_string_append (self->priv->sb, " sensitive=\"0\"");
}
if (self->priv->last_item_empty) {
g_string_append (self->priv->sb, " visible=\"0\"");
}
if (self->priv->guessed_type != NULL) {
g_string_append_printf (self->priv->sb, " type=\"%s\"", self->priv->guessed_type);
}
if (gtk_menu_item_get_submenu (menuitem) == NULL) {
g_string_append (self->priv->sb, "/>");
serializer_linebreak (self);
} else {
g_string_append_c (self->priv->sb, '>');
serializer_linebreak (self);
self->priv->level++;
if (gtk_menu_item_get_submenu (menuitem) != NULL) {
serializer_visit_menu (self, gtk_menu_item_get_submenu (menuitem));
}
self->priv->level--;
serializer_indent (self);
g_string_append (self->priv->sb, "</item>");
serializer_linebreak (self);
}
}
static void
sync_menu_shell (GtkMenuShell *menu_shell,
MenuRef carbon_menu,
gboolean toplevel,
gboolean debug)
{
GList *children;
GList *l;
MenuItemIndex carbon_index = 1;
if (debug)
g_printerr ("%s: syncing shell %p\n", G_STRFUNC, menu_shell);
carbon_menu_connect (GTK_WIDGET (menu_shell), carbon_menu, toplevel);
children = gtk_container_get_children (GTK_CONTAINER (menu_shell));
for (l = children; l; l = l->next)
{
GtkWidget *menu_item = l->data;
CarbonMenuItem *carbon_item;
if (GTK_IS_TEAROFF_MENU_ITEM (menu_item))
continue;
if (toplevel && g_object_get_data (G_OBJECT (menu_item),
"gtk-empty-menu-item"))
continue;
carbon_item = carbon_menu_item_get (menu_item);
if (debug)
g_printerr ("%s: carbon_item %d for menu_item %d (%s, %s)\n",
G_STRFUNC, carbon_item ? carbon_item->index : -1,
carbon_index, get_menu_label_text (menu_item, NULL),
g_type_name (G_TYPE_FROM_INSTANCE (menu_item)));
if (carbon_item && carbon_item->index != carbon_index)
{
if (debug)
g_printerr ("%s: -> not matching, deleting\n", G_STRFUNC);
DeleteMenuItem (carbon_item->menu, carbon_index);
carbon_item = NULL;
}
if (!carbon_item)
{
GtkWidget *label = NULL;
const gchar *label_text;
CFStringRef cfstr = NULL;
MenuItemAttributes attributes = 0;
if (debug)
g_printerr ("%s: -> creating new\n", G_STRFUNC);
label_text = get_menu_label_text (menu_item, &label);
if (label_text)
cfstr = CFStringCreateWithCString (NULL, label_text,
kCFStringEncodingUTF8);
if (GTK_IS_SEPARATOR_MENU_ITEM (menu_item))
attributes |= kMenuItemAttrSeparator;
if (!gtk_widget_is_sensitive (menu_item))
attributes |= kMenuItemAttrDisabled;
if (!gtk_widget_get_visible (menu_item))
attributes |= kMenuItemAttrHidden;
InsertMenuItemTextWithCFString (carbon_menu, cfstr,
carbon_index - 1,
attributes, 0);
SetMenuItemProperty (carbon_menu, carbon_index,
IGE_QUARTZ_MENU_CREATOR,
IGE_QUARTZ_ITEM_WIDGET,
sizeof (menu_item), &menu_item);
if (cfstr)
CFRelease (cfstr);
carbon_item = carbon_menu_item_connect (menu_item, label,
carbon_menu,
carbon_index);
if (GTK_IS_CHECK_MENU_ITEM (menu_item))
carbon_menu_item_update_active (carbon_item, menu_item);
carbon_menu_item_update_accel_closure (carbon_item, menu_item);
if (gtk_menu_item_get_submenu (GTK_MENU_ITEM (menu_item)))
carbon_menu_item_update_submenu (carbon_item, menu_item);
}
carbon_index++;
}
g_list_free (children);
}
static void
sync_menu_shell (GtkMenuShell *menu_shell,
MenuRef carbon_menu,
gboolean toplevel)
{
GList *children;
GList *l;
MenuItemIndex carbon_index = 1;
carbon_menu_connect (GTK_WIDGET (menu_shell), carbon_menu);
children = gtk_container_get_children (GTK_CONTAINER (menu_shell));
UInt16 carbon_item_count = CountMenuItems(carbon_menu);
for (l = children; l; l = l->next)
{
GtkWidget *menu_item = l->data;
CarbonMenuItem *carbon_item;
if (GTK_IS_TEAROFF_MENU_ITEM (menu_item))
continue;
if (toplevel && g_object_get_data (G_OBJECT (menu_item),
"gtk-empty-menu-item"))
continue;
GtkWidget *label = NULL;
const gchar *label_text = NULL;
label_text = get_menu_label_text (menu_item, &label);
if (label_text && strcmp(label_text, "_SKIP_") == 0)
{
carbon_index++;
continue;
}
else if (!label_text)
label_text = "";
MenuItemAttributes attributes = 0;
if (GTK_IS_SEPARATOR_MENU_ITEM (menu_item))
attributes |= kMenuItemAttrSeparator;
if (!GTK_WIDGET_IS_SENSITIVE (menu_item))
attributes |= kMenuItemAttrDisabled;
if (!GTK_WIDGET_VISIBLE (menu_item))
attributes |= kMenuItemAttrHidden;
CFStringRef cfstr = CFStringCreateWithCString (NULL, label_text,
kCFStringEncodingUTF8);
if (carbon_index > carbon_item_count)
AppendMenuItemTextWithCFString(carbon_menu, cfstr, attributes, 0,
NULL);
else if (!toplevel && (carbon_index > carbon_item_count))
InsertMenuItemTextWithCFString (carbon_menu, cfstr,
carbon_index, attributes, 0);
else
SetMenuItemTextWithCFString(carbon_menu, carbon_index, cfstr);
CFRelease (cfstr);
MenuItemAttributes c_attributes = kMenuItemAttrSectionHeader |
kMenuItemAttrAutoDisable;
if (!(attributes & kMenuItemAttrDisabled))
c_attributes |= kMenuItemAttrDisabled;
if (!(attributes & kMenuItemAttrSeparator))
c_attributes |= kMenuItemAttrSeparator;
if (!(attributes & kMenuItemAttrHidden))
c_attributes |= kMenuItemAttrHidden;
ChangeMenuItemAttributes(carbon_menu, carbon_index,
attributes, c_attributes);
SetMenuItemProperty (carbon_menu, carbon_index,
GTK_QUARTZ_MENU_CREATOR,
GTK_QUARTZ_ITEM_WIDGET,
sizeof (menu_item), &menu_item);
carbon_item = carbon_menu_item_connect (menu_item, label,
carbon_menu,
carbon_index);
if (GTK_IS_CHECK_MENU_ITEM (menu_item))
carbon_menu_item_update_active (carbon_item, menu_item);
carbon_menu_item_update_accel_closure (carbon_item, menu_item);
if (gtk_menu_item_get_submenu (GTK_MENU_ITEM (menu_item)))
carbon_menu_item_update_submenu (carbon_item, menu_item);
carbon_index++;
}
while (carbon_index <= carbon_item_count)
{
DeleteMenuItem (carbon_menu, carbon_index);
carbon_index++;
}
g_list_free (children);
}
static void
store_populate_menu_items (GtkListStore *store,
GtkMenuShell *menu,
const gchar *parent_path)
{
GList *children;
GList *node;
children = gtk_container_get_children (GTK_CONTAINER (menu));
for (node = children; node; node = node->next) {
if (GTK_IS_SEPARATOR_MENU_ITEM (node->data) ||
! gtk_widget_get_visible (node->data)) {
/* skip that */
} else if (GTK_IS_MENU_ITEM (node->data)) {
GtkWidget *submenu;
gchar *path;
gchar *item_label;
gboolean use_underline;
GtkStockItem item;
if (GTK_IS_IMAGE_MENU_ITEM (node->data) &&
gtk_image_menu_item_get_use_stock (node->data) &&
gtk_stock_lookup (gtk_menu_item_get_label (node->data), &item)) {
item_label = g_strdup (item.label);
use_underline = TRUE;
} else {
item_label = g_strdup (gtk_menu_item_get_label (node->data));
use_underline = gtk_menu_item_get_use_underline (node->data);
}
/* remove underlines */
if (use_underline) {
gchar *p = item_label;
gsize len = strlen (p);
while ((p = strchr (p, '_')) != NULL) {
len -= (gsize) (p - item_label);
memmove (p, p + 1, len);
}
}
if (parent_path) {
path = g_strconcat (parent_path, PATH_SEPARATOR, item_label, NULL);
} else {
path = g_strdup (item_label);
}
submenu = gtk_menu_item_get_submenu (node->data);
if (submenu) {
/* go deeper in the menus... */
store_populate_menu_items (store, GTK_MENU_SHELL (submenu), path);
} else {
gchar *tmp;
gchar *tooltip;
gchar *label = g_markup_printf_escaped ("<big>%s</big>", item_label);
tooltip = gtk_widget_get_tooltip_markup (node->data);
if (tooltip) {
SETPTR (label, g_strconcat (label, "\n<small>", tooltip, "</small>", NULL));
g_free (tooltip);
}
tmp = g_markup_escape_text (path, -1);
SETPTR (label, g_strconcat (label, "\n<small><i>", tmp, "</i></small>", NULL));
g_free (tmp);
gtk_list_store_insert_with_values (store, NULL, -1,
COL_LABEL, label,
COL_PATH, path,
COL_TYPE, COL_TYPE_MENU_ITEM,
COL_WIDGET, node->data,
-1);
g_free (label);
}
g_free (item_label);
g_free (path);
} else {
g_warning ("Unknown widget type in the menu: %s",
G_OBJECT_TYPE_NAME (node->data));
}
}
g_list_free (children);
}
/** \brief Fill in a menu with controls for fliplist control.
*
* Fliplist controls are placed at the end of a menu, after a
* separator. Any previously-existing fliplist controls within the
* menu will be removed.
*
* \param menu The menu to be edited.
* \param unit The drive unit (8-11) that this menu
* will control.
* \param separator_count The number of menu separators in the
* part of the menu that does not involve
* the fliplist.
*/
void ui_populate_fliplist_menu(GtkWidget *menu, int unit, int separator_count)
{
const char *fliplist_string;
GtkWidget *menu_item;
GList *children = gtk_container_get_children(GTK_CONTAINER(menu));
GList *child_iter = g_list_first(children);
int separators_so_far = 0;
while (child_iter) {
if (GTK_IS_SEPARATOR_MENU_ITEM(child_iter->data)) {
++separators_so_far;
}
if (separators_so_far > separator_count) {
gtk_container_remove(GTK_CONTAINER(menu), child_iter->data);
}
child_iter = child_iter->next;
}
g_list_free(children);
/* Fliplist controls in GTK2/GNOME are next/previous and then the
* full list of entries within it. For GTK3 we only show these if
* the fliplist isn't empty for this drive. */
/* TODO: Add/Remove current image to/from fliplist should really
* be here too. */
fliplist_string = fliplist_get_next(unit);
if (fliplist_string) {
char buf[128];
char *basename = NULL;
fliplist_t fliplist_iterator;
int index;
gtk_container_add(GTK_CONTAINER(menu), gtk_separator_menu_item_new());
util_fname_split(fliplist_string, NULL, &basename);
snprintf(buf, 128, "Next: %s", basename ? basename : fliplist_string);
lib_free(basename);
basename = NULL;
buf[127] = 0;
menu_item = gtk_menu_item_new_with_label(buf);
g_signal_connect(menu_item, "activate", G_CALLBACK(ui_fliplist_next_cb), GINT_TO_POINTER(unit));
gtk_container_add(GTK_CONTAINER(menu), menu_item);
fliplist_string = fliplist_get_prev(unit);
if (fliplist_string) {
util_fname_split(fliplist_string, NULL, &basename);
snprintf(buf, 128, "Previous: %s", basename ? basename : fliplist_string);
lib_free(basename);
basename = NULL;
buf[127] = 0;
menu_item = gtk_menu_item_new_with_label(buf);
g_signal_connect(menu_item, "activate", G_CALLBACK(ui_fliplist_prev_cb), GINT_TO_POINTER(unit));
gtk_container_add(GTK_CONTAINER(menu), menu_item);
}
gtk_container_add(GTK_CONTAINER(menu), gtk_separator_menu_item_new());
fliplist_iterator = fliplist_init_iterate(unit);
index = 0;
while (fliplist_iterator) {
fliplist_string = fliplist_get_image(fliplist_iterator);
util_fname_split(fliplist_string, NULL, &basename);
menu_item = gtk_menu_item_new_with_label(basename ? basename : fliplist_string);
lib_free(basename);
basename = NULL;
g_signal_connect(menu_item, "activate", G_CALLBACK(ui_fliplist_select_cb), GINT_TO_POINTER(unit+(index << 8)));
gtk_container_add(GTK_CONTAINER(menu), menu_item);
fliplist_iterator = fliplist_next_iterate(unit);
++index;
}
}
}
