nyje/medit
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
medit/moo/mooutils/moohistorymgr.c
Yevgen Muntyan bf5655c0bc Document even less stuff
2011-01-24 03:21:24 -08:00

1917 lines
52 KiB
C
Raw Blame History

/*
* moohistorymgr.h
*
* Copyright (C) 2004-2010 by Yevgen Muntyan <emuntyan@users.sourceforge.net>
*
* This file is part of medit. medit is free software; you can
* redistribute it and/or modify it under the terms of the
* GNU Lesser General Public License as published by the
* Free Software Foundation; either version 2.1 of the License,
* or (at your option) any later version.
*
* You should have received a copy of the GNU Lesser General Public
* License along with medit. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* class:MooHistoryMgr: (parent GObject) (moo.private 1)
**/
#include "mooutils/moohistorymgr.h"
#include "mooutils/moofileicon.h"
#include "mooutils/mooapp-ipc.h"
#include "mooutils/moofilewatch.h"
#include "mooutils/mooutils-misc.h"
#include "mooutils/mooutils-gobject.h"
#include "mooutils/mooutils-fs.h"
#include "mooutils/mooutils-treeview.h"
#include "mooutils/mooprefs.h"
#include "mooutils/moomarkup.h"
#include "mooutils/mooutils-thread.h"
#include "mooutils/moolist.h"
#include "mooutils/mootype-macros.h"
#include "marshals.h"
#include <stdarg.h>
#include <string.h>
#define N_MENU_ITEMS 10
#define MAX_ITEM_NUMBER 5000
#define IPC_ID "MooHistoryMgr"
MOO_DEFINE_DLIST (WidgetList, widget_list, GtkWidget)
MOO_DEFINE_QUEUE (MooHistoryItem, moo_history_item)
MOO_DEFINE_QUARK (moo-history-mgr-parse-error, moo_history_mgr_parse_error_quark)
struct _MooHistoryMgrPrivate {
char *filename;
char *basename;
char *name;
char *ipc_id;
guint save_idle;
guint update_widgets_idle;
WidgetList *widgets;
MooHistoryItemQueue *files;
GHashTable *hash;
guint loaded : 1;
};
typedef struct {
MooHistoryCallback callback;
gpointer data;
GDestroyNotify notify;
} CallbackData;
struct _MooHistoryItem {
char *uri;
GData *data;
MooFileIcon *icon;
};
typedef enum {
UPDATE_ITEM_UPDATE,
UPDATE_ITEM_REMOVE,
UPDATE_ITEM_ADD
} UpdateType;
static GObject *moo_history_mgr_constructor (GType type,
guint n_props,
GObjectConstructParam *props);
static void moo_history_mgr_dispose (GObject *object);
static void moo_history_mgr_set_property(GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void moo_history_mgr_get_property(GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
static const char *get_filename (MooHistoryMgr *mgr);
static const char *get_basename (MooHistoryMgr *mgr);
static void ensure_files (MooHistoryMgr *mgr);
static void schedule_save (MooHistoryMgr *mgr);
static void moo_history_mgr_save (MooHistoryMgr *mgr);
static void populate_menu (MooHistoryMgr *mgr,
GtkWidget *menu);
static void schedule_update_widgets (MooHistoryMgr *mgr);
static void moo_history_item_format (MooHistoryItem *item,
GString *buffer);
static gboolean moo_history_item_equal (MooHistoryItem *item1,
MooHistoryItem *item2);
static MooFileIcon *moo_history_item_get_icon (MooHistoryItem *item);
static char *uri_get_basename (const char *uri);
static char *uri_get_display_name (const char *uri);
static void ipc_callback (GObject *obj,
const char *data,
gsize len);
static void ipc_notify_add_file (MooHistoryMgr *mgr,
MooHistoryItem *item);
static void ipc_notify_update_file (MooHistoryMgr *mgr,
MooHistoryItem *item);
static void ipc_notify_remove_file (MooHistoryMgr *mgr,
MooHistoryItem *item);
G_DEFINE_TYPE (MooHistoryMgr, moo_history_mgr, G_TYPE_OBJECT)
enum {
PROP_0,
PROP_NAME,
PROP_EMPTY
};
enum {
CHANGED,
N_SIGNALS
};
static guint signals[N_SIGNALS];
static void
moo_history_mgr_class_init (MooHistoryMgrClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
g_type_class_add_private (klass, sizeof (MooHistoryMgrPrivate));
object_class->constructor = moo_history_mgr_constructor;
object_class->set_property = moo_history_mgr_set_property;
object_class->get_property = moo_history_mgr_get_property;
object_class->dispose = moo_history_mgr_dispose;
g_object_class_install_property (object_class, PROP_NAME,
g_param_spec_string ("name", "name", "name",
NULL, (GParamFlags) (G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)));
g_object_class_install_property (object_class, PROP_EMPTY,
g_param_spec_boolean ("empty", "empty", "empty",
TRUE, G_PARAM_READABLE));
signals[CHANGED] =
_moo_signal_new_cb ("changed",
MOO_TYPE_HISTORY_MGR,
G_SIGNAL_RUN_LAST,
G_CALLBACK (schedule_update_widgets),
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
}
static void
moo_history_mgr_init (MooHistoryMgr *mgr)
{
mgr->priv = G_TYPE_INSTANCE_GET_PRIVATE (mgr, MOO_TYPE_HISTORY_MGR, MooHistoryMgrPrivate);
mgr->priv->filename = NULL;
mgr->priv->basename = NULL;
mgr->priv->files = moo_history_item_queue_new ();
mgr->priv->hash = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, NULL);
mgr->priv->loaded = FALSE;
}
static GObject *
moo_history_mgr_constructor (GType type,
guint n_props,
GObjectConstructParam *props)
{
GObject *object;
MooHistoryMgr *mgr;
object = G_OBJECT_CLASS (moo_history_mgr_parent_class)->
constructor (type, n_props, props);
mgr = MOO_HISTORY_MGR (object);
if (mgr->priv->name)
{
mgr->priv->ipc_id = g_strdup_printf (IPC_ID "/%s", mgr->priv->name);
moo_ipc_register_client (G_OBJECT (mgr), mgr->priv->ipc_id, ipc_callback);
}
return object;
}
static void
moo_history_mgr_dispose (GObject *object)
{
MooHistoryMgr *mgr = MOO_HISTORY_MGR (object);
if (mgr->priv)
{
moo_history_mgr_shutdown (mgr);
if (mgr->priv->files)
{
moo_history_item_queue_foreach (mgr->priv->files, (MooHistoryItemListFunc) moo_history_item_free, NULL);
moo_history_item_queue_free_links (mgr->priv->files);
g_hash_table_destroy (mgr->priv->hash);
}
g_free (mgr->priv->name);
g_free (mgr->priv->filename);
g_free (mgr->priv->basename);
mgr->priv = NULL;
}
G_OBJECT_CLASS (moo_history_mgr_parent_class)->dispose (object);
}
void
moo_history_mgr_shutdown (MooHistoryMgr *mgr)
{
g_return_if_fail (MOO_IS_HISTORY_MGR (mgr));
if (!mgr->priv)
return;
if (mgr->priv->ipc_id)
{
moo_ipc_unregister_client (G_OBJECT (mgr), mgr->priv->ipc_id);
g_free (mgr->priv->ipc_id);
mgr->priv->ipc_id = NULL;
}
if (mgr->priv->save_idle)
{
g_source_remove (mgr->priv->save_idle);
mgr->priv->save_idle = 0;
moo_history_mgr_save (mgr);
}
if (mgr->priv->update_widgets_idle)
{
g_source_remove (mgr->priv->update_widgets_idle);
mgr->priv->update_widgets_idle = 0;
}
while (mgr->priv->widgets)
gtk_widget_destroy (mgr->priv->widgets->data);
}
static void
moo_history_mgr_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
MooHistoryMgr *mgr = MOO_HISTORY_MGR (object);
switch (prop_id)
{
case PROP_NAME:
MOO_ASSIGN_STRING (mgr->priv->name, g_value_get_string (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
moo_history_mgr_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
MooHistoryMgr *mgr = MOO_HISTORY_MGR (object);
switch (prop_id)
{
case PROP_NAME:
g_value_set_string (value, mgr->priv->name);
break;
case PROP_EMPTY:
g_value_set_boolean (value, moo_history_mgr_get_n_items (mgr) == 0);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static const char *
get_basename (MooHistoryMgr *mgr)
{
if (!mgr->priv->basename)
{
if (mgr->priv->name)
{
char *name = g_ascii_strdown (mgr->priv->name, -1);
mgr->priv->basename = g_strdup_printf ("recent-files-%s.xml", name);
g_free (name);
}
else
{
mgr->priv->basename = g_strdup ("recent-files.xml");
}
}
return mgr->priv->basename;
}
static const char *
get_filename (MooHistoryMgr *mgr)
{
if (!mgr->priv->filename)
mgr->priv->filename = moo_get_user_cache_file (get_basename (mgr));
return mgr->priv->filename;
}
char *
_moo_history_mgr_get_filename (MooHistoryMgr *mgr)
{
g_return_val_if_fail (MOO_IS_HISTORY_MGR (mgr), NULL);
return g_strdup (get_filename (mgr));
}
/*****************************************************************/
/* Loading and saving
*/
#define ELM_ROOT "md-recent-files"
#define ELM_UPDATE "md-recent-files-update"
#define ELM_ITEM "item"
#define ELM_DATA "data"
#define PROP_VERSION "version"
#define PROP_VERSION_VALUE "1.0"
#define PROP_URI "uri"
#define PROP_KEY "key"
#define PROP_VALUE "value"
#define PROP_TYPE "type"
#define ELM_RECENT_ITEMS "recent-items"
static void
add_file (MooHistoryMgr *mgr,
MooHistoryItem *item)
{
const char *uri;
uri = moo_history_item_get_uri (item);
if (g_hash_table_lookup (mgr->priv->hash, uri) != NULL)
{
g_critical ("duplicated uri '%s'", uri);
moo_history_item_free (item);
return;
}
moo_history_item_queue_push_tail (mgr->priv->files, item);
g_hash_table_insert (mgr->priv->hash, g_strdup (uri),
mgr->priv->files->tail);
}
static gboolean
parse_element (const char *filename,
MooMarkupNode *elm,
MooHistoryItem **item_p)
{
const char *uri;
MooHistoryItem *item;
MooMarkupNode *child;
if (strcmp (elm->name, ELM_ITEM) != 0)
{
g_critical ("in file '%s': invalid element '%s'",
filename ? filename : "NONE", elm->name);
return FALSE;
}
if (!(uri = moo_markup_get_prop (elm, PROP_URI)))
{
g_critical ("in file '%s': attribute '%s' missing",
filename ? filename : "NONE", PROP_URI);
return FALSE;
}
item = moo_history_item_new (uri, NULL);
g_return_val_if_fail (item != NULL, FALSE);
for (child = elm->children; child != NULL; child = child->next)
{
const char *key, *value;
if (!MOO_MARKUP_IS_ELEMENT (child))
continue;
if (strcmp (child->name, ELM_DATA) != 0)
{
g_critical ("in file '%s': invalid element '%s'",
filename ? filename : "NONE", child->name);
continue;
}
key = moo_markup_get_prop (child, PROP_KEY);
value = moo_markup_get_prop (child, PROP_VALUE);
if (!key || !key[0])
{
g_critical ("in file '%s': attribute '%s' missing",
filename ? filename : "NONE", PROP_KEY);
continue;
}
else if (!value || !value[0])
{
g_critical ("in file '%s': attribute '%s' missing",
filename ? filename : "NONE", PROP_VALUE);
continue;
}
moo_history_item_set (item, key, value);
}
*item_p = item;
return TRUE;
}
typedef enum {
ELEMENT_NONE = 0,
ELEMENT_ROOT,
ELEMENT_ITEM,
ELEMENT_DATA
} Element;
typedef struct {
gboolean seen_root;
Element element;
MooHistoryItem *item;
MooHistoryMgr *mgr;
} ParserData;
static void
start_element_root (const gchar *element_name,
const gchar **attribute_names,
const gchar **attribute_values,
ParserData *data,
GError **error)
{
gboolean seen_version = FALSE;
const char **p, **v;
if (data->seen_root)
{
g_set_error (error, MOO_HISTORY_MGR_PARSE_ERROR,
MOO_HISTORY_MGR_PARSE_ERROR_INVALID_CONTENT,
"invalid element '%s'", element_name);
return;
}
if (strcmp (element_name, ELM_ROOT) != 0)
{
g_set_error (error, MOO_HISTORY_MGR_PARSE_ERROR,
MOO_HISTORY_MGR_PARSE_ERROR_INVALID_CONTENT,
"invalid element '%s'", element_name);
return;
}
for (p = attribute_names, v = attribute_values; p && *p; p++, v++)
{
if (seen_version || strcmp (*p, PROP_VERSION) != 0)
{
g_set_error (error, MOO_HISTORY_MGR_PARSE_ERROR,
MOO_HISTORY_MGR_PARSE_ERROR_INVALID_CONTENT,
"invalid attribute '%s'", *p);
return;
}
if (strcmp (*v, PROP_VERSION_VALUE) != 0)
{
g_set_error (error, MOO_HISTORY_MGR_PARSE_ERROR,
MOO_HISTORY_MGR_PARSE_ERROR_INVALID_CONTENT,
"invalid version value '%s'", *v);
return;
}
seen_version = TRUE;
}
if (!seen_version)
{
g_set_error (error, MOO_HISTORY_MGR_PARSE_ERROR,
MOO_HISTORY_MGR_PARSE_ERROR_INVALID_CONTENT,
"version attribute missing");
return;
}
data->seen_root = TRUE;
data->element = ELEMENT_ROOT;
}
static void
start_element_item (const gchar *element_name,
const gchar **attribute_names,
const gchar **attribute_values,
ParserData *data,
GError **error)
{
MooHistoryItem *item = NULL;
const char **p, **v;
if (strcmp (element_name, ELM_ITEM) != 0)
{
g_set_error (error, MOO_HISTORY_MGR_PARSE_ERROR,
MOO_HISTORY_MGR_PARSE_ERROR_INVALID_CONTENT,
"invalid element '%s'",
element_name);
return;
}
data->element = ELEMENT_ITEM;
for (p = attribute_names, v = attribute_values; p && *p; p++, v++)
{
if (strcmp (*p, PROP_URI) != 0)
{
g_set_error (error, MOO_HISTORY_MGR_PARSE_ERROR,
MOO_HISTORY_MGR_PARSE_ERROR_INVALID_CONTENT,
"invalid attribute '%s'", *v);
return;
}
if (item != NULL)
{
g_set_error (error, MOO_HISTORY_MGR_PARSE_ERROR,
MOO_HISTORY_MGR_PARSE_ERROR_INVALID_CONTENT,
"duplicate attribute '%s'", *v);
return;
}
item = moo_history_item_new (*v, NULL);
g_return_if_fail (item != NULL);
}
if (!item)
{
g_set_error (error, MOO_HISTORY_MGR_PARSE_ERROR,
MOO_HISTORY_MGR_PARSE_ERROR_INVALID_CONTENT,
"missing attribute '%s'", PROP_URI);
return;
}
data->item = item;
}
static void
start_element_data (const gchar *element_name,
const gchar **attribute_names,
const gchar **attribute_values,
ParserData *data,
GError **error)
{
const char **p, **v;
const char *key = NULL;
const char *value = NULL;
g_return_if_fail (data->item != NULL);
if (strcmp (element_name, ELM_DATA) != 0)
{
g_set_error (error, MOO_HISTORY_MGR_PARSE_ERROR,
MOO_HISTORY_MGR_PARSE_ERROR_INVALID_CONTENT,
"invalid element '%s'",
element_name);
return;
}
data->element = ELEMENT_DATA;
for (p = attribute_names, v = attribute_values; p && *p; p++, v++)
{
if (strcmp (*p, PROP_KEY) == 0)
{
key = *v;
}
else if (strcmp (*p, PROP_VALUE) == 0)
{
value = *v;
}
else
{
g_set_error (error, MOO_HISTORY_MGR_PARSE_ERROR,
MOO_HISTORY_MGR_PARSE_ERROR_INVALID_CONTENT,
"invalid attribute '%s'", *v);
return;
}
}
if (!key || !key[0])
{
g_set_error (error, MOO_HISTORY_MGR_PARSE_ERROR,
MOO_HISTORY_MGR_PARSE_ERROR_INVALID_CONTENT,
"missing attribute '%s'", PROP_KEY);
return;
}
if (!value)
{
g_set_error (error, MOO_HISTORY_MGR_PARSE_ERROR,
MOO_HISTORY_MGR_PARSE_ERROR_INVALID_CONTENT,
"missing attribute '%s'", PROP_VALUE);
return;
}
moo_history_item_set (data->item, key, value);
}
static void
parser_start_element (G_GNUC_UNUSED GMarkupParseContext *context,
const gchar *element_name,
const gchar **attribute_names,
const gchar **attribute_values,
ParserData *data,
GError **error)
{
switch (data->element)
{
case ELEMENT_NONE:
start_element_root (element_name, attribute_names,
attribute_values, data, error);
break;
case ELEMENT_ROOT:
start_element_item (element_name, attribute_names,
attribute_values, data, error);
break;
case ELEMENT_ITEM:
start_element_data (element_name, attribute_names,
attribute_values, data, error);
break;
case ELEMENT_DATA:
g_set_error (error, MOO_HISTORY_MGR_PARSE_ERROR,
MOO_HISTORY_MGR_PARSE_ERROR_INVALID_CONTENT,
"invalid element '%s'", element_name);
break;
}
}
static void
parser_end_element (G_GNUC_UNUSED GMarkupParseContext *context,
G_GNUC_UNUSED const gchar *element_name,
ParserData *data,
G_GNUC_UNUSED GError **error)
{
switch (data->element)
{
case ELEMENT_ROOT:
data->element = ELEMENT_NONE;
break;
case ELEMENT_ITEM:
data->element = ELEMENT_ROOT;
if (data->item)
{
add_file (data->mgr, data->item);
data->item = NULL;
}
break;
case ELEMENT_DATA:
data->element = ELEMENT_ITEM;
break;
case ELEMENT_NONE:
g_assert_not_reached ();
break;
}
}
static void
load_file (MooHistoryMgr *mgr)
{
const char *filename;
GMarkupParser parser = {0};
ParserData data = {0};
GError *error = NULL;
mgr->priv->loaded = TRUE;
filename = get_filename (mgr);
g_return_if_fail (filename != NULL);
if (!g_file_test (filename, G_FILE_TEST_EXISTS))
return;
parser.start_element = (MooMarkupStartElementFunc) parser_start_element;
parser.end_element = (MooMarkupEndElementFunc) parser_end_element;
data.seen_root = FALSE;
data.element = ELEMENT_NONE;
data.item = NULL;
data.mgr = mgr;
if (!moo_parse_markup_file (filename, &parser, &data, &error))
{
g_critical ("could not load file '%s': %s",
filename, moo_error_message (error));
g_error_free (error);
}
if (data.item)
moo_history_item_free (data.item);
}
static gboolean
parse_update_item (MooMarkupDoc *xml,
MooHistoryItem **item,
UpdateType *type)
{
const char *version;
const char *update_type_string;
MooMarkupNode *root, *child;
if (!(root = moo_markup_get_root_element (xml, ELM_UPDATE)))
{
g_critical ("missing element %s", ELM_UPDATE);
return FALSE;
}
if (!(version = moo_markup_get_prop (root, PROP_VERSION)) ||
strcmp (version, PROP_VERSION_VALUE) != 0)
{
g_critical ("invalid version value '%s'",
version ? version : "(null)");
return FALSE;
}
if (!(update_type_string = moo_markup_get_prop (root, PROP_TYPE)))
{
g_critical ("attribute '%s' missing", PROP_TYPE);
return FALSE;
}
if (strcmp (update_type_string, "add") == 0)
*type = UPDATE_ITEM_ADD;
else if (strcmp (update_type_string, "remove") == 0)
*type = UPDATE_ITEM_REMOVE;
else if (strcmp (update_type_string, "update") == 0)
*type = UPDATE_ITEM_UPDATE;
else
{
g_critical ("invalid value '%s' for attribute '%s'",
update_type_string, PROP_TYPE);
return FALSE;
}
for (child = root->children; child != NULL; child = child->next)
if (MOO_MARKUP_IS_ELEMENT (child))
return parse_element (NULL, child, item);
g_critical ("element '%s' missing", ELM_ITEM);
return FALSE;
}
static void
ensure_files (MooHistoryMgr *mgr)
{
if (!mgr->priv->loaded)
load_file (mgr);
}
static gboolean
save_in_idle (MooHistoryMgr *mgr)
{
mgr->priv->save_idle = 0;
moo_history_mgr_save (mgr);
return FALSE;
}
static void
schedule_save (MooHistoryMgr *mgr)
{
if (!mgr->priv->save_idle)
mgr->priv->save_idle = g_idle_add ((GSourceFunc) save_in_idle, mgr);
}
static void
moo_history_mgr_save (MooHistoryMgr *mgr)
{
const char *filename;
GError *error = NULL;
MooFileWriter *writer;
g_return_if_fail (MOO_IS_HISTORY_MGR (mgr));
if (!mgr->priv->files)
return;
filename = get_filename (mgr);
if (!mgr->priv->files->length)
{
_moo_unlink (filename);
return;
}
if ((writer = moo_config_writer_new (filename, FALSE, &error)))
{
GString *string;
MooHistoryItemList *l;
moo_file_writer_write (writer, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n", -1);
moo_file_writer_write (writer, "<" ELM_ROOT " " PROP_VERSION "=\"" PROP_VERSION_VALUE "\">\n", -1);
string = g_string_new (NULL);
for (l = mgr->priv->files->head; l != NULL; l = l->next)
{
MooHistoryItem *item = l->data;
g_string_truncate (string, 0);
moo_history_item_format (item, string);
if (!moo_file_writer_write (writer, string->str, -1))
break;
}
g_string_free (string, TRUE);
moo_file_writer_write (writer, "</" ELM_ROOT ">\n", -1);
moo_file_writer_close (writer, &error);
}
if (error)
{
g_critical ("could not save file '%s': %s",
filename, moo_error_message (error));
g_error_free (error);
}
}
static char *
format_for_update (MooHistoryItem *item,
UpdateType type)
{
GString *buffer;
const char *update_types[3] = {"update", "remove", "add"};
g_return_val_if_fail (type < 3, NULL);
buffer = g_string_new (NULL);
g_string_append_printf (buffer, "<%s %s=\"%s\" %s=\"%s\">\n",
ELM_UPDATE, PROP_VERSION, PROP_VERSION_VALUE,
PROP_TYPE, update_types[type]);
moo_history_item_format (item, buffer);
g_string_append (buffer, "</" ELM_UPDATE ">\n");
return g_string_free (buffer, FALSE);
}
guint
moo_history_mgr_get_n_items (MooHistoryMgr *mgr)
{
g_return_val_if_fail (MOO_IS_HISTORY_MGR (mgr), 0);
ensure_files (mgr);
return mgr->priv->files->length;
}
void
moo_history_mgr_add_uri (MooHistoryMgr *mgr,
const char *uri)
{
MooHistoryItem *freeme = NULL;
MooHistoryItem *item;
g_return_if_fail (MOO_IS_HISTORY_MGR (mgr));
g_return_if_fail (uri && uri[0]);
if (!(item = moo_history_mgr_find_uri (mgr, uri)))
{
freeme = moo_history_item_new (uri, NULL);
item = freeme;
}
moo_history_mgr_add_file (mgr, item);
moo_history_item_free (freeme);
}
static void
moo_history_mgr_add_file_real (MooHistoryMgr *mgr,
MooHistoryItem *item,
gboolean notify)
{
const char *uri;
MooHistoryItemList *link;
MooHistoryItem *new_item = NULL;
g_return_if_fail (MOO_IS_HISTORY_MGR (mgr));
g_return_if_fail (item != NULL);
ensure_files (mgr);
uri = moo_history_item_get_uri (item);
link = (MooHistoryItemList*) g_hash_table_lookup (mgr->priv->hash, uri);
if (!link)
{
MooHistoryItem *copy = moo_history_item_copy (item);
moo_history_item_queue_push_head (mgr->priv->files, copy);
new_item = copy;
g_hash_table_insert (mgr->priv->hash, g_strdup (uri),
mgr->priv->files->head);
}
else if (link != mgr->priv->files->head ||
!moo_history_item_equal (item, link->data))
{
MooHistoryItem *tmp = link->data;
moo_history_item_queue_unlink (mgr->priv->files, link);
moo_history_item_queue_push_head_link (mgr->priv->files, link);
new_item = link->data = moo_history_item_copy (item);
moo_history_item_free (tmp);
}
if (new_item)
{
g_signal_emit (mgr, signals[CHANGED], 0);
if (notify)
{
schedule_save (mgr);
ipc_notify_add_file (mgr, new_item);
}
if (mgr->priv->files->length == 1)
g_object_notify (G_OBJECT (mgr), "empty");
}
if (mgr->priv->files->length > MAX_ITEM_NUMBER)
moo_history_mgr_remove_uri (mgr,
moo_history_item_get_uri (mgr->priv->files->tail->data));
}
void
moo_history_mgr_add_file (MooHistoryMgr *mgr,
MooHistoryItem *item)
{
moo_history_mgr_add_file_real (mgr, item, TRUE);
}
static void
moo_history_mgr_update_file_real (MooHistoryMgr *mgr,
MooHistoryItem *file,
gboolean notify)
{
const char *uri;
MooHistoryItemList *link;
g_return_if_fail (MOO_IS_HISTORY_MGR (mgr));
g_return_if_fail (file != NULL);
ensure_files (mgr);
uri = moo_history_item_get_uri (file);
link = (MooHistoryItemList*) g_hash_table_lookup (mgr->priv->hash, uri);
if (!link)
{
moo_history_mgr_add_file (mgr, file);
}
else if (!moo_history_item_equal (link->data, file))
{
MooHistoryItem *tmp = link->data;
link->data = moo_history_item_copy (file);
moo_history_item_free (tmp);
g_signal_emit (mgr, signals[CHANGED], 0);
if (notify)
{
schedule_save (mgr);
ipc_notify_update_file (mgr, link->data);
}
}
}
void
moo_history_mgr_update_file (MooHistoryMgr *mgr,
MooHistoryItem *file)
{
moo_history_mgr_update_file_real (mgr, file, TRUE);
}
MooHistoryItem *
moo_history_mgr_find_uri (MooHistoryMgr *mgr,
const char *uri)
{
MooHistoryItemList *link;
g_return_val_if_fail (MOO_IS_HISTORY_MGR (mgr), NULL);
g_return_val_if_fail (uri != NULL, NULL);
ensure_files (mgr);
link = (MooHistoryItemList*) g_hash_table_lookup (mgr->priv->hash, uri);
return link ? link->data : NULL;
}
static void
moo_history_mgr_remove_uri_real (MooHistoryMgr *mgr,
const char *uri,
gboolean notify)
{
MooHistoryItemList *link;
MooHistoryItem *item;
g_return_if_fail (MOO_IS_HISTORY_MGR (mgr));
g_return_if_fail (uri != NULL);
ensure_files (mgr);
link = (MooHistoryItemList*) g_hash_table_lookup (mgr->priv->hash, uri);
if (!link)
return;
item = link->data;
g_hash_table_remove (mgr->priv->hash, uri);
moo_history_item_queue_delete_link (mgr->priv->files, link);
g_signal_emit (mgr, signals[CHANGED], 0);
if (notify)
{
schedule_save (mgr);
ipc_notify_remove_file (mgr, item);
}
if (mgr->priv->files->length == 0)
g_object_notify (G_OBJECT (mgr), "empty");
moo_history_item_free (item);
}
void
moo_history_mgr_remove_uri (MooHistoryMgr *mgr,
const char *uri)
{
moo_history_mgr_remove_uri_real (mgr, uri, TRUE);
}
static void
ipc_callback (GObject *obj,
const char *data,
gsize len)
{
MooHistoryMgr *mgr;
MooMarkupDoc *xml;
GError *error = NULL;
MooHistoryItem *item;
UpdateType type;
g_return_if_fail (MOO_IS_HISTORY_MGR (obj));
mgr = MOO_HISTORY_MGR (obj);
ensure_files (mgr);
xml = moo_markup_parse_memory (data, len, &error);
if (!xml)
{
g_critical ("got invalid data: %.*s", (int) len, data);
return;
}
#if 0
g_print ("%s: got data: %.*s\n", G_STRLOC, (int) len, data);
#endif
if (parse_update_item (xml, &item, &type))
{
switch (type)
{
case UPDATE_ITEM_UPDATE:
moo_history_mgr_update_file_real (mgr, item, FALSE);
break;
case UPDATE_ITEM_ADD:
moo_history_mgr_add_file_real (mgr, item, FALSE);
break;
case UPDATE_ITEM_REMOVE:
moo_history_mgr_remove_uri_real (mgr, moo_history_item_get_uri (item), FALSE);
break;
}
moo_history_item_free (item);
}
moo_markup_doc_unref (xml);
}
static void
ipc_notify (MooHistoryMgr *mgr,
MooHistoryItem *item,
UpdateType type)
{
if (mgr->priv->ipc_id)
{
char *string = format_for_update (item, type);
moo_ipc_send (G_OBJECT (mgr), mgr->priv->ipc_id, string, -1);
g_free (string);
}
}
static void
ipc_notify_add_file (MooHistoryMgr *mgr,
MooHistoryItem *item)
{
ipc_notify (mgr, item, UPDATE_ITEM_ADD);
}
static void
ipc_notify_update_file (MooHistoryMgr *mgr,
MooHistoryItem *item)
{
ipc_notify (mgr, item, UPDATE_ITEM_UPDATE);
}
static void
ipc_notify_remove_file (MooHistoryMgr *mgr,
MooHistoryItem *item)
{
ipc_notify (mgr, item, UPDATE_ITEM_REMOVE);
}
/*****************************************************************/
/* Menu
*/
static void
callback_data_free (CallbackData *data)
{
if (data)
{
if (data->notify)
data->notify (data->data);
g_slice_free (CallbackData, data);
}
}
static void
view_destroyed (GtkWidget *widget,
MooHistoryMgr *mgr)
{
g_object_set_data (G_OBJECT (widget), "moo-history-mgr-callback-data", NULL);
mgr->priv->widgets = widget_list_remove (mgr->priv->widgets, widget);
}
static void
update_menu (MooHistoryMgr *mgr,
GtkWidget *menu)
{
WidgetList *children;
children = widget_list_from_glist (gtk_container_get_children (GTK_CONTAINER (menu)));
while (children)
{
GtkWidget *item = children->data;
if (g_object_get_data (G_OBJECT (item), "moo-history-menu-item-file"))
gtk_widget_destroy (item);
children = widget_list_delete_link (children, children);
}
populate_menu (mgr, menu);
}
GtkWidget *
moo_history_mgr_create_menu (MooHistoryMgr *mgr,
MooHistoryCallback callback,
gpointer data,
GDestroyNotify notify)
{
GtkWidget *menu;
CallbackData *cb_data;
g_return_val_if_fail (MOO_IS_HISTORY_MGR (mgr), NULL);
g_return_val_if_fail (callback != NULL, NULL);
menu = gtk_menu_new ();
gtk_widget_show (menu);
g_signal_connect (menu, "destroy", G_CALLBACK (view_destroyed), mgr);
cb_data = g_slice_new0 (CallbackData);
cb_data->callback = callback;
cb_data->data = data;
cb_data->notify = notify;
g_object_set_data_full (G_OBJECT (menu), "moo-history-mgr-callback-data",
cb_data, (GDestroyNotify) callback_data_free);
populate_menu (mgr, menu);
mgr->priv->widgets = widget_list_prepend (mgr->priv->widgets, menu);
return menu;
}
static void
menu_item_activated (GtkWidget *menu_item)
{
GtkWidget *parent = menu_item->parent;
CallbackData *data;
MooHistoryItem *item;
GSList *list;
g_return_if_fail (parent != NULL);
data = (CallbackData*) g_object_get_data (G_OBJECT (parent), "moo-history-mgr-callback-data");
item = (MooHistoryItem*) g_object_get_data (G_OBJECT (menu_item), "moo-history-menu-item-file");
g_return_if_fail (data && item);
list = g_slist_prepend (NULL, moo_history_item_copy (item));
data->callback (list, data->data);
moo_history_item_free ((MooHistoryItem*) list->data);
g_slist_free (list);
}
static void
populate_menu (MooHistoryMgr *mgr,
GtkWidget *menu)
{
guint n_items, i;
MooHistoryItemList *l;
ensure_files (mgr);
n_items = MIN (mgr->priv->files->length, N_MENU_ITEMS);
for (i = 0, l = mgr->priv->files->head; i < n_items; i++, l = l->next)
{
GtkWidget *item, *image;
MooHistoryItem *hist_item = l->data;
char *display_name, *display_basename;
GdkPixbuf *pixbuf;
display_basename = uri_get_basename (hist_item->uri);
display_name = uri_get_display_name (hist_item->uri);
item = gtk_image_menu_item_new_with_label (display_basename);
_moo_widget_set_tooltip (item, display_name);
gtk_widget_show (item);
gtk_menu_shell_insert (GTK_MENU_SHELL (menu), item, i);
/* XXX */
pixbuf = moo_file_icon_get_pixbuf (moo_history_item_get_icon (hist_item),
GTK_WIDGET (item),
GTK_ICON_SIZE_MENU);
image = gtk_image_new_from_pixbuf (pixbuf);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
g_object_set_data_full (G_OBJECT (item), "moo-history-menu-item-file",
moo_history_item_copy (hist_item),
(GDestroyNotify) moo_history_item_free);
g_signal_connect (item, "activate", G_CALLBACK (menu_item_activated), NULL);
g_free (display_basename);
g_free (display_name);
}
}
enum {
COLUMN_PIXBUF,
COLUMN_NAME,
COLUMN_TOOLTIP,
COLUMN_URI,
N_COLUMNS
};
static void
open_selected (GtkTreeView *tree_view)
{
CallbackData *data;
GtkTreeIter iter;
GtkTreeModel *model;
GtkTreeSelection *selection;
MooHistoryMgr *mgr;
GList *selected;
GSList *items;
mgr = (MooHistoryMgr*) g_object_get_data (G_OBJECT (tree_view), "moo-history-mgr");
g_return_if_fail (MOO_IS_HISTORY_MGR (mgr));
data = (CallbackData*) g_object_get_data (G_OBJECT (tree_view), "moo-history-mgr-callback-data");
g_return_if_fail (data != NULL);
selection = gtk_tree_view_get_selection (tree_view);
selected = gtk_tree_selection_get_selected_rows (selection, &model);
for (items = NULL; selected != NULL; )
{
char *uri = NULL;
MooHistoryItem *item;
GtkTreePath *path = (GtkTreePath*) selected->data;
gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_model_get (model, &iter, COLUMN_URI, &uri, -1);
item = moo_history_mgr_find_uri (mgr, uri);
if (item)
items = g_slist_prepend (items, moo_history_item_copy (item));
g_free (uri);
gtk_tree_path_free (path);
selected = g_list_delete_link (selected, selected);
}
items = g_slist_reverse (items);
if (items)
data->callback (items, data->data);
g_slist_foreach (items, (GFunc) moo_history_item_free, NULL);
g_slist_free (items);
}
static GtkWidget *
create_tree_view (void)
{
GtkWidget *tree_view;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
GtkListStore *store;
tree_view = gtk_tree_view_new ();
store = gtk_list_store_new (N_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING);
gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view), GTK_TREE_MODEL (store));
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE);
gtk_tree_view_set_tooltip_column (GTK_TREE_VIEW (tree_view),
COLUMN_TOOLTIP);
gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
GTK_SELECTION_MULTIPLE);
column = gtk_tree_view_column_new ();
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
cell = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_tree_view_column_set_attributes (column, cell, "pixbuf", COLUMN_PIXBUF, NULL);
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_set_attributes (column, cell, "text", COLUMN_NAME, NULL);
return tree_view;
}
#define FIRST_CHUNK_SIZE 100
#define CHUNK_SIZE 100
#define LOADING_TIMEOUT 40
#define LOADING_PRIORITY G_PRIORITY_DEFAULT_IDLE
typedef struct {
MooHistoryItemList *items;
guint idle;
GtkWidget *tree_view;
GtkListStore *store;
} IdleLoader;
static void
cancel_idle_loading (GtkWidget *tree_view)
{
g_object_set_data (G_OBJECT (tree_view),
"moo-history-mgr-idle-loader",
NULL);
}
static void
idle_loader_free (IdleLoader *data)
{
if (data->idle)
g_source_remove (data->idle);
moo_history_item_list_foreach (data->items, (MooHistoryItemListFunc) moo_history_item_free, NULL);
moo_history_item_list_free_links (data->items);
g_free (data);
}
static void
add_entry (MooHistoryItem *item,
GtkListStore *store,
GtkWidget *tree_view)
{
char *display_name, *display_basename;
GdkPixbuf *pixbuf;
GtkTreeIter iter;
display_basename = uri_get_basename (item->uri);
display_name = uri_get_display_name (item->uri);
pixbuf = moo_file_icon_get_pixbuf (moo_history_item_get_icon (item),
tree_view, GTK_ICON_SIZE_MENU);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
COLUMN_PIXBUF, pixbuf,
COLUMN_NAME, display_basename,
COLUMN_TOOLTIP, display_name,
COLUMN_URI, moo_history_item_get_uri (item),
-1);
g_free (display_basename);
g_free (display_name);
}
static gboolean
idle_loader (IdleLoader *data)
{
int count;
for (count = 0; data->items != NULL && count < CHUNK_SIZE; count++)
{
add_entry (data->items->data, data->store, data->tree_view);
moo_history_item_free (data->items->data);
data->items = moo_history_item_list_delete_link (data->items, data->items);
}
if (!data->items)
{
data->idle = 0;
g_object_set_data (G_OBJECT (data->tree_view),
"moo-history-mgr-idle-loader",
NULL);
return FALSE;
}
else
{
return TRUE;
}
}
static void
populate_tree_view (MooHistoryMgr *mgr,
GtkWidget *tree_view)
{
GtkListStore *store;
GtkTreeModel *model;
MooHistoryItemList *l;
int count;
ensure_files (mgr);
cancel_idle_loading (tree_view);
model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree_view));
store = GTK_LIST_STORE (model);
for (l = mgr->priv->files->head, count = 0;
l != NULL && count < FIRST_CHUNK_SIZE;
l = l->next, count++)
{
add_entry (l->data, store, tree_view);
}
if (l != NULL)
{
IdleLoader *data = g_new0 (IdleLoader, 1);
while (l != NULL)
{
data->items = moo_history_item_list_prepend (data->items, moo_history_item_copy (l->data));
l = l->next;
}
data->items = moo_history_item_list_reverse (data->items);
data->idle = g_timeout_add_full (LOADING_PRIORITY,
LOADING_TIMEOUT,
(GSourceFunc) idle_loader,
data, NULL);
data->tree_view = tree_view;
data->store = store;
g_object_set_data_full (G_OBJECT (tree_view),
"moo-history-mgr-idle-loader", data,
(GDestroyNotify) idle_loader_free);
}
}
static void
update_tree_view (MooHistoryMgr *mgr,
GtkWidget *tree_view)
{
GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree_view));
gtk_list_store_clear (GTK_LIST_STORE (model));
populate_tree_view (mgr, tree_view);
}
static GtkWidget *
moo_history_mgr_create_tree_view (MooHistoryMgr *mgr,
MooHistoryCallback callback,
gpointer data,
GDestroyNotify notify)
{
GtkWidget *tree_view;
CallbackData *cb_data;
g_return_val_if_fail (MOO_IS_HISTORY_MGR (mgr), NULL);
g_return_val_if_fail (callback != NULL, NULL);
tree_view = create_tree_view ();
gtk_widget_show (tree_view);
g_signal_connect (tree_view, "destroy", G_CALLBACK (view_destroyed), mgr);
cb_data = g_slice_new0 (CallbackData);
cb_data->callback = callback;
cb_data->data = data;
cb_data->notify = notify;
g_object_set_data_full (G_OBJECT (tree_view), "moo-history-mgr-callback-data",
cb_data, (GDestroyNotify) callback_data_free);
g_object_set_data (G_OBJECT (tree_view), "moo-history-mgr", mgr);
populate_tree_view (mgr, tree_view);
if (mgr->priv->files->head)
_moo_tree_view_select_first (GTK_TREE_VIEW (tree_view));
mgr->priv->widgets = widget_list_prepend (mgr->priv->widgets, tree_view);
return tree_view;
}
static void
dialog_response (GtkTreeView *tree_view,
int response)
{
if (response == GTK_RESPONSE_OK)
open_selected (tree_view);
}
static void
row_activated (GtkDialog *dialog)
{
gtk_dialog_response (dialog, GTK_RESPONSE_OK);
}
GtkWidget *
moo_history_mgr_create_dialog (MooHistoryMgr *mgr,
MooHistoryCallback callback,
gpointer data,
GDestroyNotify notify)
{
GtkWidget *dialog, *swin, *tree_view;
g_return_val_if_fail (MOO_IS_HISTORY_MGR (mgr), NULL);
g_return_val_if_fail (callback != NULL, NULL);
dialog = gtk_dialog_new_with_buttons ("", NULL, GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
swin = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swin),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
tree_view = moo_history_mgr_create_tree_view (mgr, callback, data, notify);
gtk_container_add (GTK_CONTAINER (swin), tree_view);
gtk_widget_show_all (swin);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), swin, TRUE, TRUE, 0);
g_signal_connect_swapped (tree_view, "row-activated",
G_CALLBACK (row_activated), dialog);
g_signal_connect_swapped (dialog, "response",
G_CALLBACK (dialog_response), tree_view);
return dialog;
}
static gboolean
do_update_widgets (MooHistoryMgr *mgr)
{
WidgetList *l;
mgr->priv->update_widgets_idle = 0;
for (l = mgr->priv->widgets; l != NULL; l = l->next)
{
GtkWidget *widget = l->data;
if (GTK_IS_MENU (widget))
update_menu (mgr, widget);
else if (GTK_IS_TREE_VIEW (widget))
update_tree_view (mgr, widget);
else
g_critical ("%s: oops", G_STRFUNC);
}
return FALSE;
}
static void
schedule_update_widgets (MooHistoryMgr *mgr)
{
if (!mgr->priv->update_widgets_idle && mgr->priv->widgets)
mgr->priv->update_widgets_idle =
g_idle_add ((GSourceFunc) do_update_widgets, mgr);
}
void
moo_history_item_free (MooHistoryItem *item)
{
if (item)
{
g_free (item->uri);
g_datalist_clear (&item->data);
moo_file_icon_free (item->icon);
g_slice_free (MooHistoryItem, item);
}
}
static MooHistoryItem *
moo_history_item_new_uri (const char *uri)
{
MooHistoryItem *item = g_slice_new (MooHistoryItem);
item->uri = g_strdup (uri);
item->data = NULL;
item->icon = NULL;
return item;
}
static MooHistoryItem *
moo_history_item_newv (const char *uri,
const char *first_key,
va_list args)
{
const char *key;
MooHistoryItem *item;
item = moo_history_item_new_uri (uri);
for (key = first_key; key != NULL; )
{
const char *value = va_arg (args, const char *);
moo_history_item_set (item, key, value);
key = va_arg (args, const char *);
}
return item;
}
MooHistoryItem *
moo_history_item_new (const char *uri,
const char *first_key,
...)
{
va_list args;
MooHistoryItem *item;
g_return_val_if_fail (uri != NULL, NULL);
va_start (args, first_key);
item = moo_history_item_newv (uri, first_key, args);
va_end (args);
return item;
}
static void
copy_data (GQuark key,
const char *value,
MooHistoryItem *dest)
{
g_datalist_id_set_data_full (&dest->data, key, g_strdup (value), g_free);
}
MooHistoryItem *
moo_history_item_copy (MooHistoryItem *item)
{
MooHistoryItem *copy;
if (!item)
return NULL;
copy = moo_history_item_new_uri (item->uri);
g_datalist_foreach (&item->data, (GDataForeachFunc) copy_data, copy);
copy->icon = moo_file_icon_copy (item->icon);
return copy;
}
typedef struct {
MooHistoryItem *item;
gboolean equal;
} CmpData;
static void
cmp_data (GQuark key,
const char *value,
CmpData *data)
{
const char *value2;
if (!data->equal)
return;
value2 = (const char*) g_datalist_id_get_data (&data->item->data, key);
if (!value2 || strcmp (value2, value) != 0)
data->equal = FALSE;
}
static gboolean
moo_history_item_equal (MooHistoryItem *item1,
MooHistoryItem *item2)
{
CmpData data;
g_return_val_if_fail (item1 && item2, FALSE);
if (item1 == item2)
return TRUE;
if (strcmp (item1->uri, item2->uri) != 0)
return FALSE;
data.equal = TRUE;
data.item = item1;
g_datalist_foreach (&item2->data, (GDataForeachFunc) cmp_data, &data);
if (data.equal)
{
data.item = item2;
g_datalist_foreach (&item1->data, (GDataForeachFunc) cmp_data, &data);
}
return data.equal;
}
void
moo_history_item_set (MooHistoryItem *item,
const char *key,
const char *value)
{
g_return_if_fail (item != NULL);
g_return_if_fail (key != NULL);
if (value)
g_datalist_set_data_full (&item->data, key, g_strdup (value), g_free);
else
g_datalist_remove_data (&item->data, key);
}
const char *
moo_history_item_get (MooHistoryItem *item,
const char *key)
{
g_return_val_if_fail (item != NULL, NULL);
g_return_val_if_fail (key != NULL, NULL);
return (const char*) g_datalist_get_data (&item->data, key);
}
const char *
moo_history_item_get_uri (MooHistoryItem *item)
{
g_return_val_if_fail (item != NULL, NULL);
return item->uri;
}
static MooFileIcon *
moo_history_item_get_icon (MooHistoryItem *item)
{
g_return_val_if_fail (item != NULL, NULL);
if (!item->icon)
{
char *display_name;
item->icon = moo_file_icon_new ();
display_name = uri_get_display_name (item->uri);
/* XXX */
moo_file_icon_for_file (item->icon, display_name);
g_free (display_name);
}
return item->icon;
}
static void
format_data (GQuark key_id,
const char *value,
GString *dest)
{
const char *key = g_quark_to_string (key_id);
char *key_escaped = g_markup_escape_text (key, -1);
char *value_escaped = g_markup_escape_text (value, -1);
g_string_append_printf (dest, " <data key=\"%s\" value=\"%s\"/>\n",
key_escaped, value_escaped);
g_free (value_escaped);
g_free (key_escaped);
}
static void
moo_history_item_format (MooHistoryItem *item,
GString *dest)
{
char *uri_escaped;
g_return_if_fail (item != NULL);
g_return_if_fail (dest != NULL);
uri_escaped = g_markup_escape_text (item->uri, -1);
if (item->data)
{
g_string_append_printf (dest, " <item uri=\"%s\">\n", uri_escaped);
g_datalist_foreach (&item->data, (GDataForeachFunc) format_data, dest);
g_string_append (dest, " </item>\n");
}
else
{
g_string_append_printf (dest, " <item uri=\"%s\"/>\n", uri_escaped);
}
g_free (uri_escaped);
}
void
moo_history_item_foreach (MooHistoryItem *item,
GDataForeachFunc func,
gpointer user_data)
{
g_return_if_fail (item != NULL);
g_return_if_fail (func != NULL);
g_datalist_foreach (&item->data, func, user_data);
}
static char *
uri_get_basename (const char *uri)
{
const char *last_slash;
g_return_val_if_fail (uri != NULL, NULL);
if (g_str_has_prefix (uri, "file://"))
{
char *filename = g_filename_from_uri (uri, NULL, NULL);
if (filename)
{
char *display_name = g_filename_display_basename (filename);
if (display_name)
{
g_free (filename);
return display_name;
}
g_free (filename);
}
}
/* XXX percent encoding */
last_slash = strrchr (uri, '/');
if (last_slash)
return g_strdup (last_slash + 1);
else
return g_strdup (uri);
}
static char *
uri_get_display_name (const char *uri)
{
g_return_val_if_fail (uri != NULL, NULL);
if (g_str_has_prefix (uri, "file://"))
{
char *filename = g_filename_from_uri (uri, NULL, NULL);
if (filename)
{
char *display_name = g_filename_display_name (filename);
if (display_name)
{
g_free (filename);
return display_name;
}
g_free (filename);
}
}
return g_strdup (uri);
}
Reference in New Issue View Git Blame Copy Permalink