1
/* GTK - The GIMP Toolkit
2
* gtkrecentmanager.c: a manager for the recently used resources
4
* Copyright (C) 2006 Emmanuele Bassi
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.
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.
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,
23
#include <sys/types.h>
32
#include <glib/gstdio.h>
34
#include "gtkrecentmanager.h"
37
#include "gtkicontheme.h"
38
#include "gtktypebuiltins.h"
39
#include "gtkprivate.h"
40
#include "gtkmarshalers.h"
44
#define XDG_PREFIX _gtk_xdg
45
#include "xdgmime/xdgmime.h"
48
/* the file where we store the recently used items */
49
#define GTK_RECENTLY_USED_FILE ".recently-used.xbel"
51
/* a poll every two seconds should be enough */
52
#define POLL_DELTA 2000
54
/* return all items by default */
55
#define DEFAULT_LIMIT -1
57
/* keep in sync with xdgmime */
58
#define GTK_RECENT_DEFAULT_MIME "application/octet-stream"
84
GHashTable *apps_lookup;
95
struct _GtkRecentManagerPrivate
99
guint is_screen_singleton : 1;
101
guint write_in_progress : 1;
102
guint read_in_progress : 1;
109
GBookmarkFile *recent_items;
124
static void gtk_recent_manager_finalize (GObject *object);
126
static void gtk_recent_manager_set_property (GObject *object,
130
static void gtk_recent_manager_get_property (GObject *object,
134
static void gtk_recent_manager_changed (GtkRecentManager *manager);
136
static void gtk_recent_manager_real_changed (GtkRecentManager *manager);
137
static gboolean gtk_recent_manager_poll_timeout (gpointer data);
138
static void gtk_recent_manager_set_filename (GtkRecentManager *manager,
139
const gchar *filename);
141
static void build_recent_items_list (GtkRecentManager *manager);
142
static void purge_recent_items_list (GtkRecentManager *manager,
145
static RecentAppInfo *recent_app_info_new (const gchar *app_name);
146
static void recent_app_info_free (RecentAppInfo *app_info);
148
static GtkRecentInfo *gtk_recent_info_new (const gchar *uri);
149
static void gtk_recent_info_free (GtkRecentInfo *recent_info);
151
static guint signal_changed = 0;
153
G_DEFINE_TYPE (GtkRecentManager, gtk_recent_manager, G_TYPE_OBJECT)
156
filename_warning (const gchar *format,
157
const gchar *filename,
158
const gchar *message)
160
gchar *utf8 = g_filename_to_utf8 (filename, -1, NULL, NULL, NULL);
161
g_warning (format, utf8 ? utf8 : "(invalid filename)", message);
165
/* Test of haystack has the needle prefix, comparing case
166
* insensitive. haystack may be UTF-8, but needle must
167
* contain only lowercase ascii. */
169
has_case_prefix (const gchar *haystack,
174
/* Eat one character at a time. */
178
while (*n && *h && *n == g_ascii_tolower (*h))
188
gtk_recent_manager_error_quark (void)
190
return g_quark_from_static_string ("gtk-recent-manager-error-quark");
195
gtk_recent_manager_class_init (GtkRecentManagerClass *klass)
197
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
199
gtk_recent_manager_parent_class = g_type_class_peek_parent (klass);
201
gobject_class->set_property = gtk_recent_manager_set_property;
202
gobject_class->get_property = gtk_recent_manager_get_property;
203
gobject_class->finalize = gtk_recent_manager_finalize;
206
* GtkRecentManager:filename
208
* The full path to the file to be used to store and read the recently
209
* used resources list
213
g_object_class_install_property (gobject_class,
215
g_param_spec_string ("filename",
217
P_("The full path to the file to be used to store and read the list"),
219
(G_PARAM_CONSTRUCT_ONLY | G_PARAM_READABLE | G_PARAM_WRITABLE)));
221
* GtkRecentManager:limit
223
* The maximum number of items to be returned by the
224
* gtk_recent_manager_get_items() function.
228
g_object_class_install_property (gobject_class,
230
g_param_spec_int ("limit",
232
P_("The maximum number of items to be returned by gtk_recent_manager_get_items()"),
238
* GtkRecentManager:size
240
* The size of the recently used resources list.
244
g_object_class_install_property (gobject_class,
246
g_param_spec_int ("size",
248
P_("The size of the recently used resources list"),
255
* GtkRecentManager::changed
256
* @recent_manager: the recent manager
258
* Emitted when the current recently used resources manager changes its
264
g_signal_new (I_("changed"),
265
G_TYPE_FROM_CLASS (klass),
267
G_STRUCT_OFFSET (GtkRecentManagerClass, changed),
269
g_cclosure_marshal_VOID__VOID,
272
klass->changed = gtk_recent_manager_real_changed;
274
g_type_class_add_private (klass, sizeof (GtkRecentManagerPrivate));
278
gtk_recent_manager_init (GtkRecentManager *manager)
280
GtkRecentManagerPrivate *priv;
282
priv = g_type_instance_get_private ((GTypeInstance *) manager,
283
GTK_TYPE_RECENT_MANAGER);
284
manager->priv = priv;
286
priv->limit = DEFAULT_LIMIT;
289
priv->is_screen_singleton = FALSE;
290
priv->is_dirty = FALSE;
291
priv->write_in_progress = FALSE;
292
priv->read_in_progress = FALSE;
296
priv->filename = g_build_filename (g_get_home_dir (),
297
GTK_RECENTLY_USED_FILE,
299
priv->poll_timeout = g_timeout_add (POLL_DELTA,
300
gtk_recent_manager_poll_timeout,
303
build_recent_items_list (manager);
307
gtk_recent_manager_set_property (GObject *object,
312
GtkRecentManager *recent_manager = GTK_RECENT_MANAGER (object);
317
gtk_recent_manager_set_filename (recent_manager, g_value_get_string (value));
320
gtk_recent_manager_set_limit (recent_manager, g_value_get_int (value));
323
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
329
gtk_recent_manager_get_property (GObject *object,
334
GtkRecentManager *recent_manager = GTK_RECENT_MANAGER (object);
339
g_value_set_string (value, recent_manager->priv->filename);
342
g_value_set_int (value, recent_manager->priv->limit);
345
g_value_set_int (value, recent_manager->priv->size);
348
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
354
gtk_recent_manager_finalize (GObject *object)
356
GtkRecentManager *manager = GTK_RECENT_MANAGER (object);
357
GtkRecentManagerPrivate *priv = manager->priv;
359
/* remove the poll timeout */
360
if (priv->poll_timeout)
361
g_source_remove (priv->poll_timeout);
364
g_free (priv->filename);
366
if (priv->recent_items)
367
g_bookmark_file_free (priv->recent_items);
369
/* chain up parent's finalize method */
370
G_OBJECT_CLASS (gtk_recent_manager_parent_class)->finalize (object);
374
gtk_recent_manager_real_changed (GtkRecentManager *manager)
376
GtkRecentManagerPrivate *priv = manager->priv;
378
g_object_freeze_notify (G_OBJECT (manager));
383
struct stat stat_buf;
385
/* we are marked as dirty, so we dump the content of our
386
* recently used items list
388
g_assert (priv->filename != NULL);
390
priv->write_in_progress = TRUE;
392
/* if no container object has been defined, we create a new
393
* empty container, and dump it
395
if (!priv->recent_items)
397
priv->recent_items = g_bookmark_file_new ();
402
g_bookmark_file_to_file (priv->recent_items,
408
filename_warning ("Attempting to store changes into `%s', "
411
write_error->message);
412
g_error_free (write_error);
415
priv->write_in_progress = FALSE;
417
/* we have sync'ed our list with the storage file, so we
418
* update the file mtime in order to skip the timed check
419
* and spare us from a re-read.
421
if (g_stat (priv->filename, &stat_buf) < 0)
423
filename_warning ("Unable to stat() the recently used resources file "
428
g_object_thaw_notify (G_OBJECT (manager));
433
priv->last_mtime = stat_buf.st_mtime;
435
/* mark us as clean */
436
priv->is_dirty = FALSE;
440
/* we are not marked as dirty, so we have been called
441
* because the recently used resources file has been
442
* changed (and not from us).
444
build_recent_items_list (manager);
447
g_object_thaw_notify (G_OBJECT (manager));
450
/* timed poll()-ing of the recently used resources file.
451
* an event-based system would be more efficient.
454
gtk_recent_manager_poll_timeout (gpointer data)
456
GtkRecentManager *manager = GTK_RECENT_MANAGER (data);
457
GtkRecentManagerPrivate *priv = manager->priv;
458
struct stat stat_buf;
461
/* wait for the next timeout if we have a read/write in progress */
462
if (priv->write_in_progress || priv->read_in_progress)
465
stat_res = g_stat (priv->filename, &stat_buf);
468
/* the file does not exist, yet, so we wait */
472
filename_warning ("Unable to stat() the recently used resources file "
480
/* the file didn't change from the last poll(), so we bail out */
481
if (stat_buf.st_mtime == priv->last_mtime)
484
/* the file has been changed, hence we emit the "changed" signal */
485
gtk_recent_manager_changed (manager);
491
gtk_recent_manager_set_filename (GtkRecentManager *manager,
492
const gchar *filename)
494
GtkRecentManagerPrivate *priv;
496
g_assert (GTK_IS_RECENT_MANAGER (manager));
497
priv = manager->priv;
499
if (!filename || filename[0] == '\0')
502
g_free (manager->priv->filename);
504
if (manager->priv->poll_timeout)
506
g_source_remove (manager->priv->poll_timeout);
507
manager->priv->poll_timeout = 0;
510
priv->filename = g_strdup (filename);
511
priv->poll_timeout = g_timeout_add (POLL_DELTA,
512
gtk_recent_manager_poll_timeout,
515
/* mark us clean, so that we can re-read the list
516
* of recently used resources
518
priv->is_dirty = FALSE;
519
build_recent_items_list (manager);
522
/* reads the recently used resources file and builds the items list.
523
* we keep the items list inside the parser object, and build the
524
* RecentInfo object only on user's demand to avoid useless replication.
525
* this function resets the dirty bit of the manager.
528
build_recent_items_list (GtkRecentManager *manager)
530
GtkRecentManagerPrivate *priv;
531
struct stat stat_buf;
537
priv = manager->priv;
538
g_assert (priv->filename != NULL);
540
if (!priv->recent_items)
542
priv->recent_items = g_bookmark_file_new ();
546
stat_res = g_stat (priv->filename, &stat_buf);
549
/* the file doesn't exists, so we bail out and wait for the first
557
filename_warning ("Attempting to read the recently used resources file "
558
"at `%s', but an error occurred: %s. Aborting.",
566
/* record the last mtime, for later use */
567
priv->last_mtime = stat_buf.st_mtime;
569
priv->read_in_progress = TRUE;
571
/* the file exists, and it's valid (we hope); if not, destroy the container
572
* object and hope for a better result when the next "changed" signal is
575
res = g_bookmark_file_load_from_file (priv->recent_items,
580
filename_warning ("Attempting to read the recently used resources file "
581
"at `%s', but the parser failed: %s.",
583
read_error->message);
585
g_bookmark_file_free (priv->recent_items);
586
priv->recent_items = NULL;
588
g_error_free (read_error);
591
size = g_bookmark_file_get_size (priv->recent_items);
592
if (priv->size != size)
596
g_object_notify (G_OBJECT (manager), "size");
599
priv->read_in_progress = FALSE;
600
priv->is_dirty = FALSE;
604
/********************
606
********************/
610
* gtk_recent_manager_new:
612
* Creates a new recent manager object. Recent manager objects are used to
613
* handle the list of recently used resources. A #GtkRecentManager object
614
* monitors the recently used resources list, and emits the "changed" signal
615
* each time something inside the list changes.
617
* #GtkRecentManager objects are expensive: be sure to create them only when
618
* needed. You should use the gtk_recent_manager_new_for_screen() or the
619
* gtk_recent_manager_get_default() functions instead.
621
* Return value: A newly created #GtkRecentManager object.
626
gtk_recent_manager_new (void)
628
return g_object_new (GTK_TYPE_RECENT_MANAGER, NULL);
632
* gtk_recent_manager_get_default:
634
* Gets the recent manager for the default screen. See
635
* gtk_recent_manager_get_for_screen().
637
* Return value: A unique #GtkRecentManager associated with the
638
* default screen. This recent manager is associated with the
639
* screen and can be used as long as the screen is open.
640
* Do not ref or unref it.
645
gtk_recent_manager_get_default (void)
647
return gtk_recent_manager_get_for_screen (gdk_screen_get_default ());
651
* gtk_recent_manager_get_for_screen:
652
* @screen: a #GdkScreen
654
* Gets the recent manager object associated with @screen; if this
655
* function has not previously been called for the given screen,
656
* a new recent manager object will be created and associated with
657
* the screen. Recent manager objects are fairly expensive to create,
658
* so using this function is usually a better choice than calling
659
* gtk_recent_manager_new() and setting the screen yourself; by using
660
* this function a single recent manager object will be shared between
663
* Return value: A unique #GtkRecentManager associated with the given
664
* screen. This recent manager is associated to the with the screen
665
* and can be used as long as the screen is open. Do not ref or
671
gtk_recent_manager_get_for_screen (GdkScreen *screen)
673
GtkRecentManager *manager;
675
g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
676
g_return_val_if_fail (!screen->closed, NULL);
678
manager = g_object_get_data (G_OBJECT (screen), "gtk-recent-manager-default");
681
GtkRecentManagerPrivate *priv;
683
manager = gtk_recent_manager_new ();
684
gtk_recent_manager_set_screen (manager, screen);
686
priv = manager->priv;
687
priv->is_screen_singleton = TRUE;
689
g_object_set_data (G_OBJECT (screen), I_("gtk-recent-manager-default"), manager);
696
display_closed (GdkDisplay *display,
698
GtkRecentManager *manager)
700
GtkRecentManagerPrivate *priv = manager->priv;
701
GdkScreen *screen = priv->screen;
702
gboolean was_screen_singleton = priv->is_screen_singleton;
704
if (was_screen_singleton)
706
g_object_set_data (G_OBJECT (screen), I_("gtk-recent-manager-default"), NULL);
707
priv->is_screen_singleton = FALSE;
710
gtk_recent_manager_set_screen (manager, NULL);
712
if (was_screen_singleton)
713
g_object_unref (manager);
717
unset_screen (GtkRecentManager *manager)
719
GtkRecentManagerPrivate *priv = manager->priv;
724
display = gdk_screen_get_display (priv->screen);
726
g_signal_handlers_disconnect_by_func (display,
727
(gpointer) display_closed,
735
* gtk_recent_manager_set_screen:
736
* @manager: a #GtkRecentManager
737
* @screen: a #GdkScreen
739
* Sets the screen for a recent manager; the screen is used to
740
* track the user's currently configured recently used documents
746
gtk_recent_manager_set_screen (GtkRecentManager *manager,
749
GtkRecentManagerPrivate *priv;
752
g_return_if_fail (GTK_IS_RECENT_MANAGER (manager));
753
g_return_if_fail (screen == NULL || GDK_IS_SCREEN (screen));
755
priv = manager->priv;
757
unset_screen (manager);
761
display = gdk_screen_get_display (screen);
763
priv->screen = screen;
765
g_signal_connect (display, "closed",
766
G_CALLBACK (display_closed), manager);
771
* gtk_recent_manager_set_limit:
772
* @manager: a #GtkRecentManager
773
* @limit: the maximum number of items to return, or -1.
775
* Sets the maximum number of item that the gtk_recent_manager_get_items()
776
* function should return. If @limit is set to -1, then return all the
782
gtk_recent_manager_set_limit (GtkRecentManager *manager,
785
GtkRecentManagerPrivate *priv;
787
g_return_if_fail (GTK_IS_RECENT_MANAGER (manager));
789
priv = manager->priv;
794
* gtk_recent_manager_get_limit:
795
* @manager: a #GtkRecentManager
797
* Gets the maximum number of items that the gtk_recent_manager_get_items()
798
* function should return.
800
* Return value: the number of items to return, or -1 for every item.
805
gtk_recent_manager_get_limit (GtkRecentManager *manager)
807
GtkRecentManagerPrivate *priv;
809
g_return_val_if_fail (GTK_IS_RECENT_MANAGER (manager), DEFAULT_LIMIT);
811
priv = manager->priv;
816
* gtk_recent_manager_add_item:
817
* @manager: a #GtkRecentManager
820
* Adds a new resource, pointed by @uri, into the recently used
823
* This function automatically retrieving some of the needed
824
* metadata and setting other metadata to common default values; it
825
* then feeds the data to gtk_recent_manager_add_full().
827
* See gtk_recent_manager_add_full() if you want to explicitely
828
* define the metadata for the resource pointed by @uri.
830
* Return value: %TRUE if the new item was successfully added
831
* to the recently used resources list
836
gtk_recent_manager_add_item (GtkRecentManager *manager,
839
GtkRecentData recent_data;
842
g_return_val_if_fail (GTK_IS_RECENT_MANAGER (manager), FALSE);
843
g_return_val_if_fail (uri != NULL, FALSE);
845
recent_data.display_name = NULL;
846
recent_data.description = NULL;
847
recent_data.mime_type = NULL;
850
if (has_case_prefix (uri, "file:/"))
853
const gchar *mime_type;
855
filename = g_filename_from_uri (uri, NULL, NULL);
858
mime_type = xdg_mime_get_mime_type_for_file (filename, NULL);
859
if (mime_type && *mime_type)
860
recent_data.mime_type = g_strdup (mime_type);
865
if (!recent_data.mime_type)
866
recent_data.mime_type = g_strdup (GTK_RECENT_DEFAULT_MIME);
870
recent_data.mime_type = g_strdup (GTK_RECENT_DEFAULT_MIME);
872
recent_data.app_name = g_strdup (g_get_application_name ());
873
recent_data.app_exec = g_strjoin (" ", g_get_prgname (), "%u", NULL);
874
recent_data.groups = NULL;
875
recent_data.is_private = FALSE;
877
retval = gtk_recent_manager_add_full (manager, uri, &recent_data);
879
g_free (recent_data.mime_type);
880
g_free (recent_data.app_name);
881
g_free (recent_data.app_exec);
887
* gtk_recent_manager_add_full:
888
* @manager: a #GtkRecentManager
890
* @recent_data: metadata of the resource
892
* Adds a new resource, pointed by @uri, into the recently used
893
* resources list, using the metadata specified inside the #GtkRecentData
894
* structure passed in @recent_data.
896
* The passed URI will be used to identify this resource inside the
899
* In order to register the new recently used resource, metadata about
900
* the resource must be passed as well as the URI; the metadata is
901
* stored in a #GtkRecentData structure, which must contain the MIME
902
* type of the resource pointed by the URI; the name of the application
903
* that is registering the item, and a command line to be used when
904
* launching the item.
906
* Optionally, a #GtkRecentData structure might contain a UTF-8 string
907
* to be used when viewing the item instead of the last component of the
908
* URI; a short description of the item; whether the item should be
909
* considered private - that is, should be displayed only by the
910
* applications that have registered it.
912
* Return value: %TRUE if the new item was successfully added to the
913
* recently used resources list, %FALSE otherwise.
918
gtk_recent_manager_add_full (GtkRecentManager *manager,
920
const GtkRecentData *data)
922
GtkRecentManagerPrivate *priv;
924
g_return_val_if_fail (GTK_IS_RECENT_MANAGER (manager), FALSE);
925
g_return_val_if_fail (uri != NULL, FALSE);
926
g_return_val_if_fail (data != NULL, FALSE);
929
if ((data->display_name) &&
930
(!g_utf8_validate (data->display_name, -1, NULL)))
932
g_warning ("Attempting to add `%s' to the list of recently used "
933
"resources, but the display name is not a valid UTF-8 "
939
if ((data->description) &&
940
(!g_utf8_validate (data->description, -1, NULL)))
942
g_warning ("Attempting to add `%s' to the list of recently used "
943
"resources, but the description is not a valid UTF-8 "
950
if (!data->mime_type)
952
g_warning ("Attempting to add `%s' to the list of recently used "
953
"resources, but not MIME type was defined",
960
g_warning ("Attempting to add `%s' to the list of recently used "
961
"resources, but no name of the application that is "
962
"registering it was defined",
969
g_warning ("Attempting to add `%s' to the list of recently used "
970
"resources, but no command line for the application "
971
"that is registering it was defined",
976
priv = manager->priv;
978
if (!priv->recent_items)
980
priv->recent_items = g_bookmark_file_new ();
984
if (data->display_name)
985
g_bookmark_file_set_title (priv->recent_items, uri, data->display_name);
987
if (data->description)
988
g_bookmark_file_set_description (priv->recent_items, uri, data->description);
990
g_bookmark_file_set_mime_type (priv->recent_items, uri, data->mime_type);
992
if (data->groups && data->groups[0] != '\0')
996
for (j = 0; (data->groups)[j] != NULL; j++)
997
g_bookmark_file_add_group (priv->recent_items, uri, (data->groups)[j]);
1000
/* register the application; this will take care of updating the
1001
* registration count and time in case the application has
1002
* already registered the same document inside the list
1004
g_bookmark_file_add_application (priv->recent_items, uri,
1008
g_bookmark_file_set_is_private (priv->recent_items, uri,
1011
/* mark us as dirty, so that when emitting the "changed" signal we
1012
* will dump our changes
1014
priv->is_dirty = TRUE;
1016
gtk_recent_manager_changed (manager);
1022
* gtk_recent_manager_remove_item:
1023
* @manager: a #GtkRecentManager
1024
* @uri: the URI of the item you wish to remove
1025
* @error: return location for a #GError, or %NULL
1027
* Removes a resource pointed by @uri from the recently used resources
1028
* list handled by a recent manager.
1030
* Return value: %TRUE if the item pointed by @uri has been successfully
1031
* removed by the recently used resources list, and %FALSE otherwise.
1036
gtk_recent_manager_remove_item (GtkRecentManager *manager,
1040
GtkRecentManagerPrivate *priv;
1041
GError *remove_error = NULL;
1043
g_return_val_if_fail (GTK_IS_RECENT_MANAGER (manager), FALSE);
1044
g_return_val_if_fail (uri != NULL, FALSE);
1045
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
1047
priv = manager->priv;
1049
if (!priv->recent_items)
1051
priv->recent_items = g_bookmark_file_new ();
1054
g_set_error (error, GTK_RECENT_MANAGER_ERROR,
1055
GTK_RECENT_MANAGER_ERROR_NOT_FOUND,
1056
_("Unable to find an item with URI '%s'"),
1062
g_bookmark_file_remove_item (priv->recent_items, uri, &remove_error);
1065
g_propagate_error (error, remove_error);
1070
priv->is_dirty = TRUE;
1072
gtk_recent_manager_changed (manager);
1078
* gtk_recent_manager_has_item:
1079
* @manager: a #GtkRecentManager
1082
* Checks whether there is a recently used resource registered
1083
* with @uri inside the recent manager.
1085
* Return value: %TRUE if the resource was found, %FALSE otherwise.
1090
gtk_recent_manager_has_item (GtkRecentManager *manager,
1093
GtkRecentManagerPrivate *priv;
1095
g_return_val_if_fail (GTK_IS_RECENT_MANAGER (manager), FALSE);
1096
g_return_val_if_fail (uri != NULL, FALSE);
1098
priv = manager->priv;
1099
g_return_val_if_fail (priv->recent_items != NULL, FALSE);
1101
return g_bookmark_file_has_item (priv->recent_items, uri);
1105
build_recent_info (GBookmarkFile *bookmarks,
1106
GtkRecentInfo *info)
1108
gchar **apps, **groups;
1109
gsize apps_len, groups_len, i;
1111
g_assert (bookmarks != NULL);
1112
g_assert (info != NULL);
1114
info->display_name = g_bookmark_file_get_title (bookmarks, info->uri, NULL);
1115
info->description = g_bookmark_file_get_description (bookmarks, info->uri, NULL);
1116
info->mime_type = g_bookmark_file_get_mime_type (bookmarks, info->uri, NULL);
1118
info->is_private = g_bookmark_file_get_is_private (bookmarks, info->uri, NULL);
1120
info->added = g_bookmark_file_get_added (bookmarks, info->uri, NULL);
1121
info->modified = g_bookmark_file_get_modified (bookmarks, info->uri, NULL);
1122
info->visited = g_bookmark_file_get_visited (bookmarks, info->uri, NULL);
1124
groups = g_bookmark_file_get_groups (bookmarks, info->uri, &groups_len, NULL);
1125
for (i = 0; i < groups_len; i++)
1127
gchar *group_name = g_strdup (groups[i]);
1129
info->groups = g_slist_append (info->groups, group_name);
1132
g_strfreev (groups);
1134
apps = g_bookmark_file_get_applications (bookmarks, info->uri, &apps_len, NULL);
1135
for (i = 0; i < apps_len; i++)
1137
gchar *app_name, *app_exec;
1140
RecentAppInfo *app_info;
1145
res = g_bookmark_file_get_app_info (bookmarks, info->uri, app_name,
1153
app_info = recent_app_info_new (app_name);
1154
app_info->exec = app_exec;
1155
app_info->count = count;
1156
app_info->stamp = stamp;
1158
info->applications = g_slist_append (info->applications,
1160
g_hash_table_replace (info->apps_lookup, app_info->name, app_info);
1169
* gtk_recent_manager_lookup_item:
1170
* @manager: a #GtkRecentManager
1172
* @error: a return location for a #GError, or %NULL
1174
* Searches for a URI inside the recently used resources list, and
1175
* returns a structure containing informations about the resource
1176
* like its MIME type, or its display name.
1178
* Return value: a #GtkRecentInfo structure containing information
1179
* about the resource pointed by @uri, or %NULL if the URI was
1180
* not registered in the recently used resources list. Free with
1181
* gtk_recent_info_unref().
1186
gtk_recent_manager_lookup_item (GtkRecentManager *manager,
1190
GtkRecentManagerPrivate *priv;
1191
GtkRecentInfo *info = NULL;
1194
g_return_val_if_fail (GTK_IS_RECENT_MANAGER (manager), NULL);
1195
g_return_val_if_fail (uri != NULL, NULL);
1196
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
1198
priv = manager->priv;
1199
if (!priv->recent_items)
1201
priv->recent_items = g_bookmark_file_new ();
1204
g_set_error (error, GTK_RECENT_MANAGER_ERROR,
1205
GTK_RECENT_MANAGER_ERROR_NOT_FOUND,
1206
_("Unable to find an item with URI '%s'"),
1212
if (!g_bookmark_file_has_item (priv->recent_items, uri))
1214
g_set_error (error, GTK_RECENT_MANAGER_ERROR,
1215
GTK_RECENT_MANAGER_ERROR_NOT_FOUND,
1216
_("Unable to find an item with URI '%s'"),
1221
info = gtk_recent_info_new (uri);
1222
g_return_val_if_fail (info != NULL, NULL);
1224
/* fill the RecentInfo structure with the data retrieved by our
1225
* parser object from the storage file
1227
res = build_recent_info (priv->recent_items, info);
1230
gtk_recent_info_free (info);
1239
* gtk_recent_manager_move_item:
1240
* @manager: a #GtkRecentManager
1241
* @uri: the URI of a recently used resource
1242
* @new_uri: the new URI of the recently used resource, or %NULL to
1243
* remove the item pointed by @uri in the list
1244
* @error: a return location for a #GError, or %NULL
1246
* Changes the location of a recently used resource from @uri to @new_uri.
1248
* Please note that this function will not affect the resource pointed
1249
* by the URIs, but only the URI used in the recently used resources list.
1251
* Return value: %TRUE on success.
1256
gtk_recent_manager_move_item (GtkRecentManager *recent_manager,
1258
const gchar *new_uri,
1261
GtkRecentManagerPrivate *priv;
1265
g_return_val_if_fail (GTK_IS_RECENT_MANAGER (recent_manager), FALSE);
1266
g_return_val_if_fail (uri != NULL, FALSE);
1267
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
1269
priv = recent_manager->priv;
1271
if (!g_bookmark_file_has_item (priv->recent_items, uri))
1273
g_set_error (error, GTK_RECENT_MANAGER_ERROR,
1274
GTK_RECENT_MANAGER_ERROR_NOT_FOUND,
1275
_("Unable to find an item with URI '%s'"),
1281
res = g_bookmark_file_move_item (priv->recent_items,
1286
g_propagate_error (error, move_error);
1290
priv->is_dirty = TRUE;
1292
gtk_recent_manager_changed (recent_manager);
1298
* gtk_recent_manager_get_items:
1299
* @manager: a #GtkRecentManager
1301
* Gets the list of recently used resources.
1303
* Return value: a list of newly allocated #GtkRecentInfo objects. Use
1304
* gtk_recent_info_unref() on each item inside the list, and then
1305
* free the list itself using g_list_free().
1310
gtk_recent_manager_get_items (GtkRecentManager *manager)
1312
GtkRecentManagerPrivate *priv;
1313
GList *retval = NULL;
1317
g_return_val_if_fail (GTK_IS_RECENT_MANAGER (manager), NULL);
1319
priv = manager->priv;
1320
if (!priv->recent_items)
1323
if (priv->limit == 0)
1326
uris = g_bookmark_file_get_uris (priv->recent_items, &uris_len);
1327
for (i = 0; i < uris_len; i++)
1329
GtkRecentInfo *info;
1332
info = gtk_recent_info_new (uris[i]);
1333
res = build_recent_info (priv->recent_items, info);
1336
g_warning ("Unable to create a RecentInfo object for "
1337
"item with URI `%s'",
1339
gtk_recent_info_free (info);
1344
retval = g_list_prepend (retval, info);
1349
/* clamp the list, if a limit is present */
1350
if ((priv->limit != -1) &&
1351
(g_list_length (retval) > priv->limit))
1355
clamp = g_list_nth (retval, priv->limit - 1);
1363
g_list_foreach (l, (GFunc) gtk_recent_info_free, NULL);
1371
purge_recent_items_list (GtkRecentManager *manager,
1374
GtkRecentManagerPrivate *priv = manager->priv;
1376
if (!priv->recent_items)
1379
g_bookmark_file_free (priv->recent_items);
1380
priv->recent_items = NULL;
1382
priv->recent_items = g_bookmark_file_new ();
1384
priv->is_dirty = TRUE;
1386
/* emit the changed signal, to ensure that the purge is written */
1387
gtk_recent_manager_changed (manager);
1391
* gtk_recent_manager_purge_items:
1392
* @manager: a #GtkRecentManager
1393
* @error: a return location for a #GError, or %NULL
1395
* Purges every item from the recently used resources list.
1397
* Return value: the number of items that have been removed from the
1398
* recently used resources list.
1403
gtk_recent_manager_purge_items (GtkRecentManager *manager,
1406
GtkRecentManagerPrivate *priv;
1409
g_return_val_if_fail (GTK_IS_RECENT_MANAGER (manager), -1);
1411
priv = manager->priv;
1412
if (!priv->recent_items)
1415
count = g_bookmark_file_get_size (priv->recent_items);
1419
purge_recent_items_list (manager, error);
1421
purged = count - g_bookmark_file_get_size (priv->recent_items);
1427
gtk_recent_manager_changed (GtkRecentManager *recent_manager)
1429
g_signal_emit (recent_manager, signal_changed, 0);
1437
gtk_recent_info_get_type (void)
1439
static GType info_type = 0;
1442
info_type = g_boxed_type_register_static ("GtkRecentInfo",
1443
(GBoxedCopyFunc) gtk_recent_info_ref,
1444
(GBoxedFreeFunc) gtk_recent_info_unref);
1448
static GtkRecentInfo *
1449
gtk_recent_info_new (const gchar *uri)
1451
GtkRecentInfo *info;
1453
g_assert (uri != NULL);
1455
info = g_new0 (GtkRecentInfo, 1);
1456
info->uri = g_strdup (uri);
1458
info->applications = NULL;
1459
info->apps_lookup = g_hash_table_new (g_str_hash, g_str_equal);
1461
info->groups = NULL;
1463
info->ref_count = 1;
1469
gtk_recent_info_free (GtkRecentInfo *recent_info)
1474
g_free (recent_info->uri);
1475
g_free (recent_info->display_name);
1476
g_free (recent_info->description);
1477
g_free (recent_info->mime_type);
1479
if (recent_info->applications)
1481
g_slist_foreach (recent_info->applications,
1482
(GFunc) recent_app_info_free,
1484
g_slist_free (recent_info->applications);
1486
recent_info->applications = NULL;
1489
if (recent_info->apps_lookup)
1490
g_hash_table_destroy (recent_info->apps_lookup);
1492
if (recent_info->groups)
1494
g_slist_foreach (recent_info->groups,
1497
g_slist_free (recent_info->groups);
1499
recent_info->groups = NULL;
1502
if (recent_info->icon)
1503
g_object_unref (recent_info->icon);
1505
g_free (recent_info);
1509
* gtk_recent_info_ref:
1510
* @info: a #GtkRecentInfo
1512
* Increases the reference count of @recent_info by one.
1514
* Return value: the recent info object with its reference count increased
1520
gtk_recent_info_ref (GtkRecentInfo *info)
1522
g_return_val_if_fail (info != NULL, NULL);
1523
g_return_val_if_fail (info->ref_count > 0, NULL);
1525
info->ref_count += 1;
1531
* gtk_recent_info_unref:
1532
* @info: a #GtkRecentInfo
1534
* Decreases the reference count of @info by one. If the reference
1535
* count reaches zero, @info is deallocated, and the memory freed.
1540
gtk_recent_info_unref (GtkRecentInfo *info)
1542
g_return_if_fail (info != NULL);
1543
g_return_if_fail (info->ref_count > 0);
1545
info->ref_count -= 1;
1547
if (info->ref_count == 0)
1548
gtk_recent_info_free (info);
1552
* gtk_recent_info_get_uri:
1553
* @info: a #GtkRecentInfo
1555
* Gets the URI of the resource.
1557
* Return value: the URI of the resource. The returned string is
1558
* owned by the recent manager, and should not be freed.
1562
G_CONST_RETURN gchar *
1563
gtk_recent_info_get_uri (GtkRecentInfo *info)
1565
g_return_val_if_fail (info != NULL, NULL);
1571
* gtk_recent_info_get_display_name:
1572
* @info: a #GtkRecentInfo
1574
* Gets the name of the resource. If none has been defined, the basename
1575
* of the resource is obtained.
1577
* Return value: the display name of the resource. The returned string
1578
* is owned by the recent manager, and should not be freed.
1582
G_CONST_RETURN gchar *
1583
gtk_recent_info_get_display_name (GtkRecentInfo *info)
1585
g_return_val_if_fail (info != NULL, NULL);
1587
if (!info->display_name)
1588
info->display_name = gtk_recent_info_get_short_name (info);
1590
return info->display_name;
1594
* gtk_recent_info_get_description:
1595
* @info: a #GtkRecentInfo
1597
* Gets the (short) description of the resource.
1599
* Return value: the description of the resource. The returned string
1600
* is owned by the recent manager, and should not be freed.
1604
G_CONST_RETURN gchar *
1605
gtk_recent_info_get_description (GtkRecentInfo *info)
1607
g_return_val_if_fail (info != NULL, NULL);
1609
return info->description;
1613
* gtk_recent_info_get_mime_type:
1614
* @info: a #GtkRecentInfo
1616
* Gets the MIME type of the resource.
1618
* Return value: the MIME type of the resource. The returned string
1619
* is owned by the recent manager, and should not be freed.
1623
G_CONST_RETURN gchar *
1624
gtk_recent_info_get_mime_type (GtkRecentInfo *info)
1626
g_return_val_if_fail (info != NULL, NULL);
1628
if (!info->mime_type)
1629
info->mime_type = g_strdup (GTK_RECENT_DEFAULT_MIME);
1631
return info->mime_type;
1635
* gtk_recent_info_get_added:
1636
* @info: a #GtkRecentInfo
1638
* Gets the timestamp (seconds from system's Epoch) when the resource
1639
* was added to the recently used resources list.
1641
* Return value: the number of seconds elapsed from system's Epoch when
1642
* the resource was added to the list, or -1 on failure.
1647
gtk_recent_info_get_added (GtkRecentInfo *info)
1649
g_return_val_if_fail (info != NULL, (time_t) -1);
1655
* gtk_recent_info_get_modified:
1656
* @info: a #GtkRecentInfo
1658
* Gets the timestamp (seconds from system's Epoch) when the resource
1659
* was last modified.
1661
* Return value: the number of seconds elapsed from system's Epoch when
1662
* the resource was last modified, or -1 on failure.
1667
gtk_recent_info_get_modified (GtkRecentInfo *info)
1669
g_return_val_if_fail (info != NULL, (time_t) -1);
1671
return info->modified;
1675
* gtk_recent_info_get_visited:
1676
* @info: a #GtkRecentInfo
1678
* Gets the timestamp (seconds from system's Epoch) when the resource
1681
* Return value: the number of seconds elapsed from system's Epoch when
1682
* the resource was last visited, or -1 on failure.
1687
gtk_recent_info_get_visited (GtkRecentInfo *info)
1689
g_return_val_if_fail (info != NULL, (time_t) -1);
1691
return info->visited;
1695
* gtk_recent_info_get_private_hint:
1696
* @info: a #GtkRecentInfo
1698
* Gets the value of the "private" flag. Resources in the recently used
1699
* list that have this flag set to %TRUE should only be displayed by the
1700
* applications that have registered them.
1702
* Return value: %TRUE if the private flag was found, %FALSE otherwise.
1707
gtk_recent_info_get_private_hint (GtkRecentInfo *info)
1709
g_return_val_if_fail (info != NULL, FALSE);
1711
return info->is_private;
1715
static RecentAppInfo *
1716
recent_app_info_new (const gchar *app_name)
1718
RecentAppInfo *app_info;
1720
g_assert (app_name != NULL);
1722
app_info = g_new0 (RecentAppInfo, 1);
1723
app_info->name = g_strdup (app_name);
1724
app_info->exec = NULL;
1725
app_info->count = 1;
1726
app_info->stamp = time (NULL);
1732
recent_app_info_free (RecentAppInfo *app_info)
1738
g_free (app_info->name);
1741
g_free (app_info->exec);
1747
* gtk_recent_info_get_application_info:
1748
* @info: a #GtkRecentInfo
1749
* @app_name: the name of the application that has registered this item
1750
* @app_exec: return location for the string containing the command line
1751
* @count: return location for the number of times this item was registered
1752
* @time_: return location for the timestamp this item was last registered
1753
* for this application
1755
* Gets the data regarding the application that has registered the resource
1758
* If the command line contains any escape characters defined inside the
1759
* storage specification, they will be expanded.
1761
* Return value: %TRUE if an application with @app_name has registered this
1762
* resource inside the recently used list, or %FALSE otherwise. You should
1763
* free the returned command line using g_free().
1768
gtk_recent_info_get_application_info (GtkRecentInfo *info,
1769
const gchar *app_name,
1776
g_return_val_if_fail (info != NULL, FALSE);
1777
g_return_val_if_fail (app_name != NULL, FALSE);
1779
ai = (RecentAppInfo *) g_hash_table_lookup (info->apps_lookup,
1783
g_warning ("No registered application with name '%s' "
1784
"for item with URI '%s' found",
1791
*app_exec = ai->exec;
1803
* gtk_recent_info_get_applications:
1804
* @info: a #GtkRecentInfo
1805
* @length: return location for the length of the returned list, or %NULL
1807
* Retrieves the list of applications that have registered this resource.
1809
* Return value: a newly allocated %NULL-terminated array of strings.
1810
* Use g_strfreev() to free it.
1815
gtk_recent_info_get_applications (GtkRecentInfo *info,
1822
g_return_val_if_fail (info != NULL, NULL);
1824
if (!info->applications)
1832
n_apps = g_slist_length (info->applications);
1834
retval = g_new0 (gchar *, n_apps + 1);
1836
for (l = info->applications, i = 0;
1840
RecentAppInfo *ai = (RecentAppInfo *) l->data;
1842
g_assert (ai != NULL);
1844
retval[i++] = g_strdup (ai->name);
1855
* gtk_recent_info_has_application:
1856
* @info: a #GtkRecentInfo
1857
* @app_name: a string containing an application name
1859
* Checks whether an application registered this resource using @app_name.
1861
* Return value: %TRUE if an application with name @app_name was found,
1867
gtk_recent_info_has_application (GtkRecentInfo *info,
1868
const gchar *app_name)
1870
g_return_val_if_fail (info != NULL, FALSE);
1871
g_return_val_if_fail (app_name != NULL, FALSE);
1873
return (NULL != g_hash_table_lookup (info->apps_lookup, app_name));
1877
* gtk_recent_info_last_application:
1878
* @info: a #GtkRecentInfo
1880
* Gets the name of the last application that have registered the
1881
* recently used resource represented by @info.
1883
* Return value: an application name. Use g_free() to free it.
1888
gtk_recent_info_last_application (GtkRecentInfo *info)
1891
time_t last_stamp = (time_t) -1;
1894
g_return_val_if_fail (info != NULL, NULL);
1896
for (l = info->applications; l != NULL; l = l->next)
1898
RecentAppInfo *ai = (RecentAppInfo *) l->data;
1900
if (ai->stamp > last_stamp)
1903
last_stamp = ai->stamp;
1907
return g_strdup (name);
1917
icon_cache_element_free (IconCacheElement *element)
1919
if (element->pixbuf)
1920
g_object_unref (element->pixbuf);
1925
icon_theme_changed (GtkIconTheme *icon_theme)
1929
/* Difference from the initial creation is that we don't
1930
* reconnect the signal
1932
cache = g_hash_table_new_full (g_str_hash, g_str_equal,
1933
(GDestroyNotify)g_free,
1934
(GDestroyNotify)icon_cache_element_free);
1935
g_object_set_data_full (G_OBJECT (icon_theme), "gtk-recent-icon-cache",
1936
cache, (GDestroyNotify)g_hash_table_destroy);
1939
/* TODO: use the GtkFileChooser's icon cache instead of our own to reduce
1940
* the memory footprint
1943
get_cached_icon (const gchar *name,
1946
GtkIconTheme *icon_theme;
1948
IconCacheElement *element;
1950
icon_theme = gtk_icon_theme_get_default ();
1951
cache = g_object_get_data (G_OBJECT (icon_theme), "gtk-recent-icon-cache");
1955
cache = g_hash_table_new_full (g_str_hash, g_str_equal,
1956
(GDestroyNotify)g_free,
1957
(GDestroyNotify)icon_cache_element_free);
1959
g_object_set_data_full (G_OBJECT (icon_theme), "gtk-recent-icon-cache",
1960
cache, (GDestroyNotify)g_hash_table_destroy);
1961
g_signal_connect (icon_theme, "changed",
1962
G_CALLBACK (icon_theme_changed), NULL);
1965
element = g_hash_table_lookup (cache, name);
1968
element = g_new0 (IconCacheElement, 1);
1969
g_hash_table_insert (cache, g_strdup (name), element);
1972
if (element->size != pixel_size)
1974
if (element->pixbuf)
1975
g_object_unref (element->pixbuf);
1977
element->size = pixel_size;
1978
element->pixbuf = gtk_icon_theme_load_icon (icon_theme, name,
1979
pixel_size, 0, NULL);
1982
return element->pixbuf ? g_object_ref (element->pixbuf) : NULL;
1987
get_icon_for_mime_type (const char *mime_type,
1990
const char *separator;
1994
separator = strchr (mime_type, '/');
1996
return NULL; /* maybe we should return a GError with "invalid MIME-type" */
1998
icon_name = g_string_new ("gnome-mime-");
1999
g_string_append_len (icon_name, mime_type, separator - mime_type);
2000
g_string_append_c (icon_name, '-');
2001
g_string_append (icon_name, separator + 1);
2002
pixbuf = get_cached_icon (icon_name->str, pixel_size);
2003
g_string_free (icon_name, TRUE);
2007
icon_name = g_string_new ("gnome-mime-");
2008
g_string_append_len (icon_name, mime_type, separator - mime_type);
2009
pixbuf = get_cached_icon (icon_name->str, pixel_size);
2010
g_string_free (icon_name, TRUE);
2016
get_icon_fallback (const gchar *icon_name,
2019
GtkIconTheme *icon_theme;
2022
icon_theme = gtk_icon_theme_get_default ();
2024
retval = gtk_icon_theme_load_icon (icon_theme, icon_name,
2026
GTK_ICON_LOOKUP_USE_BUILTIN,
2028
g_assert (retval != NULL);
2034
* gtk_recent_info_get_icon:
2035
* @info: a #GtkRecentInfo
2036
* @size: the size of the icon in pixels
2038
* Retrieves the icon of size @size associated to the resource MIME type.
2040
* Return value: a #GdkPixbuf containing the icon, or %NULL.
2045
gtk_recent_info_get_icon (GtkRecentInfo *info,
2048
GdkPixbuf *retval = NULL;
2050
g_return_val_if_fail (info != NULL, NULL);
2052
if (info->mime_type)
2053
retval = get_icon_for_mime_type (info->mime_type, size);
2055
/* this should never fail */
2057
retval = get_icon_fallback (GTK_STOCK_FILE, size);
2063
* gtk_recent_info_is_local:
2064
* @info: a #GtkRecentInfo
2066
* Checks whether the resource is local or not by looking at the
2067
* scheme of its URI.
2069
* Return value: %TRUE if the resource is local.
2074
gtk_recent_info_is_local (GtkRecentInfo *info)
2076
g_return_val_if_fail (info != NULL, FALSE);
2078
return has_case_prefix (info->uri, "file:/");
2082
* gtk_recent_info_exists:
2083
* @info: a #GtkRecentInfo
2085
* Checks whether the resource pointed by @info still exists. At
2086
* the moment this check is done only on resources pointing to local files.
2088
* Return value: %TRUE if the resource exists
2093
gtk_recent_info_exists (GtkRecentInfo *info)
2096
struct stat stat_buf;
2097
gboolean retval = FALSE;
2099
g_return_val_if_fail (info != NULL, FALSE);
2101
/* we guarantee only local resources */
2102
if (!gtk_recent_info_is_local (info))
2105
filename = g_filename_from_uri (info->uri, NULL, NULL);
2108
if (stat (filename, &stat_buf) == 0)
2118
* gtk_recent_info_match:
2119
* @info_a: a #GtkRecentInfo
2120
* @info_b: a #GtkRecentInfo
2122
* Checks whether two #GtkRecentInfo structures point to the same
2125
* Return value: %TRUE if both #GtkRecentInfo structures point to se same
2126
* resource, %FALSE otherwise.
2131
gtk_recent_info_match (GtkRecentInfo *info_a,
2132
GtkRecentInfo *info_b)
2134
g_return_val_if_fail (info_a != NULL, FALSE);
2135
g_return_val_if_fail (info_b != NULL, FALSE);
2137
return (0 == strcmp (info_a->uri, info_b->uri));
2140
/* taken from gnome-vfs-uri.c */
2141
static const gchar *
2142
get_method_string (const gchar *substring,
2143
gchar **method_string)
2149
g_ascii_isalnum (*p) || *p == '+' || *p == '-' || *p == '.';
2156
!(p == substring + 1 && g_ascii_isalpha (*substring))
2160
/* Found toplevel method specification. */
2161
method = g_strndup (substring, p - substring);
2162
*method_string = g_ascii_strdown (method, -1);
2168
*method_string = g_strdup ("file");
2175
/* Stolen from gnome_vfs_make_valid_utf8() */
2177
make_valid_utf8 (const char *name)
2180
const char *remainder, *invalid;
2181
int remaining_bytes, valid_bytes;
2185
remaining_bytes = name ? strlen (name) : 0;
2187
while (remaining_bytes != 0)
2189
if (g_utf8_validate (remainder, remaining_bytes, &invalid))
2192
valid_bytes = invalid - remainder;
2195
string = g_string_sized_new (remaining_bytes);
2197
g_string_append_len (string, remainder, valid_bytes);
2198
g_string_append_c (string, '?');
2200
remaining_bytes -= valid_bytes + 1;
2201
remainder = invalid + 1;
2205
return g_strdup (name);
2207
g_string_append (string, remainder);
2208
g_assert (g_utf8_validate (string->str, -1, NULL));
2210
return g_string_free (string, FALSE);
2214
get_uri_shortname_for_display (const gchar *uri)
2217
gboolean validated = FALSE;
2219
if (has_case_prefix (uri, "file:/"))
2223
local_file = g_filename_from_uri (uri, NULL, NULL);
2227
name = g_filename_display_basename (local_file);
2231
g_free (local_file);
2240
rest = get_method_string (uri, &method);
2241
local_file = g_filename_display_basename (rest);
2243
name = g_strdup_printf ("%s: %s", method, local_file);
2245
g_free (local_file);
2249
g_assert (name != NULL);
2251
if (!validated && !g_utf8_validate (name, -1, NULL))
2255
utf8_name = make_valid_utf8 (name);
2265
* gtk_recent_info_get_short_name:
2266
* @info: an #GtkRecentInfo
2268
* Computes a valid UTF-8 string that can be used as the name of the item in a
2269
* menu or list. For example, calling this function on an item that refers to
2270
* "file:///foo/bar.txt" will yield "bar.txt".
2272
* Return value: A newly-allocated string in UTF-8 encoding; free it with
2278
gtk_recent_info_get_short_name (GtkRecentInfo *info)
2282
g_return_val_if_fail (info != NULL, NULL);
2284
if (info->uri == NULL)
2287
short_name = get_uri_shortname_for_display (info->uri);
2293
* gtk_recent_info_get_uri_display:
2294
* @info: a #GtkRecentInfo
2296
* Gets a displayable version of the resource's URI.
2298
* Return value: a UTF-8 string containing the resource's URI or %NULL
2303
gtk_recent_info_get_uri_display (GtkRecentInfo *info)
2305
gchar *filename, *filename_utf8;
2307
g_return_val_if_fail (info != NULL, NULL);
2309
filename = g_filename_from_uri (info->uri, NULL, NULL);
2313
filename_utf8 = g_filename_to_utf8 (filename, -1, NULL, NULL, NULL);
2316
return filename_utf8;
2320
* gtk_recent_info_get_age:
2321
* @info: a #GtkRecentInfo
2323
* Gets the number of days elapsed since the last update of the resource
2326
* Return value: a positive integer containing the number of days elapsed
2327
* since the time this resource was last modified.
2332
gtk_recent_info_get_age (GtkRecentInfo *info)
2337
g_return_val_if_fail (info != NULL, -1);
2341
delta = now - info->modified;
2343
retval = (gint) (delta / (60 * 60 * 24));
2349
* gtk_recent_info_get_groups:
2350
* @info: a #GtkRecentInfo
2351
* @length: return location for the number of groups returned, or %NULL
2353
* Returns all groups registered for the recently used item @info. The
2354
* array of returned group names will be %NULL terminated, so length might
2355
* optionally be %NULL.
2357
* Return value: a newly allocated %NULL terminated array of strings. Use
2358
* g_strfreev() to free it.
2363
gtk_recent_info_get_groups (GtkRecentInfo *info,
2370
g_return_val_if_fail (info != NULL, NULL);
2380
n_groups = g_slist_length (info->groups);
2382
retval = g_new0 (gchar *, n_groups + 1);
2384
for (l = info->groups, i = 0;
2388
gchar *group_name = (gchar *) l->data;
2390
g_assert (group_name != NULL);
2392
retval[i++] = g_strdup (group_name);
2403
* gtk_recent_info_has_group:
2404
* @info: a #GtkRecentInfo
2405
* @group_name: name of a group
2407
* Checks whether @group_name appears inside the groups registered for the
2408
* recently used item @info.
2410
* Return value: %TRUE if the group was found.
2415
gtk_recent_info_has_group (GtkRecentInfo *info,
2416
const gchar *group_name)
2420
g_return_val_if_fail (info != NULL, FALSE);
2421
g_return_val_if_fail (group_name != NULL, FALSE);
2426
for (l = info->groups; l != NULL; l = l->next)
2428
gchar *g = (gchar *) l->data;
2430
if (strcmp (g, group_name) == 0)
2437
#define __GTK_RECENT_MANAGER_C__
2438
#include "gtkaliasdef.c"
added
removed
gtk/gtkrecentmanager.c
