Pileus Git - ~andy/gtk/blob - gtk/gtkrecentchooserutils.c

   1 /* gtkrecentchooserutils.h - Private utility functions for implementing a
   2  *                           GtkRecentChooser interface
   3  *
   4  * Copyright (C) 2006 Emmanuele Bassi
   5  *
   6  * All rights reserved
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public
  19  * License along with this library; if not, write to the
  20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21  * Boston, MA 02111-1307, USA.
  22  *
  23  * Based on gtkfilechooserutils.c:
  24  *      Copyright (C) 2003 Red Hat, Inc.
  25  */
  26
  27 #include "config.h"
  28
  29 #include "gtkrecentchooserutils.h"
  30
  31 /* Methods */
  32 static void      delegate_set_sort_func              (GtkRecentChooser  *chooser,
  33                                                       GtkRecentSortFunc  sort_func,
  34                                                       gpointer           sort_data,
  35                                                       GDestroyNotify     data_destroy);
  36 static void      delegate_add_filter                 (GtkRecentChooser  *chooser,
  37                                                       GtkRecentFilter   *filter);
  38 static void      delegate_remove_filter              (GtkRecentChooser  *chooser,
  39                                                       GtkRecentFilter   *filter);
  40 static GSList   *delegate_list_filters               (GtkRecentChooser  *chooser);
  41 static gboolean  delegate_select_uri                 (GtkRecentChooser  *chooser,
  42                                                       const gchar       *uri,
  43                                                       GError           **error);
  44 static void      delegate_unselect_uri               (GtkRecentChooser  *chooser,
  45                                                       const gchar       *uri);
  46 static GList    *delegate_get_items                  (GtkRecentChooser  *chooser);
  47 static GtkRecentManager *delegate_get_recent_manager (GtkRecentChooser  *chooser);
  48 static void      delegate_select_all                 (GtkRecentChooser  *chooser);
  49 static void      delegate_unselect_all               (GtkRecentChooser  *chooser);
  50 static gboolean  delegate_set_current_uri            (GtkRecentChooser  *chooser,
  51                                                       const gchar       *uri,
  52                                                       GError           **error);
  53 static gchar *   delegate_get_current_uri            (GtkRecentChooser  *chooser);
  54
  55 /* Signals */
  56 static void      delegate_notify            (GObject          *object,
  57                                              GParamSpec       *pspec,
  58                                              gpointer          user_data);
  59 static void      delegate_selection_changed (GtkRecentChooser *receiver,
  60                                              gpointer          user_data);
  61 static void      delegate_item_activated    (GtkRecentChooser *receiver,
  62                                              gpointer          user_data);
  63
  64 /**
  65  * _gtk_recent_chooser_install_properties:
  66  * @klass: the class structure for a type deriving from #GObject
  67  *
  68  * Installs the necessary properties for a class implementing
  69  * #GtkRecentChooser. A #GtkParamSpecOverride property is installed
  70  * for each property, using the values from the #GtkRecentChooserProp
  71  * enumeration. The caller must make sure itself that the enumeration
  72  * values don't collide with some other property values they
  73  * are using.
  74  */
  75 void
  76 _gtk_recent_chooser_install_properties (GObjectClass *klass)
  77 {
  78   g_object_class_override_property (klass,
  79                                     GTK_RECENT_CHOOSER_PROP_RECENT_MANAGER,
  80                                     "recent-manager");
  81   g_object_class_override_property (klass,
  82                                     GTK_RECENT_CHOOSER_PROP_SHOW_PRIVATE,
  83                                     "show-private");
  84   g_object_class_override_property (klass,
  85                                     GTK_RECENT_CHOOSER_PROP_SHOW_TIPS,
  86                                     "show-tips");
  87   g_object_class_override_property (klass,
  88                                     GTK_RECENT_CHOOSER_PROP_SHOW_ICONS,
  89                                     "show-icons");
  90   g_object_class_override_property (klass,
  91                                     GTK_RECENT_CHOOSER_PROP_SHOW_NOT_FOUND,
  92                                     "show-not-found");
  93   g_object_class_override_property (klass,
  94                                     GTK_RECENT_CHOOSER_PROP_SELECT_MULTIPLE,
  95                                     "select-multiple");
  96   g_object_class_override_property (klass,
  97                                     GTK_RECENT_CHOOSER_PROP_LIMIT,
  98                                     "limit");
  99   g_object_class_override_property (klass,
 100                                     GTK_RECENT_CHOOSER_PROP_LOCAL_ONLY,
 101                                     "local-only");
 102   g_object_class_override_property (klass,
 103                                     GTK_RECENT_CHOOSER_PROP_SORT_TYPE,
 104                                     "sort-type");
 105   g_object_class_override_property (klass,
 106                                     GTK_RECENT_CHOOSER_PROP_FILTER,
 107                                     "filter");
 108 }
 109
 110 /**
 111  * _gtk_recent_chooser_delegate_iface_init:
 112  * @iface: a #GtkRecentChooserIface
 113  *
 114  * An interface-initialization function for use in cases where
 115  * an object is simply delegating the methods, signals of
 116  * the #GtkRecentChooser interface to another object.
 117  * _gtk_recent_chooser_set_delegate() must be called on each
 118  * instance of the object so that the delegate object can
 119  * be found.
 120  */
 121 void
 122 _gtk_recent_chooser_delegate_iface_init (GtkRecentChooserIface *iface)
 123 {
 124   iface->set_current_uri = delegate_set_current_uri;
 125   iface->get_current_uri = delegate_get_current_uri;
 126   iface->select_uri = delegate_select_uri;
 127   iface->unselect_uri = delegate_unselect_uri;
 128   iface->select_all = delegate_select_all;
 129   iface->unselect_all = delegate_unselect_all;
 130   iface->get_items = delegate_get_items;
 131   iface->get_recent_manager = delegate_get_recent_manager;
 132   iface->set_sort_func = delegate_set_sort_func;
 133   iface->add_filter = delegate_add_filter;
 134   iface->remove_filter = delegate_remove_filter;
 135   iface->list_filters = delegate_list_filters;
 136 }
 137
 138 /**
 139  * _gtk_recent_chooser_set_delegate:
 140  * @receiver: a #GObject implementing #GtkRecentChooser
 141  * @delegate: another #GObject implementing #GtkRecentChooser
 142  *
 143  * Establishes that calls on @receiver for #GtkRecentChooser
 144  * methods should be delegated to @delegate, and that
 145  * #GtkRecentChooser signals emitted on @delegate should be
 146  * forwarded to @receiver. Must be used in conjunction with
 147  * _gtk_recent_chooser_delegate_iface_init().
 148  */
 149 void
 150 _gtk_recent_chooser_set_delegate (GtkRecentChooser *receiver,
 151                                   GtkRecentChooser *delegate)
 152 {
 153   g_return_if_fail (GTK_IS_RECENT_CHOOSER (receiver));
 154   g_return_if_fail (GTK_IS_RECENT_CHOOSER (delegate));
 155
 156   g_object_set_data (G_OBJECT (receiver),
 157                     "gtk-recent-chooser-delegate", delegate);
 158
 159   g_signal_connect (delegate, "notify",
 160                     G_CALLBACK (delegate_notify), receiver);
 161   g_signal_connect (delegate, "selection-changed",
 162                     G_CALLBACK (delegate_selection_changed), receiver);
 163   g_signal_connect (delegate, "item-activated",
 164                     G_CALLBACK (delegate_item_activated), receiver);
 165 }
 166
 167 GQuark
 168 _gtk_recent_chooser_delegate_get_quark (void)
 169 {
 170   static GQuark quark = 0;
 171
 172   if (G_UNLIKELY (quark == 0))
 173     quark = g_quark_from_static_string ("gtk-recent-chooser-delegate");
 174
 175   return quark;
 176 }
 177
 178 static GtkRecentChooser *
 179 get_delegate (GtkRecentChooser *receiver)
 180 {
 181   return g_object_get_qdata (G_OBJECT (receiver),
 182                              GTK_RECENT_CHOOSER_DELEGATE_QUARK);
 183 }
 184
 185 static void
 186 delegate_set_sort_func (GtkRecentChooser  *chooser,
 187                         GtkRecentSortFunc  sort_func,
 188                         gpointer           sort_data,
 189                         GDestroyNotify     data_destroy)
 190 {
 191   gtk_recent_chooser_set_sort_func (get_delegate (chooser),
 192                                     sort_func,
 193                                     sort_data,
 194                                     data_destroy);
 195 }
 196
 197 static void
 198 delegate_add_filter (GtkRecentChooser *chooser,
 199                      GtkRecentFilter  *filter)
 200 {
 201   gtk_recent_chooser_add_filter (get_delegate (chooser), filter);
 202 }
 203
 204 static void
 205 delegate_remove_filter (GtkRecentChooser *chooser,
 206                         GtkRecentFilter  *filter)
 207 {
 208   gtk_recent_chooser_remove_filter (get_delegate (chooser), filter);
 209 }
 210
 211 static GSList *
 212 delegate_list_filters (GtkRecentChooser *chooser)
 213 {
 214   return gtk_recent_chooser_list_filters (get_delegate (chooser));
 215 }
 216
 217 static gboolean
 218 delegate_select_uri (GtkRecentChooser  *chooser,
 219                      const gchar       *uri,
 220                      GError           **error)
 221 {
 222   return gtk_recent_chooser_select_uri (get_delegate (chooser), uri, error);
 223 }
 224
 225 static void
 226 delegate_unselect_uri (GtkRecentChooser *chooser,
 227                        const gchar      *uri)
 228 {
 229  gtk_recent_chooser_unselect_uri (get_delegate (chooser), uri);
 230 }
 231
 232 static GList *
 233 delegate_get_items (GtkRecentChooser *chooser)
 234 {
 235   return gtk_recent_chooser_get_items (get_delegate (chooser));
 236 }
 237
 238 static GtkRecentManager *
 239 delegate_get_recent_manager (GtkRecentChooser *chooser)
 240 {
 241   return _gtk_recent_chooser_get_recent_manager (get_delegate (chooser));
 242 }
 243
 244 static void
 245 delegate_select_all (GtkRecentChooser *chooser)
 246 {
 247   gtk_recent_chooser_select_all (get_delegate (chooser));
 248 }
 249
 250 static void
 251 delegate_unselect_all (GtkRecentChooser *chooser)
 252 {
 253   gtk_recent_chooser_unselect_all (get_delegate (chooser));
 254 }
 255
 256 static gboolean
 257 delegate_set_current_uri (GtkRecentChooser  *chooser,
 258                           const gchar       *uri,
 259                           GError           **error)
 260 {
 261   return gtk_recent_chooser_set_current_uri (get_delegate (chooser), uri, error);
 262 }
 263
 264 static gchar *
 265 delegate_get_current_uri (GtkRecentChooser *chooser)
 266 {
 267   return gtk_recent_chooser_get_current_uri (get_delegate (chooser));
 268 }
 269
 270 static void
 271 delegate_notify (GObject    *object,
 272                  GParamSpec *pspec,
 273                  gpointer    user_data)
 274 {
 275   gpointer iface;
 276
 277   iface = g_type_interface_peek (g_type_class_peek (G_OBJECT_TYPE (object)),
 278                                  gtk_recent_chooser_get_type ());
 279   if (g_object_interface_find_property (iface, pspec->name))
 280     g_object_notify (user_data, pspec->name);
 281 }
 282
 283 static void
 284 delegate_selection_changed (GtkRecentChooser *receiver,
 285                             gpointer          user_data)
 286 {
 287   _gtk_recent_chooser_selection_changed (GTK_RECENT_CHOOSER (user_data));
 288 }
 289
 290 static void
 291 delegate_item_activated (GtkRecentChooser *receiver,
 292                          gpointer          user_data)
 293 {
 294   _gtk_recent_chooser_item_activated (GTK_RECENT_CHOOSER (user_data));
 295 }
 296
 297 static gint
 298 sort_recent_items_mru (GtkRecentInfo *a,
 299                        GtkRecentInfo *b,
 300                        gpointer       unused)
 301 {
 302   g_assert (a != NULL && b != NULL);
 303
 304   return gtk_recent_info_get_modified (b) - gtk_recent_info_get_modified (a);
 305 }
 306
 307 static gint
 308 sort_recent_items_lru (GtkRecentInfo *a,
 309                        GtkRecentInfo *b,
 310                        gpointer       unused)
 311 {
 312   g_assert (a != NULL && b != NULL);
 313
 314   return -1 * (gtk_recent_info_get_modified (b) - gtk_recent_info_get_modified (a));
 315 }
 316
 317 typedef struct
 318 {
 319   GtkRecentSortFunc func;
 320   gpointer data;
 321 } SortRecentData;
 322
 323 /* our proxy sorting function */
 324 static gint
 325 sort_recent_items_proxy (gpointer *a,
 326                          gpointer *b,
 327                          gpointer  user_data)
 328 {
 329   GtkRecentInfo *info_a = (GtkRecentInfo *) a;
 330   GtkRecentInfo *info_b = (GtkRecentInfo *) b;
 331   SortRecentData *sort_recent = user_data;
 332
 333   if (sort_recent->func)
 334     return (* sort_recent->func) (info_a, info_b, sort_recent->data);
 335
 336   /* fallback */
 337   return 0;
 338 }
 339
 340 static gboolean
 341 get_is_recent_filtered (GtkRecentFilter *filter,
 342                         GtkRecentInfo   *info)
 343 {
 344   GtkRecentFilterInfo filter_info;
 345   GtkRecentFilterFlags needed;
 346   gboolean retval;
 347
 348   g_assert (info != NULL);
 349
 350   needed = gtk_recent_filter_get_needed (filter);
 351
 352   filter_info.contains = GTK_RECENT_FILTER_URI | GTK_RECENT_FILTER_MIME_TYPE;
 353
 354   filter_info.uri = gtk_recent_info_get_uri (info);
 355   filter_info.mime_type = gtk_recent_info_get_mime_type (info);
 356
 357   if (needed & GTK_RECENT_FILTER_DISPLAY_NAME)
 358     {
 359       filter_info.display_name = gtk_recent_info_get_display_name (info);
 360       filter_info.contains |= GTK_RECENT_FILTER_DISPLAY_NAME;
 361     }
 362   else
 363     filter_info.uri = NULL;
 364
 365   if (needed & GTK_RECENT_FILTER_APPLICATION)
 366     {
 367       filter_info.applications = (const gchar **) gtk_recent_info_get_applications (info, NULL);
 368       filter_info.contains |= GTK_RECENT_FILTER_APPLICATION;
 369     }
 370   else
 371     filter_info.applications = NULL;
 372
 373   if (needed & GTK_RECENT_FILTER_GROUP)
 374     {
 375       filter_info.groups = (const gchar **) gtk_recent_info_get_groups (info, NULL);
 376       filter_info.contains |= GTK_RECENT_FILTER_GROUP;
 377     }
 378   else
 379     filter_info.groups = NULL;
 380
 381   if (needed & GTK_RECENT_FILTER_AGE)
 382     {
 383       filter_info.age = gtk_recent_info_get_age (info);
 384       filter_info.contains |= GTK_RECENT_FILTER_AGE;
 385     }
 386   else
 387     filter_info.age = -1;
 388
 389   retval = gtk_recent_filter_filter (filter, &filter_info);
 390
 391   /* these we own */
 392   if (filter_info.applications)
 393     g_strfreev ((gchar **) filter_info.applications);
 394   if (filter_info.groups)
 395     g_strfreev ((gchar **) filter_info.groups);
 396
 397   return !retval;
 398 }
 399
 400 /*
 401  * _gtk_recent_chooser_get_items:
 402  * @chooser: a #GtkRecentChooser
 403  * @filter: a #GtkRecentFilter
 404  * @sort_func: (allow-none): sorting function, or %NULL
 405  * @sort_data: (allow-none): sorting function data, or %NULL
 406  *
 407  * Default implementation for getting the filtered, sorted and
 408  * clamped list of recently used resources from a #GtkRecentChooser.
 409  * This function should be used by implementations of the
 410  * #GtkRecentChooser interface inside the GtkRecentChooser::get_items
 411  * vfunc.
 412  *
 413  * Return value: a list of #GtkRecentInfo objects
 414  */
 415 GList *
 416 _gtk_recent_chooser_get_items (GtkRecentChooser  *chooser,
 417                                GtkRecentFilter   *filter,
 418                                GtkRecentSortFunc  sort_func,
 419                                gpointer           sort_data)
 420 {
 421   GtkRecentManager *manager;
 422   gint limit;
 423   GtkRecentSortType sort_type;
 424   GList *items;
 425   GCompareDataFunc compare_func;
 426   gint length;
 427
 428   g_return_val_if_fail (GTK_IS_RECENT_CHOOSER (chooser), NULL);
 429
 430   manager = _gtk_recent_chooser_get_recent_manager (chooser);
 431   if (!manager)
 432     return NULL;
 433
 434   items = gtk_recent_manager_get_items (manager);
 435   if (!items)
 436     return NULL;
 437
 438   limit = gtk_recent_chooser_get_limit (chooser);
 439   if (limit == 0)
 440     return NULL;
 441
 442   if (filter)
 443     {
 444       GList *filter_items, *l;
 445       gboolean local_only = FALSE;
 446       gboolean show_private = FALSE;
 447       gboolean show_not_found = FALSE;
 448
 449       g_object_get (G_OBJECT (chooser),
 450                     "local-only", &local_only,
 451                     "show-private", &show_private,
 452                     "show-not-found", &show_not_found,
 453                     NULL);
 454
 455       filter_items = NULL;
 456       for (l = items; l != NULL; l = l->next)
 457         {
 458           GtkRecentInfo *info = l->data;
 459           gboolean remove_item = FALSE;
 460
 461           if (get_is_recent_filtered (filter, info))
 462             remove_item = TRUE;
 463
 464           if (local_only && !gtk_recent_info_is_local (info))
 465             remove_item = TRUE;
 466
 467           if (!show_private && gtk_recent_info_get_private_hint (info))
 468             remove_item = TRUE;
 469
 470           if (!show_not_found && !gtk_recent_info_exists (info))
 471             remove_item = TRUE;
 472
 473           if (!remove_item)
 474             filter_items = g_list_prepend (filter_items, info);
 475           else
 476             gtk_recent_info_unref (info);
 477         }
 478
 479       g_list_free (items);
 480       items = filter_items;
 481     }
 482
 483   if (!items)
 484     return NULL;
 485
 486   sort_type = gtk_recent_chooser_get_sort_type (chooser);
 487   switch (sort_type)
 488     {
 489     case GTK_RECENT_SORT_NONE:
 490       compare_func = NULL;
 491       break;
 492     case GTK_RECENT_SORT_MRU:
 493       compare_func = (GCompareDataFunc) sort_recent_items_mru;
 494       break;
 495     case GTK_RECENT_SORT_LRU:
 496       compare_func = (GCompareDataFunc) sort_recent_items_lru;
 497       break;
 498     case GTK_RECENT_SORT_CUSTOM:
 499       compare_func = (GCompareDataFunc) sort_recent_items_proxy;
 500       break;
 501     default:
 502       g_assert_not_reached ();
 503       break;
 504     }
 505
 506   if (compare_func)
 507     {
 508       SortRecentData sort_recent;
 509
 510       sort_recent.func = sort_func;
 511       sort_recent.data = sort_data;
 512
 513       items = g_list_sort_with_data (items, compare_func, &sort_recent);
 514     }
 515
 516   length = g_list_length (items);
 517   if ((limit != -1) && (length > limit))
 518     {
 519       GList *clamp, *l;
 520
 521       clamp = g_list_nth (items, limit - 1);
 522       if (!clamp)
 523         return items;
 524
 525       l = clamp->next;
 526       clamp->next = NULL;
 527
 528       g_list_free_full (l, (GDestroyNotify) gtk_recent_info_unref);
 529     }
 530
 531   return items;
 532 }