moving from https://github.com/perberos/mate-desktop-environment

author: Perberos <[email protected]> 2011-12-01 22:24:23 -0300
committer: Perberos <[email protected]> 2011-12-01 22:24:23 -0300
commit: 0e004c696b0e68b2cff37a4c3315b022a35eaf43 (patch)
tree: 43261e815529cb9518ed7be37af13b846af8b26b /src/caja-bookmark-list.c
download: caja-0e004c696b0e68b2cff37a4c3315b022a35eaf43.tar.bz2
caja-0e004c696b0e68b2cff37a4c3315b022a35eaf43.tar.xz
1 files changed, 775 insertions, 0 deletions
diff --git a/src/caja-bookmark-list.c b/src/caja-bookmark-list.c
new file mode 100644
index 00000000..17f9b961
--- /dev/null
+++ b/src/caja-bookmark-list.c
@@ -0,0 +1,775 @@
+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
+
+/*
+ * Caja
+ *
+ * Copyright (C) 1999, 2000 Eazel, Inc.
+ *
+ * Caja is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * Caja is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors: John Sullivan <[email protected]>
+ */
+
+/* caja-bookmark-list.c - implementation of centralized list of bookmarks.
+ */
+
+#include <config.h>
+#include "caja-bookmark-list.h"
+
+#include <libcaja-private/caja-file-utilities.h>
+#include <libcaja-private/caja-file.h>
+#include <libcaja-private/caja-icon-names.h>
+#include <eel/eel-glib-extensions.h>
+#include <eel/eel-string.h>
+#include <gio/gio.h>
+
+#define MAX_BOOKMARK_LENGTH 80
+#define LOAD_JOB 1
+#define SAVE_JOB 2
+
+enum
+{
+ CONTENTS_CHANGED,
+ LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL];
+static char *window_geometry;
+static CajaBookmarkList *singleton = NULL;
+
+/* forward declarations */
+
+static void caja_bookmark_list_load_file (CajaBookmarkList *bookmarks);
+static void caja_bookmark_list_save_file (CajaBookmarkList *bookmarks);
+
+G_DEFINE_TYPE(CajaBookmarkList, caja_bookmark_list, G_TYPE_OBJECT)
+
+static CajaBookmark *
+new_bookmark_from_uri (const char *uri, const char *label)
+{
+ CajaBookmark *new_bookmark;
+ CajaFile *file;
+ char *name;
+ GIcon *icon;
+ gboolean has_label;
+ GFile *location;
+ gboolean native;
+
+ location = NULL;
+ if (uri)
+ {
+ location = g_file_new_for_uri (uri);
+ }
+
+ has_label = FALSE;
+ if (!label)
+ {
+ name = caja_compute_title_for_location (location);
+ }
+ else
+ {
+ name = g_strdup (label);
+ has_label = TRUE;
+ }
+
+ new_bookmark = NULL;
+
+ if (uri)
+ {
+ native = g_file_is_native (location);
+ file = caja_file_get (location);
+
+ icon = NULL;
+ if (caja_file_check_if_ready (file,
+ CAJA_FILE_ATTRIBUTES_FOR_ICON))
+ {
+ icon = caja_file_get_gicon (file, 0);
+ }
+ caja_file_unref (file);
+
+ if (icon == NULL)
+ {
+ icon = native ? g_themed_icon_new (CAJA_ICON_FOLDER) :
+ g_themed_icon_new (CAJA_ICON_FOLDER_REMOTE);
+ }
+
+ new_bookmark = caja_bookmark_new (location, name, has_label, icon);
+
+ g_object_unref (icon);
+
+ }
+ g_free (name);
+ g_object_unref (location);
+ return new_bookmark;
+}
+
+static GFile *
+caja_bookmark_list_get_file (void)
+{
+ char *filename;
+ GFile *file;
+
+ filename = g_build_filename (g_get_home_dir (),
+ ".gtk-bookmarks",
+ NULL);
+ file = g_file_new_for_path (filename);
+
+ g_free (filename);
+
+ return file;
+}
+
+/* Initialization. */
+
+static void
+bookmark_in_list_changed_callback (CajaBookmark *bookmark,
+ CajaBookmarkList *bookmarks)
+{
+ g_assert (CAJA_IS_BOOKMARK (bookmark));
+ g_assert (CAJA_IS_BOOKMARK_LIST (bookmarks));
+
+ /* Save changes so we'll have the good icon next time. */
+ caja_bookmark_list_save_file (bookmarks);
+}
+
+static void
+stop_monitoring_bookmark (CajaBookmarkList *bookmarks,
+ CajaBookmark *bookmark)
+{
+ g_signal_handlers_disconnect_by_func (bookmark,
+ bookmark_in_list_changed_callback,
+ bookmarks);
+}
+
+static void
+stop_monitoring_one (gpointer data, gpointer user_data)
+{
+ g_assert (CAJA_IS_BOOKMARK (data));
+ g_assert (CAJA_IS_BOOKMARK_LIST (user_data));
+
+ stop_monitoring_bookmark (CAJA_BOOKMARK_LIST (user_data),
+ CAJA_BOOKMARK (data));
+}
+
+static void
+clear (CajaBookmarkList *bookmarks)
+{
+ g_list_foreach (bookmarks->list, stop_monitoring_one, bookmarks);
+ eel_g_object_list_free (bookmarks->list);
+ bookmarks->list = NULL;
+}
+
+static void
+do_finalize (GObject *object)
+{
+ if (CAJA_BOOKMARK_LIST (object)->monitor != NULL)
+ {
+ g_file_monitor_cancel (CAJA_BOOKMARK_LIST (object)->monitor);
+ CAJA_BOOKMARK_LIST (object)->monitor = NULL;
+ }
+
+ g_queue_free (CAJA_BOOKMARK_LIST (object)->pending_ops);
+
+ clear (CAJA_BOOKMARK_LIST (object));
+
+ G_OBJECT_CLASS (caja_bookmark_list_parent_class)->finalize (object);
+}
+
+static GObject *
+do_constructor (GType type,
+ guint n_construct_params,
+ GObjectConstructParam *construct_params)
+{
+ GObject *retval;
+
+ if (singleton != NULL)
+ {
+ return g_object_ref (singleton);
+ }
+
+ retval = G_OBJECT_CLASS (caja_bookmark_list_parent_class)->constructor
+ (type, n_construct_params, construct_params);
+
+ singleton = CAJA_BOOKMARK_LIST (retval);
+ g_object_add_weak_pointer (retval, (gpointer) &singleton);
+
+ return retval;
+}
+
+
+static void
+caja_bookmark_list_class_init (CajaBookmarkListClass *class)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (class);
+
+ object_class->finalize = do_finalize;
+ object_class->constructor = do_constructor;
+
+ signals[CONTENTS_CHANGED] =
+ g_signal_new ("contents_changed",
+ G_TYPE_FROM_CLASS (object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaBookmarkListClass,
+ contents_changed),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+}
+
+static void
+bookmark_monitor_changed_cb (GFileMonitor *monitor,
+ GFile *child,
+ GFile *other_file,
+ GFileMonitorEvent eflags,
+ gpointer user_data)
+{
+ if (eflags == G_FILE_MONITOR_EVENT_CHANGED ||
+ eflags == G_FILE_MONITOR_EVENT_CREATED)
+ {
+ g_return_if_fail (CAJA_IS_BOOKMARK_LIST (CAJA_BOOKMARK_LIST (user_data)));
+ caja_bookmark_list_load_file (CAJA_BOOKMARK_LIST (user_data));
+ }
+}
+
+static void
+caja_bookmark_list_init (CajaBookmarkList *bookmarks)
+{
+ GFile *file;
+
+ bookmarks->pending_ops = g_queue_new ();
+
+ caja_bookmark_list_load_file (bookmarks);
+
+ file = caja_bookmark_list_get_file ();
+ bookmarks->monitor = g_file_monitor_file (file, 0, NULL, NULL);
+ g_file_monitor_set_rate_limit (bookmarks->monitor, 1000);
+
+ g_signal_connect (bookmarks->monitor, "changed",
+ G_CALLBACK (bookmark_monitor_changed_cb), bookmarks);
+
+ g_object_unref (file);
+}
+
+static void
+insert_bookmark_internal (CajaBookmarkList *bookmarks,
+ CajaBookmark *bookmark,
+ int index)
+{
+ bookmarks->list = g_list_insert (bookmarks->list, bookmark, index);
+
+ g_signal_connect_object (bookmark, "contents_changed",
+ G_CALLBACK (bookmark_in_list_changed_callback), bookmarks, 0);
+}
+
+/**
+ * caja_bookmark_list_append:
+ *
+ * Append a bookmark to a bookmark list.
+ * @bookmarks: CajaBookmarkList to append to.
+ * @bookmark: Bookmark to append a copy of.
+ **/
+void
+caja_bookmark_list_append (CajaBookmarkList *bookmarks,
+ CajaBookmark *bookmark)
+{
+ g_return_if_fail (CAJA_IS_BOOKMARK_LIST (bookmarks));
+ g_return_if_fail (CAJA_IS_BOOKMARK (bookmark));
+
+ insert_bookmark_internal (bookmarks,
+ caja_bookmark_copy (bookmark),
+ -1);
+
+ caja_bookmark_list_save_file (bookmarks);
+}
+
+/**
+ * caja_bookmark_list_contains:
+ *
+ * Check whether a bookmark with matching name and url is already in the list.
+ * @bookmarks: CajaBookmarkList to check contents of.
+ * @bookmark: CajaBookmark to match against.
+ *
+ * Return value: TRUE if matching bookmark is in list, FALSE otherwise
+ **/
+gboolean
+caja_bookmark_list_contains (CajaBookmarkList *bookmarks,
+ CajaBookmark *bookmark)
+{
+ g_return_val_if_fail (CAJA_IS_BOOKMARK_LIST (bookmarks), FALSE);
+ g_return_val_if_fail (CAJA_IS_BOOKMARK (bookmark), FALSE);
+
+ return g_list_find_custom (bookmarks->list,
+ (gpointer)bookmark,
+ caja_bookmark_compare_with)
+ != NULL;
+}
+
+/**
+ * caja_bookmark_list_delete_item_at:
+ *
+ * Delete the bookmark at the specified position.
+ * @bookmarks: the list of bookmarks.
+ * @index: index, must be less than length of list.
+ **/
+void
+caja_bookmark_list_delete_item_at (CajaBookmarkList *bookmarks,
+ guint index)
+{
+ GList *doomed;
+
+ g_return_if_fail (CAJA_IS_BOOKMARK_LIST (bookmarks));
+ g_return_if_fail (index < g_list_length (bookmarks->list));
+
+ doomed = g_list_nth (bookmarks->list, index);
+ bookmarks->list = g_list_remove_link (bookmarks->list, doomed);
+
+ g_assert (CAJA_IS_BOOKMARK (doomed->data));
+ stop_monitoring_bookmark (bookmarks, CAJA_BOOKMARK (doomed->data));
+ g_object_unref (doomed->data);
+
+ g_list_free_1 (doomed);
+
+ caja_bookmark_list_save_file (bookmarks);
+}
+
+/**
+ * caja_bookmark_list_move_item:
+ *
+ * Move the item from the given position to the destination.
+ * @index: the index of the first bookmark.
+ * @destination: the index of the second bookmark.
+ **/
+void
+caja_bookmark_list_move_item (CajaBookmarkList *bookmarks,
+ guint index,
+ guint destination)
+{
+ GList *bookmark_item;
+
+ if (index == destination)
+ {
+ return;
+ }
+
+ bookmark_item = g_list_nth (bookmarks->list, index);
+ bookmarks->list = g_list_remove_link (bookmarks->list,
+ bookmark_item);
+
+ if (index < destination)
+ {
+ bookmarks->list = g_list_insert (bookmarks->list,
+ bookmark_item->data,
+ destination - 1);
+ }
+ else
+ {
+ bookmarks->list = g_list_insert (bookmarks->list,
+ bookmark_item->data,
+ destination);
+ }
+
+ caja_bookmark_list_save_file (bookmarks);
+}
+
+/**
+ * caja_bookmark_list_delete_items_with_uri:
+ *
+ * Delete all bookmarks with the given uri.
+ * @bookmarks: the list of bookmarks.
+ * @uri: The uri to match.
+ **/
+void
+caja_bookmark_list_delete_items_with_uri (CajaBookmarkList *bookmarks,
+ const char *uri)
+{
+ GList *node, *next;
+ gboolean list_changed;
+ char *bookmark_uri;
+
+ g_return_if_fail (CAJA_IS_BOOKMARK_LIST (bookmarks));
+ g_return_if_fail (uri != NULL);
+
+ list_changed = FALSE;
+ for (node = bookmarks->list; node != NULL; node = next)
+ {
+ next = node->next;
+
+ bookmark_uri = caja_bookmark_get_uri (CAJA_BOOKMARK (node->data));
+ if (eel_strcmp (bookmark_uri, uri) == 0)
+ {
+ bookmarks->list = g_list_remove_link (bookmarks->list, node);
+ stop_monitoring_bookmark (bookmarks, CAJA_BOOKMARK (node->data));
+ g_object_unref (node->data);
+ g_list_free_1 (node);
+ list_changed = TRUE;
+ }
+ g_free (bookmark_uri);
+ }
+
+ if (list_changed)
+ {
+ caja_bookmark_list_save_file (bookmarks);
+ }
+}
+
+/**
+ * caja_bookmark_list_get_window_geometry:
+ *
+ * Get a string representing the bookmark_list's window's geometry.
+ * This is the value set earlier by caja_bookmark_list_set_window_geometry.
+ * @bookmarks: the list of bookmarks associated with the window.
+ * Return value: string representation of window's geometry, suitable for
+ * passing to mate_parse_geometry(), or NULL if
+ * no window geometry has yet been saved for this bookmark list.
+ **/
+const char *
+caja_bookmark_list_get_window_geometry (CajaBookmarkList *bookmarks)
+{
+ return window_geometry;
+}
+
+/**
+ * caja_bookmark_list_insert_item:
+ *
+ * Insert a bookmark at a specified position.
+ * @bookmarks: the list of bookmarks.
+ * @index: the position to insert the bookmark at.
+ * @new_bookmark: the bookmark to insert a copy of.
+ **/
+void
+caja_bookmark_list_insert_item (CajaBookmarkList *bookmarks,
+ CajaBookmark *new_bookmark,
+ guint index)
+{
+ g_return_if_fail (CAJA_IS_BOOKMARK_LIST (bookmarks));
+ g_return_if_fail (index <= g_list_length (bookmarks->list));
+
+ insert_bookmark_internal (bookmarks,
+ caja_bookmark_copy (new_bookmark),
+ index);
+
+ caja_bookmark_list_save_file (bookmarks);
+}
+
+/**
+ * caja_bookmark_list_item_at:
+ *
+ * Get the bookmark at the specified position.
+ * @bookmarks: the list of bookmarks.
+ * @index: index, must be less than length of list.
+ *
+ * Return value: the bookmark at position @index in @bookmarks.
+ **/
+CajaBookmark *
+caja_bookmark_list_item_at (CajaBookmarkList *bookmarks, guint index)
+{
+ g_return_val_if_fail (CAJA_IS_BOOKMARK_LIST (bookmarks), NULL);
+ g_return_val_if_fail (index < g_list_length (bookmarks->list), NULL);
+
+ return CAJA_BOOKMARK (g_list_nth_data (bookmarks->list, index));
+}
+
+/**
+ * caja_bookmark_list_length:
+ *
+ * Get the number of bookmarks in the list.
+ * @bookmarks: the list of bookmarks.
+ *
+ * Return value: the length of the bookmark list.
+ **/
+guint
+caja_bookmark_list_length (CajaBookmarkList *bookmarks)
+{
+ g_return_val_if_fail (CAJA_IS_BOOKMARK_LIST(bookmarks), 0);
+
+ return g_list_length (bookmarks->list);
+}
+
+static void
+load_file_finish (CajaBookmarkList *bookmarks,
+ GObject *source,
+ GAsyncResult *res)
+{
+ GError *error = NULL;
+ gchar *contents = NULL;
+
+ g_file_load_contents_finish (G_FILE (source),
+ res, &contents, NULL, NULL, &error);
+
+ if (error == NULL)
+ {
+ char **lines;
+ int i;
+
+ lines = g_strsplit (contents, "\n", -1);
+ for (i = 0; lines[i]; i++)
+ {
+ /* Ignore empty or invalid lines that cannot be parsed properly */
+ if (lines[i][0] != '\0' && lines[i][0] != ' ')
+ {
+ /* gtk 2.7/2.8 might have labels appended to bookmarks which are separated by a space */
+ /* we must seperate the bookmark uri and the potential label */
+ char *space, *label;
+
+ label = NULL;
+ space = strchr (lines[i], ' ');
+ if (space)
+ {
+ *space = '\0';
+ label = g_strdup (space + 1);
+ }
+ insert_bookmark_internal (bookmarks,
+ new_bookmark_from_uri (lines[i], label),
+ -1);
+
+ g_free (label);
+ }
+ }
+ g_free (contents);
+ g_strfreev (lines);
+
+ g_signal_emit (bookmarks, signals[CONTENTS_CHANGED], 0);
+ }
+ else if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
+ {
+ g_warning ("Could not load bookmark file: %s\n", error->message);
+ g_error_free (error);
+ }
+}
+
+static void
+load_file_async (CajaBookmarkList *self,
+ GAsyncReadyCallback callback)
+{
+ GFile *file;
+
+ file = caja_bookmark_list_get_file ();
+
+ /* Wipe out old list. */
+ clear (self);
+
+ /* keep the bookmark list alive */
+ g_object_ref (self);
+ g_file_load_contents_async (file, NULL, callback, self);
+
+ g_object_unref (file);
+}
+
+static void
+save_file_finish (CajaBookmarkList *bookmarks,
+ GObject *source,
+ GAsyncResult *res)
+{
+ GError *error = NULL;
+ GFile *file;
+
+ g_file_replace_contents_finish (G_FILE (source),
+ res, NULL, &error);
+
+ if (error != NULL)
+ {
+ g_warning ("Unable to replace contents of the bookmarks file: %s",
+ error->message);
+ g_error_free (error);
+ }
+
+ file = caja_bookmark_list_get_file ();
+
+ /* re-enable bookmark file monitoring */
+ bookmarks->monitor = g_file_monitor_file (file, 0, NULL, NULL);
+ g_file_monitor_set_rate_limit (bookmarks->monitor, 1000);
+ g_signal_connect (bookmarks->monitor, "changed",
+ G_CALLBACK (bookmark_monitor_changed_cb), bookmarks);
+
+ g_object_unref (file);
+}
+
+static void
+save_file_async (CajaBookmarkList *bookmarks,
+ GAsyncReadyCallback callback)
+{
+ GFile *file;
+ GList *l;
+ GString *bookmark_string;
+
+ /* temporarily disable bookmark file monitoring when writing file */
+ if (bookmarks->monitor != NULL)
+ {
+ g_file_monitor_cancel (bookmarks->monitor);
+ bookmarks->monitor = NULL;
+ }
+
+ file = caja_bookmark_list_get_file ();
+ bookmark_string = g_string_new (NULL);
+
+ for (l = bookmarks->list; l; l = l->next)
+ {
+ CajaBookmark *bookmark;
+
+ bookmark = CAJA_BOOKMARK (l->data);
+
+ /* make sure we save label if it has one for compatibility with GTK 2.7 and 2.8 */
+ if (caja_bookmark_get_has_custom_name (bookmark))
+ {
+ char *label, *uri;
+ label = caja_bookmark_get_name (bookmark);
+ uri = caja_bookmark_get_uri (bookmark);
+ g_string_append_printf (bookmark_string,
+ "%s %s\n", uri, label);
+ g_free (uri);
+ g_free (label);
+ }
+ else
+ {
+ char *uri;
+ uri = caja_bookmark_get_uri (bookmark);
+ g_string_append_printf (bookmark_string, "%s\n", uri);
+ g_free (uri);
+ }
+ }
+
+ /* keep the bookmark list alive */
+ g_object_ref (bookmarks);
+ g_file_replace_contents_async (file, bookmark_string->str,
+ bookmark_string->len, NULL,
+ FALSE, 0, NULL, callback,
+ bookmarks);
+
+ g_object_unref (file);
+}
+
+static void
+process_next_op (CajaBookmarkList *bookmarks);
+
+static void
+op_processed_cb (GObject *source,
+ GAsyncResult *res,
+ gpointer user_data)
+{
+ CajaBookmarkList *self = user_data;
+ int op;
+
+ op = GPOINTER_TO_INT (g_queue_pop_tail (self->pending_ops));
+
+ if (op == LOAD_JOB)
+ {
+ load_file_finish (self, source, res);
+ }
+ else
+ {
+ save_file_finish (self, source, res);
+ }
+
+ if (!g_queue_is_empty (self->pending_ops))
+ {
+ process_next_op (self);
+ }
+
+ /* release the reference acquired during the _async method */
+ g_object_unref (self);
+}
+
+static void
+process_next_op (CajaBookmarkList *bookmarks)
+{
+ gint op;
+
+ op = GPOINTER_TO_INT (g_queue_peek_tail (bookmarks->pending_ops));
+
+ if (op == LOAD_JOB)
+ {
+ load_file_async (bookmarks, op_processed_cb);
+ }
+ else
+ {
+ save_file_async (bookmarks, op_processed_cb);
+ }
+}
+
+/**
+ * caja_bookmark_list_load_file:
+ *
+ * Reads bookmarks from file, clobbering contents in memory.
+ * @bookmarks: the list of bookmarks to fill with file contents.
+ **/
+static void
+caja_bookmark_list_load_file (CajaBookmarkList *bookmarks)
+{
+ g_queue_push_head (bookmarks->pending_ops, GINT_TO_POINTER (LOAD_JOB));
+
+ if (g_queue_get_length (bookmarks->pending_ops) == 1)
+ {
+ process_next_op (bookmarks);
+ }
+}
+
+/**
+ * caja_bookmark_list_save_file:
+ *
+ * Save bookmarks to disk.
+ * @bookmarks: the list of bookmarks to save.
+ **/
+static void
+caja_bookmark_list_save_file (CajaBookmarkList *bookmarks)
+{
+ g_signal_emit (bookmarks, signals[CONTENTS_CHANGED], 0);
+
+ g_queue_push_head (bookmarks->pending_ops, GINT_TO_POINTER (SAVE_JOB));
+
+ if (g_queue_get_length (bookmarks->pending_ops) == 1)
+ {
+ process_next_op (bookmarks);
+ }
+}
+
+/**
+ * caja_bookmark_list_new:
+ *
+ * Create a new bookmark_list, with contents read from disk.
+ *
+ * Return value: A pointer to the new widget.
+ **/
+CajaBookmarkList *
+caja_bookmark_list_new (void)
+{
+ CajaBookmarkList *list;
+
+ list = CAJA_BOOKMARK_LIST (g_object_new (CAJA_TYPE_BOOKMARK_LIST, NULL));
+
+ return list;
+}
+
+/**
+ * caja_bookmark_list_set_window_geometry:
+ *
+ * Set a bookmarks window's geometry (position & size), in string form. This is
+ * stored to disk by this class, and can be retrieved later in
+ * the same session or in a future session.
+ * @bookmarks: the list of bookmarks associated with the window.
+ * @geometry: the new window geometry string.
+ **/
+void
+caja_bookmark_list_set_window_geometry (CajaBookmarkList *bookmarks,
+ const char *geometry)
+{
+ g_return_if_fail (CAJA_IS_BOOKMARK_LIST (bookmarks));
+ g_return_if_fail (geometry != NULL);
+
+ g_free (window_geometry);
+ window_geometry = g_strdup (geometry);
+
+ caja_bookmark_list_save_file (bookmarks);
+}
+
author	Perberos <[email protected]>	2011-12-01 22:24:23 -0300
committer	Perberos <[email protected]>	2011-12-01 22:24:23 -0300
commit	0e004c696b0e68b2cff37a4c3315b022a35eaf43 (patch)
tree	43261e815529cb9518ed7be37af13b846af8b26b /src/caja-bookmark-list.c
download	caja-0e004c696b0e68b2cff37a4c3315b022a35eaf43.tar.bz2 caja-0e004c696b0e68b2cff37a4c3315b022a35eaf43.tar.xz