← Back to branch summary

~ubuntu-branches/ubuntu/utopic/cairo-dock-plug-ins/utopic-proposed

« back to all changes in this revision

Viewing changes to GMenu/src/applet-tree.c

  • Committer: Matthieu Baerts
  • Date: 2014-02-19 23:22:46 UTC
  • mfrom: (1.1.36)
  • Revision ID: matttbe@gmail.com-20140219232246-iopf2zg7s6jby9tt
Tags: 3.3.99.beta1.1~20140219~bzr3061-0ubuntu1
https://launchpad.net/bugs/1253654
* New upstream snapshot.
* Short Upstream ChangeLog:
  - All: updated due to recent API changes and changes in the global style
  - GMenu:
    - Do not create empty menus
    - Show the dialogue to open a new after after the end of the installation
    - Added an option to not show this dialogue
  - Gnome: support Cinnamon logout
  - Logout: display a message to reboot the system after the end of the update
  - Shortcut: improve the support of bookmarks
  - Status-Notifier: support scroll events
  - Terminal: open terminal on middle click
  - Some bugs have been fixed (LP: #1253654), other tweaks
* debian/control:
  - Bumped Cairo-Dock (core) versions
  - Bumped Standard Version (no change needed)

Show diffs side-by-side

added added

removed removed

Lines of Context:
GMenu/src/applet-tree.c
27
27
 
28
28
#define CD_FOLDER_DEFAULT_ICON "folder"
29
29
 
30
 
static void cd_populate_menu_from_directory (GtkWidget *menu, GMenuTreeDirectory *directory);
 
30
// return TRUE if the menu is not empty
 
31
static gboolean cd_populate_menu_from_directory (GtkWidget *menu, GMenuTreeDirectory *directory);
31
32
 
32
33
 
33
34
  /////////////////
69
70
 /// MENU FROM TREE ///
70
71
//////////////////////
71
72
 
72
 
/* Not really needed with libgnome-menu-3
73
 
static void _load_one_icon (GtkWidget *image)
74
 
{
75
 
        // this actually loads the pixbuf of the gicon
76
 
        GtkRequisition requisition;
77
 
        #if (GTK_MAJOR_VERSION < 3)
78
 
        gtk_widget_size_request (image, &requisition);
79
 
        #else
80
 
        gtk_widget_get_preferred_size (image, &requisition, NULL);
81
 
        #endif
82
 
}*/
83
 
 
84
73
static void add_image_to_menu_item (GtkWidget *image_menu_item,
85
74
        GIcon *pIcon,
86
75
        const char *fallback_image_filename)
99
88
        gtk_widget_show (image);
100
89
}
101
90
 
102
 
/**static gchar * menu_escape_underscores_and_prepend (const char *text)
103
 
{
104
 
        GString    *escaped_text;
105
 
        const char *src;
106
 
        int         inserted;
107
 
        
108
 
        if (!text)
109
 
                return g_strdup (text);
110
 
 
111
 
        escaped_text = g_string_sized_new (strlen (text) + 1);
112
 
        g_string_printf (escaped_text, "_%s", text);
113
 
 
114
 
        src = text;
115
 
        inserted = 1;
116
 
 
117
 
        while (*src) {
118
 
                gunichar c;
119
 
 
120
 
                c = g_utf8_get_char (src);
121
 
 
122
 
                if (c == (gunichar)-1) {
123
 
                        g_warning ("Invalid input string for underscore escaping");
124
 
                        return g_strdup (text);
125
 
                } else if (c == '_') {
126
 
                        g_string_insert_c (escaped_text,
127
 
                                           src - text + inserted, '_');
128
 
                        inserted++;
129
 
                }
130
 
 
131
 
                src = g_utf8_next_char (src);
132
 
        }
133
 
 
134
 
        return g_string_free (escaped_text, FALSE);
135
 
}*/
136
 
 
137
91
static GtkWidget * add_menu_separator (GtkWidget *menu)
138
92
{
139
93
        GtkWidget *menuitem = gtk_separator_menu_item_new ();
145
99
}
146
100
 
147
101
static GtkWidget * create_submenu_entry (GtkWidget *menu,
148
 
        GMenuTreeDirectory *directory)
 
102
        GMenuTreeDirectory *directory, gboolean bAppend)
149
103
{
150
104
        if (gmenu_tree_directory_get_is_nodisplay (directory))
151
105
                return NULL;
156
110
        add_image_to_menu_item (menuitem,
157
111
                pIcon,
158
112
                CD_FOLDER_DEFAULT_ICON);
159
 
        
160
 
        gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
 
113
 
 
114
        if (bAppend)
 
115
                gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
161
116
        return menuitem;
162
117
}
163
118
 
164
 
static void create_submenu (GtkWidget *menu,
 
119
// return TRUE if the submenu is not empty
 
120
static gboolean create_submenu (GtkWidget *menu,
165
121
        GMenuTreeDirectory *directory,
166
122
        GMenuTreeDirectory *alias_directory)
167
123
{
168
124
        // create an entry
169
125
        GtkWidget *menuitem;
170
126
        if (alias_directory)
171
 
                menuitem = create_submenu_entry (menu, alias_directory);
 
127
                menuitem = create_submenu_entry (menu, alias_directory, FALSE);
172
128
        else
173
 
                menuitem = create_submenu_entry (menu, directory);
 
129
                menuitem = create_submenu_entry (menu, directory, FALSE);
174
130
        if (!menuitem)
175
 
                return;
 
131
                return FALSE;
176
132
        
177
133
        // create a sub-menu for it
178
134
        GtkWidget *submenu = gldi_submenu_new ();
179
135
        gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
180
 
        
 
136
 
181
137
        // populate the sub-menu with the directory
182
 
        cd_populate_menu_from_directory (submenu, directory);
 
138
        if (! cd_populate_menu_from_directory (submenu, directory))
 
139
        {
 
140
                cd_debug ("Empty submenu: %s",
 
141
                        gtk_menu_item_get_label (GTK_MENU_ITEM (menuitem)));
 
142
                gtk_widget_destroy (menuitem);
 
143
                return FALSE;
 
144
        }
 
145
 
 
146
        gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
 
147
        return TRUE;
183
148
}
184
149
 
185
 
static void create_header (GtkWidget *menu,
 
150
// return TRUE if the header is not empty
 
151
static gboolean create_header (GtkWidget *menu,
186
152
        GMenuTreeHeader *header)
187
153
{
188
154
        // create an entry
189
155
        GMenuTreeDirectory *directory = gmenu_tree_header_get_directory (header);
190
 
        create_submenu_entry (menu, directory);
 
156
        GtkWidget *entry = create_submenu_entry (menu, directory, TRUE);
191
157
        gmenu_tree_item_unref (directory);
 
158
        return entry != NULL;
192
159
}
193
160
 
194
 
static void create_menuitem (GtkWidget *menu,
 
161
// return TRUE if the entry is added
 
162
static gboolean create_menuitem (GtkWidget *menu,
195
163
        GMenuTreeEntry *entry,
196
164
        GMenuTreeDirectory *alias_directory)
197
165
{
201
169
        
202
170
        // ignore entry that are not shown in the menu
203
171
        if (gmenu_tree_entry_get_is_excluded (entry))
204
 
                return;
 
172
                return FALSE;
205
173
        if (! cd_menu_app_should_show (pAppInfo))
206
 
                return;
 
174
                return FALSE;
207
175
        
208
176
        // create an entry
209
177
        const gchar *cName = NULL;
258
226
        g_object_set_data_full (G_OBJECT (menuitem),
259
227
                "cd-entry",
260
228
                gmenu_tree_item_ref (entry),
261
 
                (GDestroyNotify) gmenu_tree_item_unref);  // stick the entry on the menu-item, which allows us to ref it and be sure to unref when the menu is destroyed.
 
229
                (GDestroyNotify) gmenu_tree_item_unref);
 
230
        // stick the entry on the menu-item, which allows us to ref it and be sure to unref when the menu is destroyed.
 
231
        return TRUE;
262
232
}
263
233
 
264
 
static void create_menuitem_from_alias (GtkWidget *menu,
 
234
// return TRUE if the menu is not empty
 
235
static gboolean create_menuitem_from_alias (GtkWidget *menu,
265
236
        GMenuTreeAlias *alias)
266
237
{
 
238
        gboolean bHasItem;
267
239
        GMenuTreeItemType iType = gmenu_tree_alias_get_aliased_item_type (alias);
268
240
        GMenuTreeDirectory *src = gmenu_tree_alias_get_directory (alias);
269
241
        switch (iType)
271
243
                case GMENU_TREE_ITEM_DIRECTORY:
272
244
                {
273
245
                        GMenuTreeDirectory *directory = gmenu_tree_alias_get_aliased_directory (alias);
274
 
                        create_submenu (menu,
275
 
                                directory,
276
 
                                src);
 
246
                        bHasItem = create_submenu (menu, directory, src);
277
247
                        gmenu_tree_item_unref (directory);
278
248
                }
279
249
                break;
281
251
                case GMENU_TREE_ITEM_ENTRY:
282
252
                {
283
253
                        GMenuTreeEntry *entry = gmenu_tree_alias_get_aliased_entry (alias);
284
 
                        create_menuitem (menu,
 
254
                        bHasItem = create_menuitem (menu,
285
255
                                gmenu_tree_alias_get_aliased_entry (alias),
286
256
                                src);
287
257
                        gmenu_tree_item_unref (entry);
289
259
                break;
290
260
 
291
261
                default:
 
262
                        bHasItem = FALSE;
292
263
                break;
293
264
        }
294
265
        gmenu_tree_item_unref (src);
 
266
        return bHasItem;
295
267
}
296
268
 
297
 
static void cd_populate_menu_from_directory (GtkWidget *menu, GMenuTreeDirectory *directory)
 
269
// return TRUE if the menu is not empty
 
270
static gboolean cd_populate_menu_from_directory (GtkWidget *menu, GMenuTreeDirectory *directory)
298
271
{
 
272
        gint i = 0;
299
273
        GMenuTreeIter *iter = gmenu_tree_directory_iter (directory);
300
274
        GMenuTreeItemType next_type;
301
275
        while ((next_type = gmenu_tree_iter_next (iter)) != GMENU_TREE_ITEM_INVALID)
305
279
                {
306
280
                        case GMENU_TREE_ITEM_DIRECTORY:  // we suppose that unicity is assured.
307
281
                                item = gmenu_tree_iter_get_directory (iter);
308
 
                                create_submenu (menu, item, NULL);
 
282
                                if (create_submenu (menu, item, NULL))
 
283
                                        i++;
309
284
                                break;
310
285
 
311
286
                        case GMENU_TREE_ITEM_ENTRY:
312
287
                                item = gmenu_tree_iter_get_entry (iter);
313
 
                                create_menuitem (menu, item, NULL);
 
288
                                if (create_menuitem (menu, item, NULL))
 
289
                                        i++;
314
290
                                break;
315
291
 
316
292
                        case GMENU_TREE_ITEM_SEPARATOR :
319
295
 
320
296
                        case GMENU_TREE_ITEM_ALIAS:
321
297
                                item = gmenu_tree_iter_get_alias (iter);
322
 
                                create_menuitem_from_alias (menu, item);
 
298
                                if (create_menuitem_from_alias (menu, item))
 
299
                                        i++;
323
300
                                break;
324
301
 
325
302
                        case GMENU_TREE_ITEM_HEADER:
326
303
                                item = gmenu_tree_iter_get_header (iter);
327
 
                                create_header (menu, item);
 
304
                                if (create_header (menu, item))
 
305
                                        i++;
328
306
                                break;
329
307
 
330
308
                        default:
334
312
                        gmenu_tree_item_unref (item);
335
313
        }
336
314
        gmenu_tree_iter_unref (iter);
 
315
 
 
316
        return i > 0;
337
317
}
338
318
 
339
319
void cd_append_tree_in_menu (GMenuTree *tree, GtkWidget *pMenu)
437
417
GMenuTree *cd_load_tree_from_file (const gchar *cMenuFile)
438
418
{
439
419
        gchar *cMenuFileName = cd_find_menu_file (cMenuFile);
440
 
        GMenuTree *tree = gmenu_tree_new (cMenuFileName, GMENU_TREE_FLAGS_INCLUDE_NODISPLAY | GMENU_TREE_FLAGS_INCLUDE_EXCLUDED);  /// GMENU_TREE_FLAGS_INCLUDE_NODISPLAY
441
 
        if (! gmenu_tree_load_sync (tree, NULL))  // this does all the heavy work of parsing the .menu and each desktop files.
 
420
        GMenuTree *tree = gmenu_tree_new (cMenuFileName,
 
421
                GMENU_TREE_FLAGS_INCLUDE_NODISPLAY| GMENU_TREE_FLAGS_INCLUDE_EXCLUDED);
 
422
        // this does all the heavy work of parsing the .menu and each desktop files:
 
423
        if (! gmenu_tree_load_sync (tree, NULL))
442
424
        {
443
425
                g_object_unref (tree);
444
426
                tree = NULL;