]> Pileus Git - ~andy/gtk/blob - gtk/gtkrecentchoosermenu.c
57e96087482673bff6056bb3f0673c9e5cbd73ac
[~andy/gtk] / gtk / gtkrecentchoosermenu.c
1 /* GTK - The GIMP Toolkit
2  * gtkrecentchoosermenu.c - Recently used items menu widget
3  * Copyright (C) 2005, Emmanuele Bassi
4  * 
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the
17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18  * Boston, MA 02111-1307, USA.
19  */
20
21 #include "config.h"
22
23 #include <string.h>
24
25 #include <gdk/gdkscreen.h>
26
27 #include "gtkrecentmanager.h"
28 #include "gtkrecentfilter.h"
29 #include "gtkrecentchooser.h"
30 #include "gtkrecentchooserutils.h"
31 #include "gtkrecentchooserprivate.h"
32 #include "gtkrecentchoosermenu.h"
33
34 #include "gtkstock.h"
35 #include "gtkicontheme.h"
36 #include "gtkiconfactory.h"
37 #include "gtkintl.h"
38 #include "gtksettings.h"
39 #include "gtkmenushell.h"
40 #include "gtkmenuitem.h"
41 #include "gtkimagemenuitem.h"
42 #include "gtkseparatormenuitem.h"
43 #include "gtkmenu.h"
44 #include "gtkimage.h"
45 #include "gtkobject.h"
46 #include "gtktooltips.h"
47 #include "gtktypebuiltins.h"
48
49 #include "gtkrecentmanager.h"
50 #include "gtkrecentfilter.h"
51 #include "gtkrecentchooser.h"
52 #include "gtkrecentchooserutils.h"
53 #include "gtkrecentchooserprivate.h"
54 #include "gtkrecentchoosermenu.h"
55 #include "gtkalias.h"
56
57 struct _GtkRecentChooserMenuPrivate
58 {
59   /* the recent manager object */
60   GtkRecentManager *manager;
61   
62   /* size of the icons of the menu items */  
63   gint icon_size;
64
65   /* RecentChooser properties */
66   gint limit;  
67   guint show_private : 1;
68   guint show_not_found : 1;
69   guint show_tips : 1;
70   guint show_icons : 1;
71   guint local_only : 1;
72   
73   guint show_numbers : 1;
74   
75   GtkRecentSortType sort_type;
76   GtkRecentSortFunc sort_func;
77   gpointer sort_data;
78   GDestroyNotify sort_data_destroy;
79   
80   GSList *filters;
81   GtkRecentFilter *current_filter;
82  
83   guint local_manager : 1;
84   gulong manager_changed_id;
85
86   /* tooltips for our bookmark items*/
87   GtkTooltips *tooltips;
88 };
89
90 enum {
91   PROP_0,
92
93   PROP_SHOW_NUMBERS
94 };
95
96 #define FALLBACK_ICON_SIZE      32
97 #define FALLBACK_ITEM_LIMIT     10
98
99 #define GTK_RECENT_CHOOSER_MENU_GET_PRIVATE(obj)        (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_RECENT_CHOOSER_MENU, GtkRecentChooserMenuPrivate))
100
101 static void     gtk_recent_chooser_menu_finalize    (GObject                   *object);
102 static GObject *gtk_recent_chooser_menu_constructor (GType                      type,
103                                                      guint                      n_construct_properties,
104                                                      GObjectConstructParam     *construct_params);
105
106 static void gtk_recent_chooser_iface_init      (GtkRecentChooserIface     *iface);
107
108 static void gtk_recent_chooser_menu_set_property (GObject      *object,
109                                                   guint         prop_id,
110                                                   const GValue *value,
111                                                   GParamSpec   *pspec);
112 static void gtk_recent_chooser_menu_get_property (GObject      *object,
113                                                   guint         prop_id,
114                                                   GValue       *value,
115                                                   GParamSpec   *pspec);
116
117 static gboolean          gtk_recent_chooser_menu_set_current_uri    (GtkRecentChooser  *chooser,
118                                                                      const gchar       *uri,
119                                                                      GError           **error);
120 static gchar *           gtk_recent_chooser_menu_get_current_uri    (GtkRecentChooser  *chooser);
121 static gboolean          gtk_recent_chooser_menu_select_uri         (GtkRecentChooser  *chooser,
122                                                                      const gchar       *uri,
123                                                                      GError           **error);
124 static void              gtk_recent_chooser_menu_unselect_uri       (GtkRecentChooser  *chooser,
125                                                                      const gchar       *uri);
126 static void              gtk_recent_chooser_menu_select_all         (GtkRecentChooser  *chooser);
127 static void              gtk_recent_chooser_menu_unselect_all       (GtkRecentChooser  *chooser);
128 static GList *           gtk_recent_chooser_menu_get_items          (GtkRecentChooser  *chooser);
129 static GtkRecentManager *gtk_recent_chooser_menu_get_recent_manager (GtkRecentChooser  *chooser);
130 static void              gtk_recent_chooser_menu_set_sort_func      (GtkRecentChooser  *chooser,
131                                                                      GtkRecentSortFunc  sort_func,
132                                                                      gpointer           sort_data,
133                                                                      GDestroyNotify     data_destroy);
134 static void              gtk_recent_chooser_menu_add_filter         (GtkRecentChooser  *chooser,
135                                                                      GtkRecentFilter   *filter);
136 static void              gtk_recent_chooser_menu_remove_filter      (GtkRecentChooser  *chooser,
137                                                                      GtkRecentFilter   *filter);
138 static GSList *          gtk_recent_chooser_menu_list_filters       (GtkRecentChooser  *chooser);
139 static void              gtk_recent_chooser_menu_set_current_filter (GtkRecentChooserMenu *menu,
140                                                                      GtkRecentFilter      *filter);
141
142 static void              gtk_recent_chooser_menu_map (GtkWidget *widget);
143 static void              gtk_recent_chooser_menu_set_show_tips      (GtkRecentChooserMenu *menu,
144                                                                      gboolean              show_tips);
145
146 static void     set_recent_manager (GtkRecentChooserMenu *menu,
147                                     GtkRecentManager     *manager);
148
149 static void     chooser_set_sort_type (GtkRecentChooserMenu *menu,
150                                        GtkRecentSortType     sort_type);
151
152 static gint     get_icon_size_for_widget (GtkWidget *widget);
153
154 static void     item_activate_cb   (GtkWidget        *widget,
155                                     gpointer          user_data);
156 static void     manager_changed_cb (GtkRecentManager *manager,
157                                     gpointer          user_data);
158
159 G_DEFINE_TYPE_WITH_CODE (GtkRecentChooserMenu,
160                          gtk_recent_chooser_menu,
161                          GTK_TYPE_MENU,
162                          G_IMPLEMENT_INTERFACE (GTK_TYPE_RECENT_CHOOSER,
163                                                 gtk_recent_chooser_iface_init))
164
165
166 static void
167 gtk_recent_chooser_iface_init (GtkRecentChooserIface *iface)
168 {
169   iface->set_current_uri = gtk_recent_chooser_menu_set_current_uri;
170   iface->get_current_uri = gtk_recent_chooser_menu_get_current_uri;
171   iface->select_uri = gtk_recent_chooser_menu_select_uri;
172   iface->unselect_uri = gtk_recent_chooser_menu_unselect_uri;
173   iface->select_all = gtk_recent_chooser_menu_select_all;
174   iface->unselect_all = gtk_recent_chooser_menu_unselect_all;
175   iface->get_items = gtk_recent_chooser_menu_get_items;
176   iface->get_recent_manager = gtk_recent_chooser_menu_get_recent_manager;
177   iface->set_sort_func = gtk_recent_chooser_menu_set_sort_func;
178   iface->add_filter = gtk_recent_chooser_menu_add_filter;
179   iface->remove_filter = gtk_recent_chooser_menu_remove_filter;
180   iface->list_filters = gtk_recent_chooser_menu_list_filters;
181 }
182
183 static void
184 gtk_recent_chooser_menu_class_init (GtkRecentChooserMenuClass *klass)
185 {
186   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
187   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
188   
189   gobject_class->constructor = gtk_recent_chooser_menu_constructor;
190   gobject_class->finalize = gtk_recent_chooser_menu_finalize;
191   gobject_class->set_property = gtk_recent_chooser_menu_set_property;
192   gobject_class->get_property = gtk_recent_chooser_menu_get_property;
193
194   widget_class->map = gtk_recent_chooser_menu_map;
195   
196   _gtk_recent_chooser_install_properties (gobject_class);
197
198   /**
199    * GtkRecentChooserMenu:show-numbers
200    *
201    * Whether the first ten items in the menu should be prepended by
202    * a number acting as a unique mnemonic.
203    *
204    * Since: 2.10
205    */
206   g_object_class_install_property (gobject_class,
207                                    PROP_SHOW_NUMBERS,
208                                    g_param_spec_boolean ("show-numbers",
209                                                          P_("Show Numbers"),
210                                                          P_("Whether the items should be displayed with a number"),
211                                                          FALSE,
212                                                          G_PARAM_READWRITE));
213   
214   g_type_class_add_private (klass, sizeof (GtkRecentChooserMenuPrivate));
215 }
216
217 static void
218 gtk_recent_chooser_menu_init (GtkRecentChooserMenu *menu)
219 {
220   GtkRecentChooserMenuPrivate *priv;
221   
222   priv = GTK_RECENT_CHOOSER_MENU_GET_PRIVATE (menu);
223   
224   menu->priv = priv;
225   
226   priv->show_icons= TRUE;
227   priv->show_numbers = FALSE;
228   priv->show_tips = FALSE;
229   priv->show_not_found = FALSE;
230   priv->show_private = FALSE;
231   priv->local_only = TRUE;
232   
233   priv->limit = FALLBACK_ITEM_LIMIT;
234
235   priv->sort_type = GTK_RECENT_SORT_NONE;
236   
237   priv->icon_size = FALLBACK_ICON_SIZE;
238   
239   priv->current_filter = NULL;
240     
241   priv->tooltips = gtk_tooltips_new ();
242   g_object_ref_sink (priv->tooltips);
243 }
244
245 static void
246 gtk_recent_chooser_menu_finalize (GObject *object)
247 {
248   GtkRecentChooserMenu *menu = GTK_RECENT_CHOOSER_MENU (object);
249   GtkRecentChooserMenuPrivate *priv = menu->priv;
250   
251   g_signal_handler_disconnect (priv->manager, priv->manager_changed_id);
252   priv->manager_changed_id = 0;
253
254   priv->manager = NULL;
255   
256   if (priv->sort_data_destroy)
257     {
258       priv->sort_data_destroy (priv->sort_data);
259       
260       priv->sort_data_destroy = NULL;
261       priv->sort_data = NULL;
262       priv->sort_func = NULL;
263     }
264   
265   if (priv->tooltips)
266     g_object_unref (priv->tooltips);
267   
268   if (priv->current_filter)
269     g_object_unref (priv->current_filter);
270   
271   G_OBJECT_CLASS (gtk_recent_chooser_menu_parent_class)->finalize (object);
272 }
273
274 static GObject *
275 gtk_recent_chooser_menu_constructor (GType                  type,
276                                      guint                  n_construct_properties,
277                                      GObjectConstructParam *construct_params)
278 {
279   GtkRecentChooserMenu *menu;
280   GObject *object;
281   
282   object = G_OBJECT_CLASS (gtk_recent_chooser_menu_parent_class)->constructor (type,
283                                                                                n_construct_properties,
284                                                                                construct_params);
285   menu = GTK_RECENT_CHOOSER_MENU (object);
286   
287   g_assert (menu->priv->manager);
288   
289   return object;
290 }
291
292 static void
293 gtk_recent_chooser_menu_set_property (GObject      *object,
294                                       guint         prop_id,
295                                       const GValue *value,
296                                       GParamSpec   *pspec)
297 {
298   GtkRecentChooserMenu *menu = GTK_RECENT_CHOOSER_MENU (object);
299   
300   switch (prop_id)
301     {
302     case PROP_SHOW_NUMBERS:
303       menu->priv->show_numbers = g_value_get_boolean (value);
304       break;
305     case GTK_RECENT_CHOOSER_PROP_RECENT_MANAGER:
306       set_recent_manager (menu, g_value_get_object (value));
307       break;
308     case GTK_RECENT_CHOOSER_PROP_SHOW_PRIVATE:
309       menu->priv->show_private = g_value_get_boolean (value);
310       break;
311     case GTK_RECENT_CHOOSER_PROP_SHOW_NOT_FOUND:
312       menu->priv->show_not_found = g_value_get_boolean (value);
313       break;
314     case GTK_RECENT_CHOOSER_PROP_SHOW_TIPS:
315       gtk_recent_chooser_menu_set_show_tips (menu, g_value_get_boolean (value));
316       break;
317     case GTK_RECENT_CHOOSER_PROP_SHOW_ICONS:
318       menu->priv->show_icons = g_value_get_boolean (value);
319       break;
320     case GTK_RECENT_CHOOSER_PROP_SELECT_MULTIPLE:
321       g_warning ("%s: Choosers of type `%s' do not support selecting multiple items.",
322                  G_STRFUNC,
323                  G_OBJECT_TYPE_NAME (object));
324       break;
325     case GTK_RECENT_CHOOSER_PROP_LOCAL_ONLY:
326       menu->priv->local_only = g_value_get_boolean (value);
327       break;
328     case GTK_RECENT_CHOOSER_PROP_LIMIT:
329       menu->priv->limit = g_value_get_int (value);
330       break;
331     case GTK_RECENT_CHOOSER_PROP_SORT_TYPE:
332       chooser_set_sort_type (menu, g_value_get_enum (value));
333       break;
334     case GTK_RECENT_CHOOSER_PROP_FILTER:
335       gtk_recent_chooser_menu_set_current_filter (menu, g_value_get_object (value));
336       break;
337     default:
338       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
339       break;
340     }
341 }
342
343 static void
344 gtk_recent_chooser_menu_get_property (GObject    *object,
345                                       guint       prop_id,
346                                       GValue     *value,
347                                       GParamSpec *pspec)
348 {
349   GtkRecentChooserMenu *menu = GTK_RECENT_CHOOSER_MENU (object);
350   
351   switch (prop_id)
352     {
353     case PROP_SHOW_NUMBERS:
354       g_value_set_boolean (value, menu->priv->show_numbers);
355       break;
356     case GTK_RECENT_CHOOSER_PROP_SHOW_TIPS:
357       g_value_set_boolean (value, menu->priv->show_tips);
358       break;
359     case GTK_RECENT_CHOOSER_PROP_LIMIT:
360       g_value_set_int (value, menu->priv->limit);
361       break;
362     case GTK_RECENT_CHOOSER_PROP_LOCAL_ONLY:
363       g_value_set_boolean (value, menu->priv->local_only);
364       break;
365     case GTK_RECENT_CHOOSER_PROP_SORT_TYPE:
366       g_value_set_enum (value, menu->priv->sort_type);
367       break;
368     case GTK_RECENT_CHOOSER_PROP_SHOW_PRIVATE:
369       g_value_set_boolean (value, menu->priv->show_private);
370       break;
371     case GTK_RECENT_CHOOSER_PROP_SHOW_NOT_FOUND:
372       g_value_set_boolean (value, menu->priv->show_not_found);
373       break;
374     case GTK_RECENT_CHOOSER_PROP_SHOW_ICONS:
375       g_value_set_boolean (value, menu->priv->show_icons);
376       break;
377     case GTK_RECENT_CHOOSER_PROP_SELECT_MULTIPLE:
378       g_warning ("%s: Choosers of type `%s' do not support selecting multiple items.",
379                  G_STRFUNC,
380                  G_OBJECT_TYPE_NAME (object));
381       break;
382     case GTK_RECENT_CHOOSER_PROP_FILTER:
383       g_value_set_object (value, menu->priv->current_filter);
384       break;
385     default:
386       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
387       break;
388     }
389 }
390
391 static gboolean
392 gtk_recent_chooser_menu_set_current_uri (GtkRecentChooser  *chooser,
393                                          const gchar       *uri,
394                                          GError           **error)
395 {
396   GtkRecentChooserMenu *menu = GTK_RECENT_CHOOSER_MENU (chooser);
397   GList *children, *l;
398   GtkWidget *menu_item = NULL;
399   gboolean found = FALSE;
400   
401   children = gtk_container_get_children (GTK_CONTAINER (menu));
402   for (l = children; l != NULL; l = l->next)
403     {
404       GtkRecentInfo *info;
405       
406       menu_item = GTK_WIDGET (l->data);
407       
408       info = g_object_get_data (G_OBJECT (menu_item), "gtk-recent-info");
409       if (!info)
410         continue;
411       
412       if (0 == strcmp (uri, gtk_recent_info_get_uri (info)))
413         found = TRUE;
414     }
415
416   g_list_free (children);
417   
418   if (!found)  
419     {
420       g_set_error (error, GTK_RECENT_CHOOSER_ERROR,
421                    GTK_RECENT_CHOOSER_ERROR_NOT_FOUND,
422                    _("No recently used resource found with URI `%s'"),
423                    uri);
424       return FALSE;
425     }
426   else
427     {
428       gtk_menu_shell_activate_item (GTK_MENU_SHELL (menu), menu_item, TRUE);
429       
430       return TRUE;
431     }
432 }
433
434 static gchar *
435 gtk_recent_chooser_menu_get_current_uri (GtkRecentChooser  *chooser)
436 {
437   GtkRecentChooserMenu *menu = GTK_RECENT_CHOOSER_MENU (chooser);
438   GtkWidget *menu_item;
439   GtkRecentInfo *info;
440   
441   menu_item = gtk_menu_get_active (GTK_MENU (menu));
442   if (!menu_item)
443     return NULL;
444   
445   info = g_object_get_data (G_OBJECT (menu_item), "gtk-recent-info");
446   if (!info)
447     return NULL;
448   
449   return g_strdup (gtk_recent_info_get_uri (info));
450 }
451
452 static gboolean
453 gtk_recent_chooser_menu_select_uri (GtkRecentChooser  *chooser,
454                                     const gchar       *uri,
455                                     GError           **error)
456 {
457   GtkRecentChooserMenu *menu = GTK_RECENT_CHOOSER_MENU (chooser);
458   GList *children, *l;
459   GtkWidget *menu_item = NULL;
460   gboolean found = FALSE;
461   
462   children = gtk_container_get_children (GTK_CONTAINER (menu));
463   for (l = children; l != NULL; l = l->next)
464     {
465       GtkRecentInfo *info;
466       
467       menu_item = GTK_WIDGET (l->data);
468       
469       info = g_object_get_data (G_OBJECT (menu_item), "gtk-recent-info");
470       if (!info)
471         continue;
472       
473       if (0 == strcmp (uri, gtk_recent_info_get_uri (info)))
474         found = TRUE;
475     }
476
477   g_list_free (children);
478   
479   if (!found)  
480     {
481       g_set_error (error, GTK_RECENT_CHOOSER_ERROR,
482                    GTK_RECENT_CHOOSER_ERROR_NOT_FOUND,
483                    _("No recently used resource found with URI `%s'"),
484                    uri);
485       return FALSE;
486     }
487   else
488     {
489       gtk_menu_shell_select_item (GTK_MENU_SHELL (menu), menu_item);
490
491       return TRUE;
492     }
493 }
494
495 static void
496 gtk_recent_chooser_menu_unselect_uri (GtkRecentChooser *chooser,
497                                        const gchar     *uri)
498 {
499   GtkRecentChooserMenu *menu = GTK_RECENT_CHOOSER_MENU (chooser);
500   
501   gtk_menu_shell_deselect (GTK_MENU_SHELL (menu));
502 }
503
504 static void
505 gtk_recent_chooser_menu_select_all (GtkRecentChooser *chooser)
506 {
507   g_warning (_("This function is not implemented for "
508                "widgets of class '%s'"),
509              g_type_name (G_OBJECT_TYPE (chooser)));
510 }
511
512 static void
513 gtk_recent_chooser_menu_unselect_all (GtkRecentChooser *chooser)
514 {
515   g_warning (_("This function is not implemented for "
516                "widgets of class '%s'"),
517              g_type_name (G_OBJECT_TYPE (chooser)));
518 }
519
520 static void
521 gtk_recent_chooser_menu_set_sort_func (GtkRecentChooser  *chooser,
522                                        GtkRecentSortFunc  sort_func,
523                                        gpointer           sort_data,
524                                        GDestroyNotify     data_destroy)
525 {
526   GtkRecentChooserMenu *menu = GTK_RECENT_CHOOSER_MENU (chooser);
527   GtkRecentChooserMenuPrivate *priv = menu->priv;
528   
529   if (priv->sort_data_destroy)
530     {
531       priv->sort_data_destroy (priv->sort_data);
532       
533       priv->sort_func = NULL;
534       priv->sort_data = NULL;
535       priv->sort_data_destroy = NULL;
536     }
537   
538   if (sort_func)
539     {
540       priv->sort_func = sort_func;
541       priv->sort_data = sort_data;
542       priv->sort_data_destroy = data_destroy;
543     }
544 }
545
546 static gint
547 sort_recent_items_mru (GtkRecentInfo *a,
548                        GtkRecentInfo *b,
549                        gpointer       unused)
550 {
551   g_assert (a != NULL && b != NULL);
552   
553   return (gtk_recent_info_get_modified (a) < gtk_recent_info_get_modified (b));
554 }
555
556 static gint
557 sort_recent_items_lru (GtkRecentInfo *a,
558                        GtkRecentInfo *b,
559                        gpointer       unused)
560 {
561   g_assert (a != NULL && b != NULL);
562   
563   return (gtk_recent_info_get_modified (a) > gtk_recent_info_get_modified (b));
564 }
565
566 /* our proxy sorting function */
567 static gint
568 sort_recent_items_proxy (gpointer *a,
569                          gpointer *b,
570                          gpointer  user_data)
571 {
572   GtkRecentInfo *info_a = (GtkRecentInfo *) a;
573   GtkRecentInfo *info_b = (GtkRecentInfo *) b;
574   GtkRecentChooserMenu *menu = GTK_RECENT_CHOOSER_MENU (user_data);
575
576   if (menu->priv->sort_func)
577     return (* menu->priv->sort_func) (info_a,
578                                       info_b,
579                                       menu->priv->sort_data);
580   
581   /* fallback */
582   return 0;
583 }
584
585 static void
586 chooser_set_sort_type (GtkRecentChooserMenu *menu,
587                        GtkRecentSortType     sort_type)
588 {
589   if (menu->priv->sort_type == sort_type)
590     return;
591
592   menu->priv->sort_type = sort_type;
593 }
594
595
596 static GList *
597 gtk_recent_chooser_menu_get_items (GtkRecentChooser *chooser)
598 {
599   GtkRecentChooserMenu *menu = GTK_RECENT_CHOOSER_MENU (chooser);
600   GtkRecentChooserMenuPrivate *priv;
601   gint limit;
602   GtkRecentSortType sort_type;
603   GList *items;
604   GCompareDataFunc compare_func;
605   gint length;
606   
607   priv = menu->priv;
608   
609   if (!priv->manager)
610     return NULL;
611   
612   limit = gtk_recent_chooser_get_limit (chooser);
613   sort_type = gtk_recent_chooser_get_sort_type (chooser);
614
615   switch (sort_type)
616     {
617     case GTK_RECENT_SORT_NONE:
618       compare_func = NULL;
619       break;
620     case GTK_RECENT_SORT_MRU:
621       compare_func = (GCompareDataFunc) sort_recent_items_mru;
622       break;
623     case GTK_RECENT_SORT_LRU:
624       compare_func = (GCompareDataFunc) sort_recent_items_lru;
625       break;
626     case GTK_RECENT_SORT_CUSTOM:
627       compare_func = (GCompareDataFunc) sort_recent_items_proxy;
628       break;
629     default:
630       g_assert_not_reached ();
631       break;
632     }
633   
634   items = gtk_recent_manager_get_items (priv->manager);
635   if (!items)
636     return NULL;
637   
638   if (compare_func)  
639     items = g_list_sort_with_data (items, compare_func, menu);
640   
641   length = g_list_length (items);
642   if ((limit != -1) && (length > limit))
643     {
644       GList *clamp, *l;
645       
646       clamp = g_list_nth (items, limit - 1);
647
648       l = clamp->next;
649       clamp->next = NULL;      
650       
651       g_list_foreach (l, (GFunc) gtk_recent_info_unref, NULL);
652       g_list_free (l);
653     }
654   
655   return items;
656 }
657
658 static GtkRecentManager *
659 gtk_recent_chooser_menu_get_recent_manager (GtkRecentChooser *chooser)
660 {
661   GtkRecentChooserMenuPrivate *priv;
662  
663   priv = GTK_RECENT_CHOOSER_MENU (chooser)->priv;
664   
665   return priv->manager;
666 }
667
668 static void
669 gtk_recent_chooser_menu_add_filter (GtkRecentChooser *chooser,
670                                     GtkRecentFilter  *filter)
671 {
672   g_warning (_("This function is not implemented for "
673                "widgets of class '%s'"),
674              g_type_name (G_OBJECT_TYPE (chooser)));
675 }
676
677 static void
678 gtk_recent_chooser_menu_remove_filter (GtkRecentChooser *chooser,
679                                        GtkRecentFilter  *filter)
680 {
681   g_warning (_("This function is not implemented for "
682                "widgets of class '%s'"),
683              g_type_name (G_OBJECT_TYPE (chooser)));
684 }
685
686 static GSList *
687 gtk_recent_chooser_menu_list_filters (GtkRecentChooser  *chooser)
688 {
689   g_warning (_("This function is not implemented for "
690                "widgets of class '%s'"),
691              g_type_name (G_OBJECT_TYPE (chooser)));
692
693   return NULL;
694 }
695
696 static void
697 gtk_recent_chooser_menu_set_current_filter (GtkRecentChooserMenu *menu,
698                                             GtkRecentFilter      *filter)
699 {
700   GtkRecentChooserMenuPrivate *priv;
701
702   priv = menu->priv;
703   
704   if (priv->current_filter)
705     g_object_unref (G_OBJECT (priv->current_filter));
706   
707   priv->current_filter = filter;
708   g_object_ref_sink (priv->current_filter);
709   
710   g_object_notify (G_OBJECT (menu), "filter");
711 }
712
713 static gboolean
714 get_is_recent_filtered (GtkRecentChooserMenu *menu,
715                         GtkRecentInfo        *info)
716 {
717   GtkRecentChooserMenuPrivate *priv;
718   GtkRecentFilter *current_filter;
719   GtkRecentFilterInfo filter_info;
720   GtkRecentFilterFlags needed;
721   gboolean retval;
722
723   g_assert (info != NULL);
724
725   priv = menu->priv;
726   
727   if (!priv->current_filter)
728     return FALSE;
729   
730   current_filter = priv->current_filter;
731   needed = gtk_recent_filter_get_needed (current_filter);
732   
733   filter_info.contains = GTK_RECENT_FILTER_URI | GTK_RECENT_FILTER_MIME_TYPE;
734   
735   filter_info.uri = gtk_recent_info_get_uri (info);
736   filter_info.mime_type = gtk_recent_info_get_mime_type (info);
737   
738   if (needed & GTK_RECENT_FILTER_DISPLAY_NAME)
739     {
740       filter_info.display_name = gtk_recent_info_get_display_name (info);
741       filter_info.contains |= GTK_RECENT_FILTER_DISPLAY_NAME;
742     }
743   else
744     filter_info.uri = NULL;
745   
746   if (needed & GTK_RECENT_FILTER_APPLICATION)
747     {
748       filter_info.applications = (const gchar **) gtk_recent_info_get_applications (info, NULL);
749       filter_info.contains |= GTK_RECENT_FILTER_APPLICATION;
750     }
751   else
752     filter_info.applications = NULL;
753
754   if (needed & GTK_RECENT_FILTER_GROUP)
755     {
756       filter_info.groups = (const gchar **) gtk_recent_info_get_groups (info, NULL);
757       filter_info.contains |= GTK_RECENT_FILTER_GROUP;
758     }
759   else
760     filter_info.groups = NULL;
761   
762   if (needed & GTK_RECENT_FILTER_AGE)
763     {
764       filter_info.age = gtk_recent_info_get_age (info);
765       filter_info.contains |= GTK_RECENT_FILTER_AGE;
766     }
767   else
768     filter_info.age = -1;
769   
770   retval = gtk_recent_filter_filter (current_filter, &filter_info);
771   
772   /* this we own */
773   if (filter_info.applications)
774     g_strfreev ((gchar **) filter_info.applications);
775   if (filter_info.groups)
776     g_strfreev ((gchar **) filter_info.groups);
777   
778   return !retval;
779 }
780
781 /* taken from libeel/eel-strings.c */
782 static gchar *
783 escape_underscores (const gchar *string)
784 {
785   gint underscores;
786   const gchar *p;
787   gchar *q;
788   gchar *escaped;
789
790   if (!string)
791     return NULL;
792         
793   underscores = 0;
794   for (p = string; *p != '\0'; p++)
795     underscores += (*p == '_');
796
797   if (underscores == 0)
798     return g_strdup (string);
799
800   escaped = g_new (char, strlen (string) + underscores + 1);
801   for (p = string, q = escaped; *p != '\0'; p++, q++)
802     {
803       /* Add an extra underscore. */
804       if (*p == '_')
805         *q++ = '_';
806       
807       *q = *p;
808     }
809   
810   *q = '\0';
811         
812   return escaped;
813 }
814
815 static void
816 gtk_recent_chooser_menu_add_tip (GtkRecentChooserMenu *menu,
817                                  GtkRecentInfo        *info,
818                                  GtkWidget            *item)
819 {
820   GtkRecentChooserMenuPrivate *priv;
821   gchar *path, *tip_text;
822
823   g_assert (info != NULL);
824   g_assert (item != NULL);
825
826   priv = menu->priv;
827   
828   if (!priv->tooltips)
829     return;
830   
831   path = gtk_recent_info_get_uri_display (info);
832   
833   tip_text = g_strdup_printf (_("Open '%s'"), path);
834  
835   gtk_tooltips_set_tip (priv->tooltips,
836                         item,
837                         tip_text,
838                         NULL);
839
840   g_free (path);  
841   g_free (tip_text);
842 }
843
844 static GtkWidget *
845 gtk_recent_chooser_menu_create_item (GtkRecentChooserMenu *menu,
846                                      GtkRecentInfo        *info,
847                                      gint                  count)
848 {
849   GtkRecentChooserMenuPrivate *priv;
850   gchar *label;
851   GtkWidget *item, *image;
852   GdkPixbuf *icon;
853
854   g_assert (info != NULL);
855
856   priv = menu->priv;
857
858   if (priv->show_numbers)
859     {
860       gchar *name, *escaped;
861       
862       name = g_strdup (gtk_recent_info_get_display_name (info));
863       if (!name)
864         name = g_strdup (_("Unknown item"));
865       
866       escaped = escape_underscores (name);
867       
868       /* avoid clashing mnemonics */
869       if (count <= 10)
870         label = g_strdup_printf ("_%d. %s", count, escaped);
871       else
872         label = g_strdup_printf ("%d. %s", count, escaped);
873       
874       item = gtk_image_menu_item_new_with_mnemonic (label);
875       
876       g_free (escaped);
877       g_free (name);
878     }
879   else
880     {
881       label = g_strdup (gtk_recent_info_get_display_name (info));
882       item = gtk_image_menu_item_new_with_label (label);
883     }
884   
885   if (priv->show_icons)
886     {
887       icon = gtk_recent_info_get_icon (info, priv->icon_size);
888         
889       image = gtk_image_new_from_pixbuf (icon);
890       gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
891     }
892   
893   if (!gtk_recent_info_exists (info))
894     {
895       gtk_widget_set_sensitive (item, FALSE);
896       
897       goto out;
898     }
899   
900   g_signal_connect (item, "activate",
901                     G_CALLBACK (item_activate_cb),
902                     menu);
903
904 out:
905   g_free (label);
906
907   return item;
908 }
909
910 /* removes the items we own from the menu */
911 static void
912 gtk_recent_chooser_menu_dispose_items (GtkRecentChooserMenu *menu)
913 {
914   GList *children, *l;
915  
916   children = gtk_container_get_children (GTK_CONTAINER (menu));
917   for (l = children; l != NULL; l = l->next)
918     {
919       GtkWidget *menu_item = GTK_WIDGET (l->data);
920       gint mark = 0;
921       
922       /* check for our mark, in order to remove just the items we own */
923       mark = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (menu_item),
924                                                  "gtk-recent-menu-mark"));
925       if (mark == 1)
926         {
927           GtkRecentInfo *info;
928           
929           /* destroy the attached RecentInfo struct, if found */
930           info = g_object_get_data (G_OBJECT (menu_item), "gtk-recent-info");
931           if (info)
932             g_object_set_data_full (G_OBJECT (menu_item), "gtk-recent-info",
933                                     NULL, NULL);
934           
935           /* and finally remove the item from the menu */
936           gtk_container_remove (GTK_CONTAINER (menu), menu_item);
937         }
938     }
939
940   g_list_free (children);
941 }
942
943 /* GtkWidget::map method override
944  *
945  * We override this method in order to populate the menu with our
946  * menu items linked to the recently used resources.
947  */
948 static void
949 gtk_recent_chooser_menu_map (GtkWidget *widget)
950 {
951   GtkRecentChooserMenu *menu = GTK_RECENT_CHOOSER_MENU (widget);
952   GtkRecentChooserMenuPrivate *priv = menu->priv;
953   GList *items, *l;
954   gint count;
955   gboolean has_items = FALSE;
956   
957   if (GTK_WIDGET_CLASS (gtk_recent_chooser_menu_parent_class)->map)
958     GTK_WIDGET_CLASS (gtk_recent_chooser_menu_parent_class)->map (widget);
959   
960   priv->icon_size = get_icon_size_for_widget (widget);
961   
962   /* dispose our menu items first */
963   gtk_recent_chooser_menu_dispose_items (menu);
964  
965   items = gtk_recent_chooser_get_items (GTK_RECENT_CHOOSER (menu));
966   
967   count = g_list_length (items);
968   items = g_list_reverse (items);
969
970   for (l = items; l != NULL; l = l->next)
971     {
972       GtkRecentInfo *info = (GtkRecentInfo *) l->data;
973       GtkWidget *item;
974
975       g_assert (info != NULL);
976       
977       /* skip non-local items on request */
978       if (priv->local_only && !gtk_recent_info_is_local (info))
979         continue;
980       
981       /* skip private items on request */
982       if (!priv->show_private && gtk_recent_info_get_private_hint (info))
983         continue;
984       
985       /* skip non-existing items on request */
986       if (!priv->show_not_found && !gtk_recent_info_exists (info))
987         continue;
988
989       /* filter items based on the currently set filter object */
990       if (get_is_recent_filtered (menu, info))
991         continue;
992  
993       item = gtk_recent_chooser_menu_create_item (menu, info, count);
994       if (!item)
995         continue;
996       
997       gtk_recent_chooser_menu_add_tip (menu, info, item);
998       
999       /* FIXME
1000        *
1001        * We should really place our items taking into account user
1002        * defined menu items; this would also remove the need of
1003        * reverting the scan order.
1004        */
1005       gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item);
1006       gtk_widget_show (item);
1007       
1008       /* mark the menu item as one of our own */
1009       g_object_set_data (G_OBJECT (item), "gtk-recent-menu-mark",
1010                          GINT_TO_POINTER (1));
1011       
1012       /* attach the RecentInfo object to the menu item, and own a reference
1013        * to it, so that it will be destroyed with the menu item when it's
1014        * not needed anymore.
1015        */
1016       g_object_set_data_full (G_OBJECT (item), "gtk-recent-info",
1017                               gtk_recent_info_ref (info),
1018                               (GDestroyNotify) gtk_recent_info_unref);
1019       
1020       /* we have at least one item */
1021       if (!has_items)
1022         has_items = TRUE;
1023     }
1024   
1025   /* now, the RecentInfo objects are bound to the lifetime of the menu */
1026   if (items)
1027     {
1028       g_list_foreach (items,
1029                       (GFunc) gtk_recent_info_unref,
1030                       NULL);
1031       g_list_free (items);
1032     }
1033
1034   /* no recently used resources were found, or they were filtered out, so
1035    * we build an item stating that no recently used resources were found
1036    * (as night follows the day...).
1037    */
1038   if (!has_items)
1039     {
1040       GtkWidget *item;
1041       
1042       item = gtk_menu_item_new_with_label ("No items found");
1043       gtk_widget_set_sensitive (item, FALSE);
1044       
1045       /* we also mark this item, so that it gets removed when rebuilding
1046        * the menu on the next map event
1047        */
1048       g_object_set_data (G_OBJECT (item), "gtk-recent-menu-mark",
1049                          GINT_TO_POINTER (1));
1050       
1051       gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item);
1052       gtk_widget_show (item);
1053     }
1054 }
1055
1056 /* bounce activate signal from the recent menu item widget 
1057  * to the recent menu widget
1058  */
1059 static void
1060 item_activate_cb (GtkWidget *widget,
1061                   gpointer   user_data)
1062 {
1063   GtkRecentChooser *chooser = GTK_RECENT_CHOOSER (user_data);
1064   
1065   _gtk_recent_chooser_item_activated (chooser);
1066 }
1067
1068 /* we force a redraw if the manager changes when we are showing */
1069 static void
1070 manager_changed_cb (GtkRecentManager *manager,
1071                     gpointer          user_data)
1072 {
1073   gtk_widget_queue_draw (GTK_WIDGET (user_data));
1074 }
1075
1076 static void
1077 set_recent_manager (GtkRecentChooserMenu *menu,
1078                     GtkRecentManager     *manager)
1079 {
1080   if (menu->priv->manager)
1081     g_signal_handler_disconnect (menu, menu->priv->manager_changed_id);
1082   
1083   menu->priv->manager = NULL;
1084   
1085   if (manager)
1086     menu->priv->manager = manager;
1087   else
1088     menu->priv->manager = gtk_recent_manager_get_default ();
1089   
1090   if (menu->priv->manager)
1091     menu->priv->manager_changed_id = g_signal_connect (menu->priv->manager, "changed",
1092                                                        G_CALLBACK (manager_changed_cb),
1093                                                        menu);
1094 }
1095
1096 static gint
1097 get_icon_size_for_widget (GtkWidget *widget)
1098 {
1099   GtkSettings *settings;
1100   gint width, height;
1101
1102   if (gtk_widget_has_screen (widget))
1103     settings = gtk_settings_get_for_screen (gtk_widget_get_screen (widget));
1104   else
1105     settings = gtk_settings_get_default ();
1106
1107   if (gtk_icon_size_lookup_for_settings (settings, GTK_ICON_SIZE_MENU,
1108                                          &width, &height))
1109     return MAX (width, height);
1110
1111   return FALLBACK_ICON_SIZE;
1112 }
1113
1114 static void
1115 gtk_recent_chooser_menu_set_show_tips (GtkRecentChooserMenu *menu,
1116                                        gboolean              show_tips)
1117 {
1118   if (menu->priv->show_tips == show_tips)
1119     return;
1120   
1121   g_assert (menu->priv->tooltips != NULL);
1122   
1123   if (show_tips)
1124     gtk_tooltips_enable (menu->priv->tooltips);
1125   else
1126     gtk_tooltips_disable (menu->priv->tooltips);
1127   
1128   menu->priv->show_tips = show_tips;
1129 }
1130
1131 /*
1132  * Public API
1133  */
1134
1135 /**
1136  * gtk_recent_chooser_menu_new:
1137  *
1138  * Creates a new #GtkRecentChooserMenu widget.
1139  *
1140  * This kind of widget shows the list of recently used resources as
1141  * a menu, each item as a menu item.  Each item inside the menu might
1142  * have an icon, representing its MIME type, and a number, for mnemonic
1143  * access.
1144  *
1145  * This widget implements the #GtkRecentChooser interface.
1146  *
1147  * This widget creates its own #GtkRecentManager object.  See the
1148  * gtk_recent_chooser_menu_new_for_manager() function to know how to create
1149  * a #GtkRecentChooserMenu widget bound to another #GtkRecentManager object.
1150  *
1151  * Return value: a new #GtkRecentChooserMenu
1152  *
1153  * Since: 2.10
1154  */
1155 GtkWidget *
1156 gtk_recent_chooser_menu_new (void)
1157 {
1158   return g_object_new (GTK_TYPE_RECENT_CHOOSER_MENU,
1159                        "recent-manager", NULL,
1160                        NULL);
1161 }
1162
1163 /**
1164  * gtk_recent_chooser_menu_new_for_manager:
1165  * @manager: a #GtkRecentManager
1166  *
1167  * Creates a new #GtkRecentChooserMenu widget using @manager as
1168  * the underlying recently used resources manager.
1169  *
1170  * This is useful if you have implemented your own recent manager,
1171  * or if you have a customized instance of a #GtkRecentManager
1172  * object or if you wish to share a common #GtkRecentManager object
1173  * among multiple #GtkRecentChooser widgets.
1174  *
1175  * Return value: a new #GtkRecentChooserMenu, bound to @manager.
1176  *
1177  * Since: 2.10
1178  */
1179 GtkWidget *
1180 gtk_recent_chooser_menu_new_for_manager (GtkRecentManager *manager)
1181 {
1182   g_return_val_if_fail (manager == NULL || GTK_IS_RECENT_MANAGER (manager), NULL);
1183   
1184   return g_object_new (GTK_TYPE_RECENT_CHOOSER_MENU,
1185                        "recent-manager", manager,
1186                        NULL);
1187 }
1188
1189 /**
1190  * gtk_recent_chooser_menu_get_show_numbers:
1191  * @menu: a #GtkRecentChooserMenu
1192  *
1193  * Returns the value set by gtk_recent_chooser_menu_set_show_numbers().
1194  * 
1195  * Return value: %TRUE if numbers should be shown.
1196  *
1197  * Since: 2.10
1198  */
1199 gboolean
1200 gtk_recent_chooser_menu_get_show_numbers (GtkRecentChooserMenu *menu)
1201 {
1202   g_return_val_if_fail (GTK_IS_RECENT_CHOOSER_MENU (menu), FALSE);
1203
1204   return menu->priv->show_numbers;
1205 }
1206
1207 /**
1208  * gtk_recent_chooser_menu_set_show_numbers:
1209  * @menu: a #GtkRecentChooserMenu
1210  * @show_numbers: whether to show numbers
1211  *
1212  * Sets whether a number should be added to the items of @menu.  The
1213  * numbers are shown to provide a unique character for a mnemonic to
1214  * be used inside the menu item's label.  Only the first the items
1215  * get a number to avoid clashes.
1216  *
1217  * Since: 2.10
1218  */
1219 void
1220 gtk_recent_chooser_menu_set_show_numbers (GtkRecentChooserMenu *menu,
1221                                           gboolean              show_numbers)
1222 {
1223   g_return_if_fail (GTK_IS_RECENT_CHOOSER_MENU (menu));
1224
1225   if (menu->priv->show_numbers == show_numbers)
1226     return;
1227
1228   menu->priv->show_numbers = show_numbers;
1229   g_object_notify (G_OBJECT (menu), "show-numbers");
1230 }
1231
1232 #define __GTK_RECENT_CHOOSER_MENU_C__
1233 #include "gtkaliasdef.c"