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

   1 /* GTK - The GIMP Toolkit
   2  * gtkrecentmanager.c: a manager for the recently used resources
   3  *
   4  * Copyright (C) 2006 Emmanuele Bassi
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  */
  20
  21 /**
  22  * SECTION:gtkrecentmanager
  23  * @Title: GtkRecentManager
  24  * @short_description: Managing recently used files
  25  * @See_Also: #GBookmarkFile, #GtkSettings, #GtkRecentChooser
  26  *
  27  * #GtkRecentManager provides a facility for adding, removing and
  28  * looking up recently used files. Each recently used file is
  29  * identified by its URI, and has meta-data associated to it, like
  30  * the names and command lines of the applications that have
  31  * registered it, the number of time each application has registered
  32  * the same file, the mime type of the file and whether the file
  33  * should be displayed only by the applications that have
  34  * registered it.
  35  *
  36  * <note><para>The recently used files list is per user.</para></note>
  37  *
  38  * The #GtkRecentManager acts like a database of all the recently
  39  * used files. You can create new #GtkRecentManager objects, but
  40  * it is more efficient to use the default manager created by GTK+.
  41  *
  42  * Adding a new recently used file is as simple as:
  43  *
  44  * |[
  45  * GtkRecentManager *manager;
  46  *
  47  * manager = gtk_recent_manager_get_default ();
  48  * gtk_recent_manager_add_item (manager, file_uri);
  49  * ]|
  50  *
  51  * The #GtkRecentManager will try to gather all the needed information
  52  * from the file itself through GIO.
  53  *
  54  * Looking up the meta-data associated with a recently used file
  55  * given its URI requires calling gtk_recent_manager_lookup_item():
  56  *
  57  * |[
  58  * GtkRecentManager *manager;
  59  * GtkRecentInfo *info;
  60  * GError *error = NULL;
  61  *
  62  * manager = gtk_recent_manager_get_default ();
  63  * info = gtk_recent_manager_lookup_item (manager, file_uri, &amp;error);
  64  * if (error)
  65  *   {
  66  *     g_warning ("Could not find the file: &percnt;s", error-&gt;message);
  67  *     g_error_free (error);
  68  *   }
  69  * else
  70  *  {
  71  *    /&ast; Use the info object &ast;/
  72  *    gtk_recent_info_unref (info);
  73  *  }
  74  * ]|
  75  *
  76  * In order to retrieve the list of recently used files, you can use
  77  * gtk_recent_manager_get_items(), which returns a list of #GtkRecentInfo
  78  * structures.
  79  *
  80  * A #GtkRecentManager is the model used to populate the contents of
  81  * one, or more #GtkRecentChooser implementations.
  82  *
  83  * <note><para>The maximum age of the recently used files list is
  84  * controllable through the #GtkSettings:gtk-recent-files-max-age
  85  * property.</para></note>
  86  *
  87  * Recently used files are supported since GTK+ 2.10.
  88  */
  89
  90 #include "config.h"
  91
  92 #include <sys/types.h>
  93 #include <sys/stat.h>
  94 #ifdef HAVE_UNISTD_H
  95 #include <unistd.h>
  96 #endif
  97 #include <errno.h>
  98 #include <string.h>
  99 #include <stdlib.h>
 100 #include <glib.h>
 101 #include <glib/gstdio.h>
 102 #include <gio/gio.h>
 103
 104 #include "gtkrecentmanager.h"
 105 #include "gtkintl.h"
 106 #include "gtksettings.h"
 107 #include "gtkstock.h"
 108 #include "gtkicontheme.h"
 109 #include "gtktypebuiltins.h"
 110 #include "gtkprivate.h"
 111 #include "gtkmarshalers.h"
 112
 113 /* the file where we store the recently used items */
 114 #define GTK_RECENTLY_USED_FILE  "recently-used.xbel"
 115
 116 /* return all items by default */
 117 #define DEFAULT_LIMIT   -1
 118
 119 /* keep in sync with xdgmime */
 120 #define GTK_RECENT_DEFAULT_MIME "application/octet-stream"
 121
 122 typedef struct
 123 {
 124   gchar *name;
 125   gchar *exec;
 126
 127   guint count;
 128
 129   time_t stamp;
 130 } RecentAppInfo;
 131
 132 /**
 133  * GtkRecentInfo:
 134  *
 135  * #GtkRecentInfo is an opaque data structure
 136  * whose members can only be accessed using the provided API.
 137  *
 138  * #GtkRecentInfo constains all the meta-data
 139  * associated with an entry in the recently used files list.
 140  *
 141  * Since: 2.10
 142  */
 143 struct _GtkRecentInfo
 144 {
 145   gchar *uri;
 146
 147   gchar *display_name;
 148   gchar *description;
 149
 150   time_t added;
 151   time_t modified;
 152   time_t visited;
 153
 154   gchar *mime_type;
 155
 156   GSList *applications;
 157   GHashTable *apps_lookup;
 158
 159   GSList *groups;
 160
 161   gboolean is_private;
 162
 163   GdkPixbuf *icon;
 164
 165   gint ref_count;
 166 };
 167
 168 struct _GtkRecentManagerPrivate
 169 {
 170   gchar *filename;
 171
 172   guint is_dirty : 1;
 173
 174   gint size;
 175
 176   GBookmarkFile *recent_items;
 177
 178   GFileMonitor *monitor;
 179
 180   guint changed_timeout;
 181   guint changed_age;
 182 };
 183
 184 enum
 185 {
 186   PROP_0,
 187
 188   PROP_FILENAME,
 189   PROP_LIMIT,
 190   PROP_SIZE
 191 };
 192
 193 static void     gtk_recent_manager_dispose             (GObject           *object);
 194 static void     gtk_recent_manager_finalize            (GObject           *object);
 195 static void     gtk_recent_manager_set_property        (GObject           *object,
 196                                                         guint              prop_id,
 197                                                         const GValue      *value,
 198                                                         GParamSpec        *pspec);
 199 static void     gtk_recent_manager_get_property        (GObject           *object,
 200                                                         guint              prop_id,
 201                                                         GValue            *value,
 202                                                         GParamSpec        *pspec);
 203 static void     gtk_recent_manager_add_item_query_info (GObject           *source_object,
 204                                                         GAsyncResult      *res,
 205                                                         gpointer           user_data);
 206 static void     gtk_recent_manager_monitor_changed     (GFileMonitor      *monitor,
 207                                                         GFile             *file,
 208                                                         GFile             *other_file,
 209                                                         GFileMonitorEvent  event_type,
 210                                                         gpointer           user_data);
 211 static void     gtk_recent_manager_changed             (GtkRecentManager  *manager);
 212 static void     gtk_recent_manager_real_changed        (GtkRecentManager  *manager);
 213 static void     gtk_recent_manager_set_filename        (GtkRecentManager  *manager,
 214                                                         const gchar       *filename);
 215 static void     gtk_recent_manager_clamp_to_age        (GtkRecentManager  *manager,
 216                                                         gint               age);
 217
 218
 219 static void build_recent_items_list (GtkRecentManager  *manager);
 220 static void purge_recent_items_list (GtkRecentManager  *manager,
 221                                      GError           **error);
 222
 223 static RecentAppInfo *recent_app_info_new  (const gchar   *app_name);
 224 static void           recent_app_info_free (RecentAppInfo *app_info);
 225
 226 static GtkRecentInfo *gtk_recent_info_new  (const gchar   *uri);
 227 static void           gtk_recent_info_free (GtkRecentInfo *recent_info);
 228
 229 static guint signal_changed = 0;
 230
 231 static GtkRecentManager *recent_manager_singleton = NULL;
 232
 233 G_DEFINE_TYPE (GtkRecentManager, gtk_recent_manager, G_TYPE_OBJECT)
 234
 235 static void
 236 filename_warning (const gchar *format,
 237                   const gchar *filename,
 238                   const gchar *message)
 239 {
 240   gchar *utf8 = g_filename_to_utf8 (filename, -1, NULL, NULL, NULL);
 241   g_warning (format, utf8 ? utf8 : "(invalid filename)", message);
 242   g_free (utf8);
 243 }
 244
 245 /* Test of haystack has the needle prefix, comparing case
 246  * insensitive. haystack may be UTF-8, but needle must
 247  * contain only lowercase ascii. */
 248 static gboolean
 249 has_case_prefix (const gchar *haystack,
 250                  const gchar *needle)
 251 {
 252   const gchar *h, *n;
 253
 254   /* Eat one character at a time. */
 255   h = haystack;
 256   n = needle;
 257
 258   while (*n && *h && *n == g_ascii_tolower (*h))
 259     {
 260       n++;
 261       h++;
 262     }
 263
 264   return *n == '\0';
 265 }
 266
 267 GQuark
 268 gtk_recent_manager_error_quark (void)
 269 {
 270   return g_quark_from_static_string ("gtk-recent-manager-error-quark");
 271 }
 272
 273 static void
 274 gtk_recent_manager_class_init (GtkRecentManagerClass *klass)
 275 {
 276   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 277
 278   gobject_class->set_property = gtk_recent_manager_set_property;
 279   gobject_class->get_property = gtk_recent_manager_get_property;
 280   gobject_class->dispose = gtk_recent_manager_dispose;
 281   gobject_class->finalize = gtk_recent_manager_finalize;
 282
 283   /**
 284    * GtkRecentManager:filename
 285    *
 286    * The full path to the file to be used to store and read the recently
 287    * used resources list
 288    *
 289    * Since: 2.10
 290    */
 291   g_object_class_install_property (gobject_class,
 292                                    PROP_FILENAME,
 293                                    g_param_spec_string ("filename",
 294                                                         P_("Filename"),
 295                                                         P_("The full path to the file to be used to store and read the list"),
 296                                                         NULL,
 297                                                         (G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE)));
 298
 299   /**
 300    * GtkRecentManager:size
 301    *
 302    * The size of the recently used resources list.
 303    *
 304    * Since: 2.10
 305    */
 306   g_object_class_install_property (gobject_class,
 307                                    PROP_SIZE,
 308                                    g_param_spec_int ("size",
 309                                                      P_("Size"),
 310                                                      P_("The size of the recently used resources list"),
 311                                                      -1,
 312                                                      G_MAXINT,
 313                                                      0,
 314                                                      G_PARAM_READABLE));
 315
 316   /**
 317    * GtkRecentManager::changed
 318    * @recent_manager: the recent manager
 319    *
 320    * Emitted when the current recently used resources manager changes its
 321    * contents, either by calling gtk_recent_manager_add_item() or by another
 322    * application.
 323    *
 324    * Since: 2.10
 325    */
 326   signal_changed =
 327     g_signal_new (I_("changed"),
 328                   G_TYPE_FROM_CLASS (klass),
 329                   G_SIGNAL_RUN_FIRST,
 330                   G_STRUCT_OFFSET (GtkRecentManagerClass, changed),
 331                   NULL, NULL,
 332                   g_cclosure_marshal_VOID__VOID,
 333                   G_TYPE_NONE, 0);
 334
 335   klass->changed = gtk_recent_manager_real_changed;
 336
 337   g_type_class_add_private (klass, sizeof (GtkRecentManagerPrivate));
 338 }
 339
 340 static void
 341 gtk_recent_manager_init (GtkRecentManager *manager)
 342 {
 343   GtkRecentManagerPrivate *priv;
 344
 345   manager->priv = G_TYPE_INSTANCE_GET_PRIVATE (manager,
 346                                                GTK_TYPE_RECENT_MANAGER,
 347                                                GtkRecentManagerPrivate);
 348   priv = manager->priv;
 349
 350   priv->size = 0;
 351   priv->filename = NULL;
 352 }
 353
 354 static void
 355 gtk_recent_manager_set_property (GObject               *object,
 356                                  guint                  prop_id,
 357                                  const GValue          *value,
 358                                  GParamSpec            *pspec)
 359 {
 360   GtkRecentManager *recent_manager = GTK_RECENT_MANAGER (object);
 361
 362   switch (prop_id)
 363     {
 364     case PROP_FILENAME:
 365       gtk_recent_manager_set_filename (recent_manager, g_value_get_string (value));
 366       break;
 367     default:
 368       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 369       break;
 370     }
 371 }
 372
 373 static void
 374 gtk_recent_manager_get_property (GObject               *object,
 375                                  guint                  prop_id,
 376                                  GValue                *value,
 377                                  GParamSpec            *pspec)
 378 {
 379   GtkRecentManager *recent_manager = GTK_RECENT_MANAGER (object);
 380
 381   switch (prop_id)
 382     {
 383     case PROP_FILENAME:
 384       g_value_set_string (value, recent_manager->priv->filename);
 385       break;
 386     case PROP_SIZE:
 387       g_value_set_int (value, recent_manager->priv->size);
 388       break;
 389     default:
 390       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 391       break;
 392     }
 393 }
 394
 395 static void
 396 gtk_recent_manager_finalize (GObject *object)
 397 {
 398   GtkRecentManager *manager = GTK_RECENT_MANAGER (object);
 399   GtkRecentManagerPrivate *priv = manager->priv;
 400
 401   g_free (priv->filename);
 402
 403   if (priv->recent_items != NULL)
 404     g_bookmark_file_free (priv->recent_items);
 405
 406   G_OBJECT_CLASS (gtk_recent_manager_parent_class)->finalize (object);
 407 }
 408
 409 static void
 410 gtk_recent_manager_dispose (GObject *gobject)
 411 {
 412   GtkRecentManager *manager = GTK_RECENT_MANAGER (gobject);
 413   GtkRecentManagerPrivate *priv = manager->priv;
 414
 415   if (priv->monitor != NULL)
 416     {
 417       g_signal_handlers_disconnect_by_func (priv->monitor,
 418                                             G_CALLBACK (gtk_recent_manager_monitor_changed),
 419                                             manager);
 420       g_object_unref (priv->monitor);
 421       priv->monitor = NULL;
 422     }
 423
 424   if (priv->changed_timeout != 0)
 425     {
 426       g_source_remove (priv->changed_timeout);
 427       priv->changed_timeout = 0;
 428       priv->changed_age = 0;
 429     }
 430
 431   if (priv->is_dirty)
 432     {
 433       g_object_ref (manager);
 434       g_signal_emit (manager, signal_changed, 0);
 435       g_object_unref (manager);
 436     }
 437
 438   G_OBJECT_CLASS (gtk_recent_manager_parent_class)->dispose (gobject);
 439 }
 440
 441 static void
 442 gtk_recent_manager_real_changed (GtkRecentManager *manager)
 443 {
 444   GtkRecentManagerPrivate *priv = manager->priv;
 445
 446   g_object_freeze_notify (G_OBJECT (manager));
 447
 448   if (priv->is_dirty)
 449     {
 450       GError *write_error;
 451
 452       /* we are marked as dirty, so we dump the content of our
 453        * recently used items list
 454        */
 455       g_assert (priv->filename != NULL);
 456
 457       if (!priv->recent_items)
 458         {
 459           /* if no container object has been defined, we create a new
 460            * empty container, and dump it
 461            */
 462           priv->recent_items = g_bookmark_file_new ();
 463           priv->size = 0;
 464         }
 465       else
 466         {
 467           GtkSettings *settings = gtk_settings_get_default ();
 468           gint age = 30;
 469
 470           g_object_get (G_OBJECT (settings), "gtk-recent-files-max-age", &age, NULL);
 471           if (age > 0)
 472             gtk_recent_manager_clamp_to_age (manager, age);
 473           else if (age == 0)
 474             {
 475               g_bookmark_file_free (priv->recent_items);
 476               priv->recent_items = g_bookmark_file_new ();
 477             }
 478         }
 479
 480       write_error = NULL;
 481       g_bookmark_file_to_file (priv->recent_items, priv->filename, &write_error);
 482       if (write_error)
 483         {
 484           filename_warning ("Attempting to store changes into `%s', "
 485                             "but failed: %s",
 486                             priv->filename,
 487                             write_error->message);
 488           g_error_free (write_error);
 489         }
 490
 491       if (g_chmod (priv->filename, 0600) < 0)
 492         {
 493           filename_warning ("Attempting to set the permissions of `%s', "
 494                             "but failed: %s",
 495                             priv->filename,
 496                             g_strerror (errno));
 497         }
 498
 499       /* mark us as clean */
 500       priv->is_dirty = FALSE;
 501     }
 502   else
 503     {
 504       /* we are not marked as dirty, so we have been called
 505        * because the recently used resources file has been
 506        * changed (and not from us).
 507        */
 508       build_recent_items_list (manager);
 509     }
 510
 511   g_object_thaw_notify (G_OBJECT (manager));
 512 }
 513
 514 static void
 515 gtk_recent_manager_monitor_changed (GFileMonitor      *monitor,
 516                                     GFile             *file,
 517                                     GFile             *other_file,
 518                                     GFileMonitorEvent  event_type,
 519                                     gpointer           user_data)
 520 {
 521   GtkRecentManager *manager = user_data;
 522
 523   switch (event_type)
 524     {
 525     case G_FILE_MONITOR_EVENT_CHANGED:
 526     case G_FILE_MONITOR_EVENT_CREATED:
 527       gtk_recent_manager_changed (manager);
 528       break;
 529
 530     case G_FILE_MONITOR_EVENT_DELETED:
 531       break;
 532
 533     default:
 534       break;
 535     }
 536 }
 537
 538 static gchar *
 539 get_default_filename (void)
 540 {
 541   return g_build_filename (g_get_user_data_dir (),
 542                            GTK_RECENTLY_USED_FILE,
 543                            NULL);
 544 }
 545
 546 static void
 547 gtk_recent_manager_set_filename (GtkRecentManager *manager,
 548                                  const gchar      *filename)
 549 {
 550   GtkRecentManagerPrivate *priv;
 551   GFile *file;
 552   GError *error;
 553
 554   g_assert (GTK_IS_RECENT_MANAGER (manager));
 555
 556   priv = manager->priv;
 557
 558   /* if a filename is already set and filename is not NULL, then copy
 559    * it and reset the monitor; otherwise, if it's NULL we're being
 560    * called from the finalization sequence, so we simply disconnect the
 561    * monitoring and return.
 562    *
 563    * if no filename is set and filename is NULL, use the default.
 564    */
 565   if (priv->filename)
 566     {
 567       g_free (priv->filename);
 568
 569       if (priv->monitor)
 570         {
 571           g_signal_handlers_disconnect_by_func (priv->monitor,
 572                                                 G_CALLBACK (gtk_recent_manager_monitor_changed),
 573                                                 manager);
 574           g_object_unref (priv->monitor);
 575           priv->monitor = NULL;
 576         }
 577
 578       if (!filename || *filename == '\0')
 579         return;
 580       else
 581         priv->filename = g_strdup (filename);
 582     }
 583   else
 584     {
 585       if (!filename || *filename == '\0')
 586         priv->filename = get_default_filename ();
 587       else
 588         priv->filename = g_strdup (filename);
 589     }
 590
 591   g_assert (priv->filename != NULL);
 592   file = g_file_new_for_path (priv->filename);
 593
 594   error = NULL;
 595   priv->monitor = g_file_monitor_file (file, G_FILE_MONITOR_NONE, NULL, &error);
 596   if (error)
 597     {
 598       filename_warning ("Unable to monitor `%s': %s\n"
 599                         "The GtkRecentManager will not update its contents "
 600                         "if the file is changed from other instances",
 601                         priv->filename,
 602                         error->message);
 603       g_error_free (error);
 604     }
 605   else
 606     g_signal_connect (priv->monitor, "changed",
 607                       G_CALLBACK (gtk_recent_manager_monitor_changed),
 608                       manager);
 609
 610   g_object_unref (file);
 611
 612   priv->is_dirty = FALSE;
 613   build_recent_items_list (manager);
 614 }
 615
 616 /* reads the recently used resources file and builds the items list.
 617  * we keep the items list inside the parser object, and build the
 618  * RecentInfo object only on user's demand to avoid useless replication.
 619  * this function resets the dirty bit of the manager.
 620  */
 621 static void
 622 build_recent_items_list (GtkRecentManager *manager)
 623 {
 624   GtkRecentManagerPrivate *priv = manager->priv;
 625   GError *read_error;
 626   gint size;
 627
 628   g_assert (priv->filename != NULL);
 629
 630   if (!priv->recent_items)
 631     {
 632       priv->recent_items = g_bookmark_file_new ();
 633       priv->size = 0;
 634     }
 635
 636   /* the file exists, and it's valid (we hope); if not, destroy the container
 637    * object and hope for a better result when the next "changed" signal is
 638    * fired. */
 639   read_error = NULL;
 640   g_bookmark_file_load_from_file (priv->recent_items, priv->filename, &read_error);
 641   if (read_error)
 642     {
 643       /* if the file does not exist we just wait for the first write
 644        * operation on this recent manager instance, to avoid creating
 645        * empty files and leading to spurious file system events (Sabayon
 646        * will not be happy about those)
 647        */
 648       if (read_error->domain == G_FILE_ERROR &&
 649           read_error->code != G_FILE_ERROR_NOENT)
 650         filename_warning ("Attempting to read the recently used resources "
 651                           "file at `%s', but the parser failed: %s.",
 652                           priv->filename,
 653                           read_error->message);
 654
 655       g_bookmark_file_free (priv->recent_items);
 656       priv->recent_items = NULL;
 657
 658       g_error_free (read_error);
 659     }
 660   else
 661     {
 662       size = g_bookmark_file_get_size (priv->recent_items);
 663       if (priv->size != size)
 664         {
 665           priv->size = size;
 666
 667           g_object_notify (G_OBJECT (manager), "size");
 668         }
 669     }
 670
 671   priv->is_dirty = FALSE;
 672 }
 673
 674
 675 /********************
 676  * GtkRecentManager *
 677  ********************/
 678
 679
 680 /**
 681  * gtk_recent_manager_new:
 682  *
 683  * Creates a new recent manager object.  Recent manager objects are used to
 684  * handle the list of recently used resources.  A #GtkRecentManager object
 685  * monitors the recently used resources list, and emits the "changed" signal
 686  * each time something inside the list changes.
 687  *
 688  * #GtkRecentManager objects are expensive: be sure to create them only when
 689  * needed. You should use gtk_recent_manager_get_default() instead.
 690  *
 691  * Return value: A newly created #GtkRecentManager object.
 692  *
 693  * Since: 2.10
 694  */
 695 GtkRecentManager *
 696 gtk_recent_manager_new (void)
 697 {
 698   return g_object_new (GTK_TYPE_RECENT_MANAGER, NULL);
 699 }
 700
 701 /**
 702  * gtk_recent_manager_get_default:
 703  *
 704  * Gets a unique instance of #GtkRecentManager, that you can share
 705  * in your application without caring about memory management.
 706  *
 707  * Return value: (transfer none): A unique #GtkRecentManager. Do not ref or unref it.
 708  *
 709  * Since: 2.10
 710  */
 711 GtkRecentManager *
 712 gtk_recent_manager_get_default (void)
 713 {
 714   if (G_UNLIKELY (!recent_manager_singleton))
 715     recent_manager_singleton = gtk_recent_manager_new ();
 716
 717   return recent_manager_singleton;
 718 }
 719
 720
 721 static void
 722 gtk_recent_manager_add_item_query_info (GObject      *source_object,
 723                                         GAsyncResult *res,
 724                                         gpointer      user_data)
 725 {
 726   GFile *file = G_FILE (source_object);
 727   GtkRecentManager *manager = user_data;
 728   GtkRecentData recent_data;
 729   GFileInfo *file_info;
 730   gchar *uri;
 731   GError *error;
 732
 733   uri = g_file_get_uri (file);
 734
 735   error = NULL;
 736   file_info = g_file_query_info_finish (file, res, &error);
 737   if (error)
 738     {
 739       g_warning ("Unable to retrieve the file info for `%s': %s",
 740                  uri,
 741                  error->message);
 742       g_error_free (error);
 743       goto out;
 744     }
 745
 746   recent_data.display_name = NULL;
 747   recent_data.description = NULL;
 748
 749   if (file_info)
 750     {
 751       gchar *content_type;
 752
 753       content_type = g_file_info_get_attribute_as_string (file_info, G_FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE);
 754
 755       if (G_LIKELY (content_type))
 756         recent_data.mime_type = g_content_type_get_mime_type (content_type);
 757       else
 758         recent_data.mime_type = g_strdup (GTK_RECENT_DEFAULT_MIME);
 759
 760       g_free (content_type);
 761       g_object_unref (file_info);
 762     }
 763   else
 764     recent_data.mime_type = g_strdup (GTK_RECENT_DEFAULT_MIME);
 765
 766   recent_data.app_name = g_strdup (g_get_application_name ());
 767   recent_data.app_exec = g_strjoin (" ", g_get_prgname (), "%u", NULL);
 768   recent_data.groups = NULL;
 769   recent_data.is_private = FALSE;
 770
 771   /* Ignore return value, this can't fail anyway since all required
 772    * fields are set */
 773   gtk_recent_manager_add_full (manager, uri, &recent_data);
 774
 775   manager->priv->is_dirty = TRUE;
 776   gtk_recent_manager_changed (manager);
 777
 778   g_free (recent_data.mime_type);
 779   g_free (recent_data.app_name);
 780   g_free (recent_data.app_exec);
 781
 782 out:
 783   g_object_unref (manager);
 784   g_free (uri);
 785 }
 786
 787 /**
 788  * gtk_recent_manager_add_item:
 789  * @manager: a #GtkRecentManager
 790  * @uri: a valid URI
 791  *
 792  * Adds a new resource, pointed by @uri, into the recently used
 793  * resources list.
 794  *
 795  * This function automatically retrieves some of the needed
 796  * metadata and setting other metadata to common default values; it
 797  * then feeds the data to gtk_recent_manager_add_full().
 798  *
 799  * See gtk_recent_manager_add_full() if you want to explicitly
 800  * define the metadata for the resource pointed by @uri.
 801  *
 802  * Return value: %TRUE if the new item was successfully added
 803  *   to the recently used resources list
 804  *
 805  * Since: 2.10
 806  */
 807 gboolean
 808 gtk_recent_manager_add_item (GtkRecentManager  *manager,
 809                              const gchar       *uri)
 810 {
 811   GFile* file;
 812
 813   g_return_val_if_fail (GTK_IS_RECENT_MANAGER (manager), FALSE);
 814   g_return_val_if_fail (uri != NULL, FALSE);
 815
 816   file = g_file_new_for_uri (uri);
 817
 818   g_file_query_info_async (file,
 819                            G_FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE,
 820                            G_PRIORITY_DEFAULT,
 821                            G_FILE_QUERY_INFO_NONE,
 822                            NULL,
 823                            gtk_recent_manager_add_item_query_info,
 824                            g_object_ref (manager));
 825
 826   g_object_unref (file);
 827
 828   return TRUE;
 829 }
 830
 831 /**
 832  * gtk_recent_manager_add_full:
 833  * @manager: a #GtkRecentManager
 834  * @uri: a valid URI
 835  * @recent_data: metadata of the resource
 836  *
 837  * Adds a new resource, pointed by @uri, into the recently used
 838  * resources list, using the metadata specified inside the #GtkRecentData
 839  * structure passed in @recent_data.
 840  *
 841  * The passed URI will be used to identify this resource inside the
 842  * list.
 843  *
 844  * In order to register the new recently used resource, metadata about
 845  * the resource must be passed as well as the URI; the metadata is
 846  * stored in a #GtkRecentData structure, which must contain the MIME
 847  * type of the resource pointed by the URI; the name of the application
 848  * that is registering the item, and a command line to be used when
 849  * launching the item.
 850  *
 851  * Optionally, a #GtkRecentData structure might contain a UTF-8 string
 852  * to be used when viewing the item instead of the last component of the
 853  * URI; a short description of the item; whether the item should be
 854  * considered private - that is, should be displayed only by the
 855  * applications that have registered it.
 856  *
 857  * Return value: %TRUE if the new item was successfully added to the
 858  * recently used resources list, %FALSE otherwise.
 859  *
 860  * Since: 2.10
 861  */
 862 gboolean
 863 gtk_recent_manager_add_full (GtkRecentManager     *manager,
 864                              const gchar          *uri,
 865                              const GtkRecentData  *data)
 866 {
 867   GtkRecentManagerPrivate *priv;
 868
 869   g_return_val_if_fail (GTK_IS_RECENT_MANAGER (manager), FALSE);
 870   g_return_val_if_fail (uri != NULL, FALSE);
 871   g_return_val_if_fail (data != NULL, FALSE);
 872
 873   /* sanity checks */
 874   if ((data->display_name) &&
 875       (!g_utf8_validate (data->display_name, -1, NULL)))
 876     {
 877       g_warning ("Attempting to add `%s' to the list of recently used "
 878                  "resources, but the display name is not a valid UTF-8 "
 879                  "encoded string",
 880                  uri);
 881       return FALSE;
 882     }
 883
 884   if ((data->description) &&
 885       (!g_utf8_validate (data->description, -1, NULL)))
 886     {
 887       g_warning ("Attempting to add `%s' to the list of recently used "
 888                  "resources, but the description is not a valid UTF-8 "
 889                  "encoded string",
 890                  uri);
 891       return FALSE;
 892     }
 893
 894
 895   if (!data->mime_type)
 896     {
 897       g_warning ("Attempting to add `%s' to the list of recently used "
 898                  "resources, but not MIME type was defined",
 899                  uri);
 900       return FALSE;
 901     }
 902
 903   if (!data->app_name)
 904     {
 905       g_warning ("Attempting to add `%s' to the list of recently used "
 906                  "resources, but no name of the application that is "
 907                  "registering it was defined",
 908                  uri);
 909       return FALSE;
 910     }
 911
 912   if (!data->app_exec)
 913     {
 914       g_warning ("Attempting to add `%s' to the list of recently used "
 915                  "resources, but no command line for the application "
 916                  "that is registering it was defined",
 917                  uri);
 918       return FALSE;
 919     }
 920
 921   priv = manager->priv;
 922
 923   if (!priv->recent_items)
 924     {
 925       priv->recent_items = g_bookmark_file_new ();
 926       priv->size = 0;
 927     }
 928
 929   if (data->display_name)
 930     g_bookmark_file_set_title (priv->recent_items, uri, data->display_name);
 931
 932   if (data->description)
 933     g_bookmark_file_set_description (priv->recent_items, uri, data->description);
 934
 935   g_bookmark_file_set_mime_type (priv->recent_items, uri, data->mime_type);
 936
 937   if (data->groups && data->groups[0] != '\0')
 938     {
 939       gint j;
 940
 941       for (j = 0; (data->groups)[j] != NULL; j++)
 942         g_bookmark_file_add_group (priv->recent_items, uri, (data->groups)[j]);
 943     }
 944
 945   /* register the application; this will take care of updating the
 946    * registration count and time in case the application has
 947    * already registered the same document inside the list
 948    */
 949   g_bookmark_file_add_application (priv->recent_items, uri,
 950                                    data->app_name,
 951                                    data->app_exec);
 952
 953   g_bookmark_file_set_is_private (priv->recent_items, uri,
 954                                   data->is_private);
 955
 956   /* mark us as dirty, so that when emitting the "changed" signal we
 957    * will dump our changes
 958    */
 959   priv->is_dirty = TRUE;
 960   gtk_recent_manager_changed (manager);
 961
 962   return TRUE;
 963 }
 964
 965 /**
 966  * gtk_recent_manager_remove_item:
 967  * @manager: a #GtkRecentManager
 968  * @uri: the URI of the item you wish to remove
 969  * @error: (allow-none): return location for a #GError, or %NULL
 970  *
 971  * Removes a resource pointed by @uri from the recently used resources
 972  * list handled by a recent manager.
 973  *
 974  * Return value: %TRUE if the item pointed by @uri has been successfully
 975  *   removed by the recently used resources list, and %FALSE otherwise.
 976  *
 977  * Since: 2.10
 978  */
 979 gboolean
 980 gtk_recent_manager_remove_item (GtkRecentManager  *manager,
 981                                 const gchar       *uri,
 982                                 GError           **error)
 983 {
 984   GtkRecentManagerPrivate *priv;
 985   GError *remove_error = NULL;
 986
 987   g_return_val_if_fail (GTK_IS_RECENT_MANAGER (manager), FALSE);
 988   g_return_val_if_fail (uri != NULL, FALSE);
 989   g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
 990
 991   priv = manager->priv;
 992
 993   if (!priv->recent_items)
 994     {
 995       priv->recent_items = g_bookmark_file_new ();
 996       priv->size = 0;
 997
 998       g_set_error (error, GTK_RECENT_MANAGER_ERROR,
 999                    GTK_RECENT_MANAGER_ERROR_NOT_FOUND,
1000                    _("Unable to find an item with URI '%s'"),
1001                    uri);
1002
1003       return FALSE;
1004     }
1005
1006   g_bookmark_file_remove_item (priv->recent_items, uri, &remove_error);
1007   if (remove_error)
1008     {
1009       g_error_free (remove_error);
1010
1011       g_set_error (error, GTK_RECENT_MANAGER_ERROR,
1012                    GTK_RECENT_MANAGER_ERROR_NOT_FOUND,
1013                    _("Unable to find an item with URI '%s'"),
1014                    uri);
1015
1016       return FALSE;
1017     }
1018
1019   priv->is_dirty = TRUE;
1020   gtk_recent_manager_changed (manager);
1021
1022   return TRUE;
1023 }
1024
1025 /**
1026  * gtk_recent_manager_has_item:
1027  * @manager: a #GtkRecentManager
1028  * @uri: a URI
1029  *
1030  * Checks whether there is a recently used resource registered
1031  * with @uri inside the recent manager.
1032  *
1033  * Return value: %TRUE if the resource was found, %FALSE otherwise.
1034  *
1035  * Since: 2.10
1036  */
1037 gboolean
1038 gtk_recent_manager_has_item (GtkRecentManager *manager,
1039                              const gchar      *uri)
1040 {
1041   GtkRecentManagerPrivate *priv;
1042
1043   g_return_val_if_fail (GTK_IS_RECENT_MANAGER (manager), FALSE);
1044   g_return_val_if_fail (uri != NULL, FALSE);
1045
1046   priv = manager->priv;
1047   g_return_val_if_fail (priv->recent_items != NULL, FALSE);
1048
1049   return g_bookmark_file_has_item (priv->recent_items, uri);
1050 }
1051
1052 static void
1053 build_recent_info (GBookmarkFile  *bookmarks,
1054                    GtkRecentInfo  *info)
1055 {
1056   gchar **apps, **groups;
1057   gsize apps_len, groups_len, i;
1058
1059   g_assert (bookmarks != NULL);
1060   g_assert (info != NULL);
1061
1062   info->display_name = g_bookmark_file_get_title (bookmarks, info->uri, NULL);
1063   info->description = g_bookmark_file_get_description (bookmarks, info->uri, NULL);
1064   info->mime_type = g_bookmark_file_get_mime_type (bookmarks, info->uri, NULL);
1065
1066   info->is_private = g_bookmark_file_get_is_private (bookmarks, info->uri, NULL);
1067
1068   info->added = g_bookmark_file_get_added (bookmarks, info->uri, NULL);
1069   info->modified = g_bookmark_file_get_modified (bookmarks, info->uri, NULL);
1070   info->visited = g_bookmark_file_get_visited (bookmarks, info->uri, NULL);
1071
1072   groups = g_bookmark_file_get_groups (bookmarks, info->uri, &groups_len, NULL);
1073   for (i = 0; i < groups_len; i++)
1074     {
1075       gchar *group_name = g_strdup (groups[i]);
1076
1077       info->groups = g_slist_append (info->groups, group_name);
1078     }
1079
1080   g_strfreev (groups);
1081
1082   apps = g_bookmark_file_get_applications (bookmarks, info->uri, &apps_len, NULL);
1083   for (i = 0; i < apps_len; i++)
1084     {
1085       gchar *app_name, *app_exec;
1086       guint count;
1087       time_t stamp;
1088       RecentAppInfo *app_info;
1089       gboolean res;
1090
1091       app_name = apps[i];
1092
1093       res = g_bookmark_file_get_app_info (bookmarks, info->uri, app_name,
1094                                           &app_exec,
1095                                           &count,
1096                                           &stamp,
1097                                           NULL);
1098       if (!res)
1099         continue;
1100
1101       app_info = recent_app_info_new (app_name);
1102       app_info->exec = app_exec;
1103       app_info->count = count;
1104       app_info->stamp = stamp;
1105
1106       info->applications = g_slist_prepend (info->applications, app_info);
1107       g_hash_table_replace (info->apps_lookup, app_info->name, app_info);
1108     }
1109
1110   g_strfreev (apps);
1111 }
1112
1113 /**
1114  * gtk_recent_manager_lookup_item:
1115  * @manager: a #GtkRecentManager
1116  * @uri: a URI
1117  * @error: (allow-none): a return location for a #GError, or %NULL
1118  *
1119  * Searches for a URI inside the recently used resources list, and
1120  * returns a structure containing informations about the resource
1121  * like its MIME type, or its display name.
1122  *
1123  * Return value: a #GtkRecentInfo structure containing information
1124  *   about the resource pointed by @uri, or %NULL if the URI was
1125  *   not registered in the recently used resources list.  Free with
1126  *   gtk_recent_info_unref().
1127  *
1128  * Since: 2.10
1129  */
1130 GtkRecentInfo *
1131 gtk_recent_manager_lookup_item (GtkRecentManager  *manager,
1132                                 const gchar       *uri,
1133                                 GError           **error)
1134 {
1135   GtkRecentManagerPrivate *priv;
1136   GtkRecentInfo *info = NULL;
1137
1138   g_return_val_if_fail (GTK_IS_RECENT_MANAGER (manager), NULL);
1139   g_return_val_if_fail (uri != NULL, NULL);
1140   g_return_val_if_fail (error == NULL || *error == NULL, NULL);
1141
1142   priv = manager->priv;
1143   if (!priv->recent_items)
1144     {
1145       priv->recent_items = g_bookmark_file_new ();
1146       priv->size = 0;
1147
1148       g_set_error (error, GTK_RECENT_MANAGER_ERROR,
1149                    GTK_RECENT_MANAGER_ERROR_NOT_FOUND,
1150                    _("Unable to find an item with URI '%s'"),
1151                    uri);
1152
1153       return NULL;
1154     }
1155
1156   if (!g_bookmark_file_has_item (priv->recent_items, uri))
1157     {
1158       g_set_error (error, GTK_RECENT_MANAGER_ERROR,
1159                    GTK_RECENT_MANAGER_ERROR_NOT_FOUND,
1160                    _("Unable to find an item with URI '%s'"),
1161                    uri);
1162       return NULL;
1163     }
1164
1165   info = gtk_recent_info_new (uri);
1166   g_return_val_if_fail (info != NULL, NULL);
1167
1168   /* fill the RecentInfo structure with the data retrieved by our
1169    * parser object from the storage file
1170    */
1171   build_recent_info (priv->recent_items, info);
1172
1173   return info;
1174 }
1175
1176 /**
1177  * gtk_recent_manager_move_item:
1178  * @manager: a #GtkRecentManager
1179  * @uri: the URI of a recently used resource
1180  * @new_uri: (allow-none): the new URI of the recently used resource, or %NULL to
1181  *    remove the item pointed by @uri in the list
1182  * @error: (allow-none): a return location for a #GError, or %NULL
1183  *
1184  * Changes the location of a recently used resource from @uri to @new_uri.
1185  *
1186  * Please note that this function will not affect the resource pointed
1187  * by the URIs, but only the URI used in the recently used resources list.
1188  *
1189  * Return value: %TRUE on success.
1190  *
1191  * Since: 2.10
1192  */
1193 gboolean
1194 gtk_recent_manager_move_item (GtkRecentManager  *recent_manager,
1195                               const gchar       *uri,
1196                               const gchar       *new_uri,
1197                               GError           **error)
1198 {
1199   GtkRecentManagerPrivate *priv;
1200   GError *move_error;
1201
1202   g_return_val_if_fail (GTK_IS_RECENT_MANAGER (recent_manager), FALSE);
1203   g_return_val_if_fail (uri != NULL, FALSE);
1204   g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
1205
1206   priv = recent_manager->priv;
1207
1208   if (!priv->recent_items)
1209     {
1210       g_set_error (error, GTK_RECENT_MANAGER_ERROR,
1211                    GTK_RECENT_MANAGER_ERROR_NOT_FOUND,
1212                    _("Unable to find an item with URI '%s'"),
1213                    uri);
1214       return FALSE;
1215     }
1216
1217   if (!g_bookmark_file_has_item (priv->recent_items, uri))
1218     {
1219       g_set_error (error, GTK_RECENT_MANAGER_ERROR,
1220                    GTK_RECENT_MANAGER_ERROR_NOT_FOUND,
1221                    _("Unable to find an item with URI '%s'"),
1222                    uri);
1223       return FALSE;
1224     }
1225
1226   move_error = NULL;
1227   if (!g_bookmark_file_move_item (priv->recent_items,
1228                                   uri,
1229                                   new_uri,
1230                                   &move_error))
1231     {
1232       g_error_free (move_error);
1233
1234       g_set_error (error, GTK_RECENT_MANAGER_ERROR,
1235                    GTK_RECENT_MANAGER_ERROR_NOT_FOUND,
1236                    _("Unable to find an item with URI '%s'"),
1237                    uri);
1238       return FALSE;
1239     }
1240
1241   priv->is_dirty = TRUE;
1242   gtk_recent_manager_changed (recent_manager);
1243
1244   return TRUE;
1245 }
1246
1247 /**
1248  * gtk_recent_manager_get_items:
1249  * @manager: a #GtkRecentManager
1250  *
1251  * Gets the list of recently used resources.
1252  *
1253  * Return value:  (element-type GtkRecentInfo) (transfer full): a list of
1254  *   newly allocated #GtkRecentInfo objects. Use
1255  *   gtk_recent_info_unref() on each item inside the list, and then
1256  *   free the list itself using g_list_free().
1257  *
1258  * Since: 2.10
1259  */
1260 GList *
1261 gtk_recent_manager_get_items (GtkRecentManager *manager)
1262 {
1263   GtkRecentManagerPrivate *priv;
1264   GList *retval = NULL;
1265   gchar **uris;
1266   gsize uris_len, i;
1267
1268   g_return_val_if_fail (GTK_IS_RECENT_MANAGER (manager), NULL);
1269
1270   priv = manager->priv;
1271   if (!priv->recent_items)
1272     return NULL;
1273
1274   uris = g_bookmark_file_get_uris (priv->recent_items, &uris_len);
1275   for (i = 0; i < uris_len; i++)
1276     {
1277       GtkRecentInfo *info;
1278
1279       info = gtk_recent_info_new (uris[i]);
1280       build_recent_info (priv->recent_items, info);
1281
1282       retval = g_list_prepend (retval, info);
1283     }
1284
1285   g_strfreev (uris);
1286
1287   return retval;
1288 }
1289
1290 static void
1291 purge_recent_items_list (GtkRecentManager  *manager,
1292                          GError           **error)
1293 {
1294   GtkRecentManagerPrivate *priv = manager->priv;
1295
1296   if (priv->recent_items == NULL)
1297     return;
1298
1299   g_bookmark_file_free (priv->recent_items);
1300   priv->recent_items = g_bookmark_file_new ();
1301   priv->size = 0;
1302
1303   /* emit the changed signal, to ensure that the purge is written */
1304   priv->is_dirty = TRUE;
1305   gtk_recent_manager_changed (manager);
1306 }
1307
1308 /**
1309  * gtk_recent_manager_purge_items:
1310  * @manager: a #GtkRecentManager
1311  * @error: (allow-none): a return location for a #GError, or %NULL
1312  *
1313  * Purges every item from the recently used resources list.
1314  *
1315  * Return value: the number of items that have been removed from the
1316  *   recently used resources list.
1317  *
1318  * Since: 2.10
1319  */
1320 gint
1321 gtk_recent_manager_purge_items (GtkRecentManager  *manager,
1322                                 GError           **error)
1323 {
1324   GtkRecentManagerPrivate *priv;
1325   gint count, purged;
1326
1327   g_return_val_if_fail (GTK_IS_RECENT_MANAGER (manager), -1);
1328
1329   priv = manager->priv;
1330   if (!priv->recent_items)
1331     return 0;
1332
1333   count = g_bookmark_file_get_size (priv->recent_items);
1334   if (!count)
1335     return 0;
1336
1337   purge_recent_items_list (manager, error);
1338
1339   purged = count - g_bookmark_file_get_size (priv->recent_items);
1340
1341   return purged;
1342 }
1343
1344 static gboolean
1345 emit_manager_changed (gpointer data)
1346 {
1347   GtkRecentManager *manager = data;
1348
1349   manager->priv->changed_age = 0;
1350   manager->priv->changed_timeout = 0;
1351
1352   g_signal_emit (manager, signal_changed, 0);
1353
1354   return FALSE;
1355 }
1356
1357 static void
1358 gtk_recent_manager_changed (GtkRecentManager *manager)
1359 {
1360   /* coalesce consecutive changes
1361    *
1362    * we schedule a write in 250 msecs immediately; if we get more than one
1363    * request per millisecond before the timeout has a chance to run, we
1364    * schedule an emission immediately.
1365    */
1366   if (manager->priv->changed_timeout == 0)
1367     manager->priv->changed_timeout = gdk_threads_add_timeout (250, emit_manager_changed, manager);
1368   else
1369     {
1370       manager->priv->changed_age += 1;
1371
1372       if (manager->priv->changed_age > 250)
1373         {
1374           g_source_remove (manager->priv->changed_timeout);
1375           g_signal_emit (manager, signal_changed, 0);
1376
1377           manager->priv->changed_age = 0;
1378           manager->priv->changed_timeout = 0;
1379         }
1380     }
1381 }
1382
1383 static void
1384 gtk_recent_manager_clamp_to_age (GtkRecentManager *manager,
1385                                  gint              age)
1386 {
1387   GtkRecentManagerPrivate *priv = manager->priv;
1388   gchar **uris;
1389   gsize n_uris, i;
1390   time_t now;
1391
1392   if (G_UNLIKELY (!priv->recent_items))
1393     return;
1394
1395   now = time (NULL);
1396
1397   uris = g_bookmark_file_get_uris (priv->recent_items, &n_uris);
1398
1399   for (i = 0; i < n_uris; i++)
1400     {
1401       const gchar *uri = uris[i];
1402       time_t modified;
1403       gint item_age;
1404
1405       modified = g_bookmark_file_get_modified (priv->recent_items, uri, NULL);
1406       item_age = (gint) ((now - modified) / (60 * 60 * 24));
1407       if (item_age > age)
1408         g_bookmark_file_remove_item (priv->recent_items, uri, NULL);
1409     }
1410
1411   g_strfreev (uris);
1412 }
1413
1414 /*****************
1415  * GtkRecentInfo *
1416  *****************/
1417
1418 G_DEFINE_BOXED_TYPE (GtkRecentInfo, gtk_recent_info,
1419                      gtk_recent_info_ref,
1420                      gtk_recent_info_unref)
1421
1422 static GtkRecentInfo *
1423 gtk_recent_info_new (const gchar *uri)
1424 {
1425   GtkRecentInfo *info;
1426
1427   g_assert (uri != NULL);
1428
1429   info = g_new0 (GtkRecentInfo, 1);
1430   info->uri = g_strdup (uri);
1431
1432   info->applications = NULL;
1433   info->apps_lookup = g_hash_table_new (g_str_hash, g_str_equal);
1434
1435   info->groups = NULL;
1436
1437   info->ref_count = 1;
1438
1439   return info;
1440 }
1441
1442 static void
1443 gtk_recent_info_free (GtkRecentInfo *recent_info)
1444 {
1445   if (!recent_info)
1446     return;
1447
1448   g_free (recent_info->uri);
1449   g_free (recent_info->display_name);
1450   g_free (recent_info->description);
1451   g_free (recent_info->mime_type);
1452
1453   if (recent_info->applications)
1454     {
1455       g_slist_foreach (recent_info->applications,
1456                        (GFunc) recent_app_info_free,
1457                        NULL);
1458       g_slist_free (recent_info->applications);
1459
1460       recent_info->applications = NULL;
1461     }
1462
1463   if (recent_info->apps_lookup)
1464     g_hash_table_destroy (recent_info->apps_lookup);
1465
1466   if (recent_info->groups)
1467     {
1468       g_slist_foreach (recent_info->groups,
1469                        (GFunc) g_free,
1470                        NULL);
1471       g_slist_free (recent_info->groups);
1472
1473       recent_info->groups = NULL;
1474     }
1475
1476   if (recent_info->icon)
1477     g_object_unref (recent_info->icon);
1478
1479   g_free (recent_info);
1480 }
1481
1482 /**
1483  * gtk_recent_info_ref:
1484  * @info: a #GtkRecentInfo
1485  *
1486  * Increases the reference count of @recent_info by one.
1487  *
1488  * Return value: the recent info object with its reference count increased
1489  *   by one.
1490  *
1491  * Since: 2.10
1492  */
1493 GtkRecentInfo *
1494 gtk_recent_info_ref (GtkRecentInfo *info)
1495 {
1496   g_return_val_if_fail (info != NULL, NULL);
1497   g_return_val_if_fail (info->ref_count > 0, NULL);
1498
1499   info->ref_count += 1;
1500
1501   return info;
1502 }
1503
1504 /**
1505  * gtk_recent_info_unref:
1506  * @info: a #GtkRecentInfo
1507  *
1508  * Decreases the reference count of @info by one.  If the reference
1509  * count reaches zero, @info is deallocated, and the memory freed.
1510  *
1511  * Since: 2.10
1512  */
1513 void
1514 gtk_recent_info_unref (GtkRecentInfo *info)
1515 {
1516   g_return_if_fail (info != NULL);
1517   g_return_if_fail (info->ref_count > 0);
1518
1519   info->ref_count -= 1;
1520
1521   if (info->ref_count == 0)
1522     gtk_recent_info_free (info);
1523 }
1524
1525 /**
1526  * gtk_recent_info_get_uri:
1527  * @info: a #GtkRecentInfo
1528  *
1529  * Gets the URI of the resource.
1530  *
1531  * Return value: the URI of the resource.  The returned string is
1532  *   owned by the recent manager, and should not be freed.
1533  *
1534  * Since: 2.10
1535  */
1536 G_CONST_RETURN gchar *
1537 gtk_recent_info_get_uri (GtkRecentInfo *info)
1538 {
1539   g_return_val_if_fail (info != NULL, NULL);
1540
1541   return info->uri;
1542 }
1543
1544 /**
1545  * gtk_recent_info_get_display_name:
1546  * @info: a #GtkRecentInfo
1547  *
1548  * Gets the name of the resource.  If none has been defined, the basename
1549  * of the resource is obtained.
1550  *
1551  * Return value: the display name of the resource.  The returned string
1552  *   is owned by the recent manager, and should not be freed.
1553  *
1554  * Since: 2.10
1555  */
1556 G_CONST_RETURN gchar *
1557 gtk_recent_info_get_display_name (GtkRecentInfo *info)
1558 {
1559   g_return_val_if_fail (info != NULL, NULL);
1560
1561   if (!info->display_name)
1562     info->display_name = gtk_recent_info_get_short_name (info);
1563
1564   return info->display_name;
1565 }
1566
1567 /**
1568  * gtk_recent_info_get_description:
1569  * @info: a #GtkRecentInfo
1570  *
1571  * Gets the (short) description of the resource.
1572  *
1573  * Return value: the description of the resource.  The returned string
1574  *   is owned by the recent manager, and should not be freed.
1575  *
1576  * Since: 2.10
1577  **/
1578 G_CONST_RETURN gchar *
1579 gtk_recent_info_get_description (GtkRecentInfo *info)
1580 {
1581   g_return_val_if_fail (info != NULL, NULL);
1582
1583   return info->description;
1584 }
1585
1586 /**
1587  * gtk_recent_info_get_mime_type:
1588  * @info: a #GtkRecentInfo
1589  *
1590  * Gets the MIME type of the resource.
1591  *
1592  * Return value: the MIME type of the resource.  The returned string
1593  *   is owned by the recent manager, and should not be freed.
1594  *
1595  * Since: 2.10
1596  */
1597 G_CONST_RETURN gchar *
1598 gtk_recent_info_get_mime_type (GtkRecentInfo *info)
1599 {
1600   g_return_val_if_fail (info != NULL, NULL);
1601
1602   if (!info->mime_type)
1603     info->mime_type = g_strdup (GTK_RECENT_DEFAULT_MIME);
1604
1605   return info->mime_type;
1606 }
1607
1608 /**
1609  * gtk_recent_info_get_added:
1610  * @info: a #GtkRecentInfo
1611  *
1612  * Gets the timestamp (seconds from system's Epoch) when the resource
1613  * was added to the recently used resources list.
1614  *
1615  * Return value: the number of seconds elapsed from system's Epoch when
1616  *   the resource was added to the list, or -1 on failure.
1617  *
1618  * Since: 2.10
1619  */
1620 time_t
1621 gtk_recent_info_get_added (GtkRecentInfo *info)
1622 {
1623   g_return_val_if_fail (info != NULL, (time_t) -1);
1624
1625   return info->added;
1626 }
1627
1628 /**
1629  * gtk_recent_info_get_modified:
1630  * @info: a #GtkRecentInfo
1631  *
1632  * Gets the timestamp (seconds from system's Epoch) when the resource
1633  * was last modified.
1634  *
1635  * Return value: the number of seconds elapsed from system's Epoch when
1636  *   the resource was last modified, or -1 on failure.
1637  *
1638  * Since: 2.10
1639  */
1640 time_t
1641 gtk_recent_info_get_modified (GtkRecentInfo *info)
1642 {
1643   g_return_val_if_fail (info != NULL, (time_t) -1);
1644
1645   return info->modified;
1646 }
1647
1648 /**
1649  * gtk_recent_info_get_visited:
1650  * @info: a #GtkRecentInfo
1651  *
1652  * Gets the timestamp (seconds from system's Epoch) when the resource
1653  * was last visited.
1654  *
1655  * Return value: the number of seconds elapsed from system's Epoch when
1656  *   the resource was last visited, or -1 on failure.
1657  *
1658  * Since: 2.10
1659  */
1660 time_t
1661 gtk_recent_info_get_visited (GtkRecentInfo *info)
1662 {
1663   g_return_val_if_fail (info != NULL, (time_t) -1);
1664
1665   return info->visited;
1666 }
1667
1668 /**
1669  * gtk_recent_info_get_private_hint:
1670  * @info: a #GtkRecentInfo
1671  *
1672  * Gets the value of the "private" flag.  Resources in the recently used
1673  * list that have this flag set to %TRUE should only be displayed by the
1674  * applications that have registered them.
1675  *
1676  * Return value: %TRUE if the private flag was found, %FALSE otherwise.
1677  *
1678  * Since: 2.10
1679  */
1680 gboolean
1681 gtk_recent_info_get_private_hint (GtkRecentInfo *info)
1682 {
1683   g_return_val_if_fail (info != NULL, FALSE);
1684
1685   return info->is_private;
1686 }
1687
1688
1689 static RecentAppInfo *
1690 recent_app_info_new (const gchar *app_name)
1691 {
1692   RecentAppInfo *app_info;
1693
1694   g_assert (app_name != NULL);
1695
1696   app_info = g_slice_new0 (RecentAppInfo);
1697   app_info->name = g_strdup (app_name);
1698   app_info->exec = NULL;
1699   app_info->count = 1;
1700   app_info->stamp = 0;
1701
1702   return app_info;
1703 }
1704
1705 static void
1706 recent_app_info_free (RecentAppInfo *app_info)
1707 {
1708   if (!app_info)
1709     return;
1710
1711   g_free (app_info->name);
1712   g_free (app_info->exec);
1713
1714   g_slice_free (RecentAppInfo, app_info);
1715 }
1716
1717 /**
1718  * gtk_recent_info_get_application_info:
1719  * @info: a #GtkRecentInfo
1720  * @app_name: the name of the application that has registered this item
1721  * @app_exec: (transfer none) (out): return location for the string containing the command line
1722  * @count: (out): return location for the number of times this item was registered
1723  * @time_: (out): return location for the timestamp this item was last registered
1724  *    for this application
1725  *
1726  * Gets the data regarding the application that has registered the resource
1727  * pointed by @info.
1728  *
1729  * If the command line contains any escape characters defined inside the
1730  * storage specification, they will be expanded.
1731  *
1732  * Return value: %TRUE if an application with @app_name has registered this
1733  *   resource inside the recently used list, or %FALSE otherwise. The
1734  *   @app_exec string is owned by the #GtkRecentInfo and should not be
1735  *   modified or freed
1736  *
1737  * Since: 2.10
1738  */
1739 gboolean
1740 gtk_recent_info_get_application_info (GtkRecentInfo  *info,
1741                                       const gchar    *app_name,
1742                                       const gchar   **app_exec,
1743                                       guint          *count,
1744                                       time_t         *time_)
1745 {
1746   RecentAppInfo *ai;
1747
1748   g_return_val_if_fail (info != NULL, FALSE);
1749   g_return_val_if_fail (app_name != NULL, FALSE);
1750
1751   ai = (RecentAppInfo *) g_hash_table_lookup (info->apps_lookup,
1752                                               app_name);
1753   if (!ai)
1754     {
1755       g_warning ("No registered application with name '%s' "
1756                  "for item with URI '%s' found",
1757                  app_name,
1758                  info->uri);
1759       return FALSE;
1760     }
1761
1762   if (app_exec)
1763     *app_exec = ai->exec;
1764
1765   if (count)
1766     *count = ai->count;
1767
1768   if (time_)
1769     *time_ = ai->stamp;
1770
1771   return TRUE;
1772 }
1773
1774 /**
1775  * gtk_recent_info_get_applications:
1776  * @info: a #GtkRecentInfo
1777  * @length: (out) (allow-none): return location for the length of the returned list
1778  *
1779  * Retrieves the list of applications that have registered this resource.
1780  *
1781  * Return value: (array length=length zero-terminated=1) (transfer full):
1782  *     a newly allocated %NULL-terminated array of strings.
1783  *     Use g_strfreev() to free it.
1784  *
1785  * Since: 2.10
1786  */
1787 gchar **
1788 gtk_recent_info_get_applications (GtkRecentInfo *info,
1789                                   gsize         *length)
1790 {
1791   GSList *l;
1792   gchar **retval;
1793   gsize n_apps, i;
1794
1795   g_return_val_if_fail (info != NULL, NULL);
1796
1797   if (!info->applications)
1798     {
1799       if (length)
1800         *length = 0;
1801
1802       return NULL;
1803     }
1804
1805   n_apps = g_slist_length (info->applications);
1806
1807   retval = g_new0 (gchar *, n_apps + 1);
1808
1809   for (l = info->applications, i = 0;
1810        l != NULL;
1811        l = l->next)
1812     {
1813       RecentAppInfo *ai = (RecentAppInfo *) l->data;
1814
1815       g_assert (ai != NULL);
1816
1817       retval[i++] = g_strdup (ai->name);
1818     }
1819   retval[i] = NULL;
1820
1821   if (length)
1822     *length = i;
1823
1824   return retval;
1825 }
1826
1827 /**
1828  * gtk_recent_info_has_application:
1829  * @info: a #GtkRecentInfo
1830  * @app_name: a string containing an application name
1831  *
1832  * Checks whether an application registered this resource using @app_name.
1833  *
1834  * Return value: %TRUE if an application with name @app_name was found,
1835  *   %FALSE otherwise.
1836  *
1837  * Since: 2.10
1838  */
1839 gboolean
1840 gtk_recent_info_has_application (GtkRecentInfo *info,
1841                                  const gchar   *app_name)
1842 {
1843   g_return_val_if_fail (info != NULL, FALSE);
1844   g_return_val_if_fail (app_name != NULL, FALSE);
1845
1846   return (NULL != g_hash_table_lookup (info->apps_lookup, app_name));
1847 }
1848
1849 /**
1850  * gtk_recent_info_last_application:
1851  * @info: a #GtkRecentInfo
1852  *
1853  * Gets the name of the last application that have registered the
1854  * recently used resource represented by @info.
1855  *
1856  * Return value: an application name.  Use g_free() to free it.
1857  *
1858  * Since: 2.10
1859  */
1860 gchar *
1861 gtk_recent_info_last_application (GtkRecentInfo  *info)
1862 {
1863   GSList *l;
1864   time_t last_stamp = (time_t) -1;
1865   gchar *name = NULL;
1866
1867   g_return_val_if_fail (info != NULL, NULL);
1868
1869   for (l = info->applications; l != NULL; l = l->next)
1870     {
1871       RecentAppInfo *ai = (RecentAppInfo *) l->data;
1872
1873       if (ai->stamp > last_stamp)
1874         {
1875           name = ai->name;
1876           last_stamp = ai->stamp;
1877         }
1878     }
1879
1880   return g_strdup (name);
1881 }
1882
1883 static GdkPixbuf *
1884 get_icon_for_mime_type (const char *mime_type,
1885                         gint        pixel_size)
1886 {
1887   GtkIconTheme *icon_theme;
1888   char *content_type;
1889   GIcon *icon;
1890   GtkIconInfo *info;
1891   GdkPixbuf *pixbuf;
1892
1893   icon_theme = gtk_icon_theme_get_default ();
1894
1895   content_type = g_content_type_from_mime_type (mime_type);
1896
1897   if (!content_type)
1898     return NULL;
1899
1900   icon = g_content_type_get_icon (content_type);
1901   info = gtk_icon_theme_lookup_by_gicon (icon_theme,
1902                                          icon,
1903                                          pixel_size,
1904                                          GTK_ICON_LOOKUP_USE_BUILTIN);
1905   g_free (content_type);
1906   g_object_unref (icon);
1907
1908   if (!info)
1909     return NULL;
1910
1911   pixbuf = gtk_icon_info_load_icon (info, NULL);
1912   gtk_icon_info_free (info);
1913
1914   return pixbuf;
1915 }
1916
1917 static GdkPixbuf *
1918 get_icon_fallback (const gchar *icon_name,
1919                    gint         size)
1920 {
1921   GtkIconTheme *icon_theme;
1922   GdkPixbuf *retval;
1923
1924   icon_theme = gtk_icon_theme_get_default ();
1925
1926   retval = gtk_icon_theme_load_icon (icon_theme, icon_name,
1927                                      size,
1928                                      GTK_ICON_LOOKUP_USE_BUILTIN,
1929                                      NULL);
1930   g_assert (retval != NULL);
1931
1932   return retval;
1933 }
1934
1935 /**
1936  * gtk_recent_info_get_icon:
1937  * @info: a #GtkRecentInfo
1938  * @size: the size of the icon in pixels
1939  *
1940  * Retrieves the icon of size @size associated to the resource MIME type.
1941  *
1942  * Return value: (transfer full): a #GdkPixbuf containing the icon,
1943  *     or %NULL. Use g_object_unref() when finished using the icon.
1944  *
1945  * Since: 2.10
1946  */
1947 GdkPixbuf *
1948 gtk_recent_info_get_icon (GtkRecentInfo *info,
1949                           gint           size)
1950 {
1951   GdkPixbuf *retval = NULL;
1952
1953   g_return_val_if_fail (info != NULL, NULL);
1954
1955   if (info->mime_type)
1956     retval = get_icon_for_mime_type (info->mime_type, size);
1957
1958   /* this function should never fail */
1959   if (!retval)
1960     {
1961       if (info->mime_type &&
1962           strcmp (info->mime_type, "x-directory/normal") == 0)
1963         retval = get_icon_fallback ("folder", size);
1964       else
1965         retval = get_icon_fallback ("document-x-generic", size);
1966     }
1967
1968   return retval;
1969 }
1970
1971 /**
1972  * gtk_recent_info_get_gicon:
1973  * @info: a #GtkRecentInfo
1974  *
1975  * Retrieves the icon associated to the resource MIME type.
1976  *
1977  * Return value: (transfer full): a #GIcon containing the icon, or %NULL. Use
1978  *   g_object_unref() when finished using the icon
1979  *
1980  * Since: 2.22
1981  */
1982 GIcon *
1983 gtk_recent_info_get_gicon (GtkRecentInfo  *info)
1984 {
1985   GIcon *icon = NULL;
1986   gchar *content_type;
1987
1988   g_return_val_if_fail (info != NULL, NULL);
1989
1990   if (info->mime_type != NULL &&
1991       (content_type = g_content_type_from_mime_type (info->mime_type)) != NULL)
1992     {
1993       icon = g_content_type_get_icon (content_type);
1994       g_free (content_type);
1995     }
1996
1997   return icon;
1998 }
1999
2000 /**
2001  * gtk_recent_info_is_local:
2002  * @info: a #GtkRecentInfo
2003  *
2004  * Checks whether the resource is local or not by looking at the
2005  * scheme of its URI.
2006  *
2007  * Return value: %TRUE if the resource is local.
2008  *
2009  * Since: 2.10
2010  */
2011 gboolean
2012 gtk_recent_info_is_local (GtkRecentInfo *info)
2013 {
2014   g_return_val_if_fail (info != NULL, FALSE);
2015
2016   return has_case_prefix (info->uri, "file:/");
2017 }
2018
2019 /**
2020  * gtk_recent_info_exists:
2021  * @info: a #GtkRecentInfo
2022  *
2023  * Checks whether the resource pointed by @info still exists.  At
2024  * the moment this check is done only on resources pointing to local files.
2025  *
2026  * Return value: %TRUE if the resource exists
2027  *
2028  * Since: 2.10
2029  */
2030 gboolean
2031 gtk_recent_info_exists (GtkRecentInfo *info)
2032 {
2033   gchar *filename;
2034   struct stat stat_buf;
2035   gboolean retval = FALSE;
2036
2037   g_return_val_if_fail (info != NULL, FALSE);
2038
2039   /* we guarantee only local resources */
2040   if (!gtk_recent_info_is_local (info))
2041     return FALSE;
2042
2043   filename = g_filename_from_uri (info->uri, NULL, NULL);
2044   if (filename)
2045     {
2046       if (stat (filename, &stat_buf) == 0)
2047         retval = TRUE;
2048
2049       g_free (filename);
2050     }
2051
2052   return retval;
2053 }
2054
2055 /**
2056  * gtk_recent_info_match:
2057  * @info_a: a #GtkRecentInfo
2058  * @info_b: a #GtkRecentInfo
2059  *
2060  * Checks whether two #GtkRecentInfo structures point to the same
2061  * resource.
2062  *
2063  * Return value: %TRUE if both #GtkRecentInfo structures point to se same
2064  *   resource, %FALSE otherwise.
2065  *
2066  * Since: 2.10
2067  */
2068 gboolean
2069 gtk_recent_info_match (GtkRecentInfo *info_a,
2070                        GtkRecentInfo *info_b)
2071 {
2072   g_return_val_if_fail (info_a != NULL, FALSE);
2073   g_return_val_if_fail (info_b != NULL, FALSE);
2074
2075   return (0 == strcmp (info_a->uri, info_b->uri));
2076 }
2077
2078 /* taken from gnome-vfs-uri.c */
2079 static const gchar *
2080 get_method_string (const gchar  *substring,
2081                    gchar       **method_string)
2082 {
2083   const gchar *p;
2084   char *method;
2085
2086   for (p = substring;
2087        g_ascii_isalnum (*p) || *p == '+' || *p == '-' || *p == '.';
2088        p++)
2089     ;
2090
2091   if (*p == ':'
2092 #ifdef G_OS_WIN32
2093                 &&
2094       !(p == substring + 1 && g_ascii_isalpha (*substring))
2095 #endif
2096                                                            )
2097     {
2098       /* Found toplevel method specification.  */
2099       method = g_strndup (substring, p - substring);
2100       *method_string = g_ascii_strdown (method, -1);
2101       g_free (method);
2102       p++;
2103     }
2104   else
2105     {
2106       *method_string = g_strdup ("file");
2107       p = substring;
2108     }
2109
2110   return p;
2111 }
2112
2113 /* Stolen from gnome_vfs_make_valid_utf8() */
2114 static char *
2115 make_valid_utf8 (const char *name)
2116 {
2117   GString *string;
2118   const char *remainder, *invalid;
2119   int remaining_bytes, valid_bytes;
2120
2121   string = NULL;
2122   remainder = name;
2123   remaining_bytes = name ? strlen (name) : 0;
2124
2125   while (remaining_bytes != 0)
2126     {
2127       if (g_utf8_validate (remainder, remaining_bytes, &invalid))
2128         break;
2129
2130       valid_bytes = invalid - remainder;
2131
2132       if (string == NULL)
2133         string = g_string_sized_new (remaining_bytes);
2134
2135       g_string_append_len (string, remainder, valid_bytes);
2136       g_string_append_c (string, '?');
2137
2138       remaining_bytes -= valid_bytes + 1;
2139       remainder = invalid + 1;
2140     }
2141
2142   if (string == NULL)
2143     return g_strdup (name);
2144
2145   g_string_append (string, remainder);
2146   g_assert (g_utf8_validate (string->str, -1, NULL));
2147
2148   return g_string_free (string, FALSE);
2149 }
2150
2151 static gchar *
2152 get_uri_shortname_for_display (const gchar *uri)
2153 {
2154   gchar *name = NULL;
2155   gboolean validated = FALSE;
2156
2157   if (has_case_prefix (uri, "file:/"))
2158     {
2159       gchar *local_file;
2160
2161       local_file = g_filename_from_uri (uri, NULL, NULL);
2162
2163       if (local_file)
2164         {
2165           name = g_filename_display_basename (local_file);
2166           validated = TRUE;
2167         }
2168
2169       g_free (local_file);
2170     }
2171
2172   if (!name)
2173     {
2174       gchar *method;
2175       gchar *local_file;
2176       const gchar *rest;
2177
2178       rest = get_method_string (uri, &method);
2179       local_file = g_filename_display_basename (rest);
2180
2181       name = g_strconcat (method, ": ", local_file, NULL);
2182
2183       g_free (local_file);
2184       g_free (method);
2185     }
2186
2187   g_assert (name != NULL);
2188
2189   if (!validated && !g_utf8_validate (name, -1, NULL))
2190     {
2191       gchar *utf8_name;
2192
2193       utf8_name = make_valid_utf8 (name);
2194       g_free (name);
2195
2196       name = utf8_name;
2197     }
2198
2199   return name;
2200 }
2201
2202 /**
2203  * gtk_recent_info_get_short_name:
2204  * @info: an #GtkRecentInfo
2205  *
2206  * Computes a valid UTF-8 string that can be used as the name of the item in a
2207  * menu or list.  For example, calling this function on an item that refers to
2208  * "file:///foo/bar.txt" will yield "bar.txt".
2209  *
2210  * Return value: A newly-allocated string in UTF-8 encoding; free it with
2211  *   g_free().
2212  *
2213  * Since: 2.10
2214  */
2215 gchar *
2216 gtk_recent_info_get_short_name (GtkRecentInfo *info)
2217 {
2218   gchar *short_name;
2219
2220   g_return_val_if_fail (info != NULL, NULL);
2221
2222   if (info->uri == NULL)
2223     return NULL;
2224
2225   short_name = get_uri_shortname_for_display (info->uri);
2226
2227   return short_name;
2228 }
2229
2230 /**
2231  * gtk_recent_info_get_uri_display:
2232  * @info: a #GtkRecentInfo
2233  *
2234  * Gets a displayable version of the resource's URI.  If the resource
2235  * is local, it returns a local path; if the resource is not local,
2236  * it returns the UTF-8 encoded content of gtk_recent_info_get_uri().
2237  *
2238  * Return value: a newly allocated UTF-8 string containing the
2239  *   resource's URI or %NULL. Use g_free() when done using it.
2240  *
2241  * Since: 2.10
2242  */
2243 gchar *
2244 gtk_recent_info_get_uri_display (GtkRecentInfo *info)
2245 {
2246   gchar *retval;
2247
2248   g_return_val_if_fail (info != NULL, NULL);
2249
2250   retval = NULL;
2251   if (gtk_recent_info_is_local (info))
2252     {
2253       gchar *filename;
2254
2255       filename = g_filename_from_uri (info->uri, NULL, NULL);
2256       if (!filename)
2257         return NULL;
2258
2259       retval = g_filename_to_utf8 (filename, -1, NULL, NULL, NULL);
2260       g_free (filename);
2261     }
2262   else
2263     {
2264       retval = make_valid_utf8 (info->uri);
2265     }
2266
2267   return retval;
2268 }
2269
2270 /**
2271  * gtk_recent_info_get_age:
2272  * @info: a #GtkRecentInfo
2273  *
2274  * Gets the number of days elapsed since the last update of the resource
2275  * pointed by @info.
2276  *
2277  * Return value: a positive integer containing the number of days elapsed
2278  *   since the time this resource was last modified.
2279  *
2280  * Since: 2.10
2281  */
2282 gint
2283 gtk_recent_info_get_age (GtkRecentInfo *info)
2284 {
2285   time_t now, delta;
2286   gint retval;
2287
2288   g_return_val_if_fail (info != NULL, -1);
2289
2290   now = time (NULL);
2291
2292   delta = now - info->modified;
2293
2294   retval = (gint) (delta / (60 * 60 * 24));
2295
2296   return retval;
2297 }
2298
2299 /**
2300  * gtk_recent_info_get_groups:
2301  * @info: a #GtkRecentInfo
2302  * @length: (out) (allow-none): return location for the number of groups returned
2303  *
2304  * Returns all groups registered for the recently used item @info.  The
2305  * array of returned group names will be %NULL terminated, so length might
2306  * optionally be %NULL.
2307  *
2308  * Return value:  (array length=length zero-terminated=1) (transfer full):
2309  *     a newly allocated %NULL terminated array of strings.
2310  *     Use g_strfreev() to free it.
2311  *
2312  * Since: 2.10
2313  */
2314 gchar **
2315 gtk_recent_info_get_groups (GtkRecentInfo *info,
2316                             gsize         *length)
2317 {
2318   GSList *l;
2319   gchar **retval;
2320   gsize n_groups, i;
2321
2322   g_return_val_if_fail (info != NULL, NULL);
2323
2324   if (!info->groups)
2325     {
2326       if (length)
2327         *length = 0;
2328
2329       return NULL;
2330     }
2331
2332   n_groups = g_slist_length (info->groups);
2333
2334   retval = g_new0 (gchar *, n_groups + 1);
2335
2336   for (l = info->groups, i = 0;
2337        l != NULL;
2338        l = l->next)
2339     {
2340       gchar *group_name = (gchar *) l->data;
2341
2342       g_assert (group_name != NULL);
2343
2344       retval[i++] = g_strdup (group_name);
2345     }
2346   retval[i] = NULL;
2347
2348   if (length)
2349     *length = i;
2350
2351   return retval;
2352 }
2353
2354 /**
2355  * gtk_recent_info_has_group:
2356  * @info: a #GtkRecentInfo
2357  * @group_name: name of a group
2358  *
2359  * Checks whether @group_name appears inside the groups registered for the
2360  * recently used item @info.
2361  *
2362  * Return value: %TRUE if the group was found.
2363  *
2364  * Since: 2.10
2365  */
2366 gboolean
2367 gtk_recent_info_has_group (GtkRecentInfo *info,
2368                            const gchar   *group_name)
2369 {
2370   GSList *l;
2371
2372   g_return_val_if_fail (info != NULL, FALSE);
2373   g_return_val_if_fail (group_name != NULL, FALSE);
2374
2375   if (!info->groups)
2376     return FALSE;
2377
2378   for (l = info->groups; l != NULL; l = l->next)
2379     {
2380       gchar *g = (gchar *) l->data;
2381
2382       if (strcmp (g, group_name) == 0)
2383         return TRUE;
2384     }
2385
2386   return FALSE;
2387 }
2388
2389 /**
2390  * gtk_recent_info_create_app_info:
2391  * @info: a #GtkRecentInfo
2392  * @app_name: (allow-none): the name of the application that should
2393  *   be mapped to a #GAppInfo; if %NULL is used then the default
2394  *   application for the MIME type is used
2395  * @error: (allow-none): return location for a #GError, or %NULL
2396  *
2397  * Creates a #GAppInfo for the specified #GtkRecentInfo
2398  *
2399  * Return value: (transfer full): the newly created #GAppInfo, or %NULL.
2400  *   In case of error, @error will be set either with a
2401  *   %GTK_RECENT_MANAGER_ERROR or a %G_IO_ERROR
2402  */
2403 GAppInfo *
2404 gtk_recent_info_create_app_info (GtkRecentInfo  *info,
2405                                  const gchar    *app_name,
2406                                  GError        **error)
2407 {
2408   RecentAppInfo *ai;
2409   GAppInfo *app_info;
2410   GError *internal_error = NULL;
2411
2412   g_return_val_if_fail (info != NULL, NULL);
2413
2414   if (app_name == NULL || *app_name == '\0')
2415     {
2416       char *content_type;
2417
2418       if (info->mime_type == NULL)
2419         return NULL;
2420
2421       content_type = g_content_type_from_mime_type (info->mime_type);
2422       if (content_type == NULL)
2423         return NULL;
2424
2425       app_info = g_app_info_get_default_for_type (content_type, TRUE);
2426       g_free (content_type);
2427
2428       return app_info;
2429     }
2430
2431   ai = g_hash_table_lookup (info->apps_lookup, app_name);
2432   if (ai == NULL)
2433     {
2434       g_set_error (error, GTK_RECENT_MANAGER_ERROR,
2435                    GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED,
2436                    _("No registered application with name '%s' for item with URI '%s' found"),
2437                    app_name,
2438                    info->uri);
2439       return NULL;
2440     }
2441
2442   internal_error = NULL;
2443   app_info = g_app_info_create_from_commandline (ai->exec, ai->name,
2444                                                  G_APP_INFO_CREATE_NONE,
2445                                                  &internal_error);
2446   if (internal_error != NULL)
2447     {
2448       g_propagate_error (error, internal_error);
2449       return NULL;
2450     }
2451
2452   return app_info;
2453 }
2454
2455 /*
2456  * _gtk_recent_manager_sync:
2457  *
2458  * Private function for synchronising the recent manager singleton.
2459  */
2460 void
2461 _gtk_recent_manager_sync (void)
2462 {
2463   if (recent_manager_singleton)
2464     {
2465       /* force a dump of the contents of the recent manager singleton */
2466       recent_manager_singleton->priv->is_dirty = TRUE;
2467       gtk_recent_manager_real_changed (recent_manager_singleton);
2468     }
2469 }