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