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