luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2025-11-05 18:48:55 +01:00
Code Issues Packages Projects Releases Wiki Activity

some GSettings stuff

Browse Source
This commit is contained in:
Ryan Lortie
2010-04-10 21:57:55 -04:00
parent a3dc7f8006
commit e06ca1fae6
8 changed files with 984 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
gio/Makefile.am
View File

@@ -250,6 +250,11 @@ libgio_2_0_la_SOURCES = \
gpollfilemonitor.h \ gpollfilemonitor.h \
gresolver.c \ gresolver.c \
gseekable.c \ gseekable.c \
gsettings.c \
gsettingsschema.c \
gdelayedsettingsbackend.c\
gsettingsbackend.c \
gmemorysettingsbackend.c\
gsimpleasyncresult.c \ gsimpleasyncresult.c \
gsocket.c \ gsocket.c \
gsocketaddress.c \ gsocketaddress.c \

329
gio/gdelayedsettingsbackend.c Normal file
View File

@@ -0,0 +1,329 @@
/*
* Copyright © 2009 Codethink Limited
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of version 3 of the GNU General Public License as
* published by the Free Software Foundation.
*
* See the included COPYING file for more information.
*/
#include "gdelayedsettingsbackend.h"
#include <string.h>
#include "gioalias.h"
enum
{
PROP_NONE,
PROP_BACKEND,
PROP_BASE_PATH,
PROP_HAS_UNAPPLIED
};
struct _GDelayedSettingsBackendPrivate {
GSettingsBackend *backend;
guint handler_id;
gchar *base_path;
GTree *delayed;
};
G_DEFINE_TYPE (GDelayedSettingsBackend,
g_delayed_settings_backend,
G_TYPE_SETTINGS_BACKEND)
static gboolean
g_delayed_settings_backend_add_to_tree (gpointer key,
gpointer value,
gpointer user_data)
{
gpointer *args = user_data;
g_tree_insert (args[0],
g_strjoin (NULL, args[1], key, NULL),
g_variant_ref (value));
return FALSE;
}
static void
g_delayed_settings_backend_write (GSettingsBackend *backend,
const gchar *prefix,
GTree *tree,
gpointer origin_tag)
{
GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (backend);
gconstpointer args[2] = { delayed->priv->delayed, prefix };
gboolean was_empty;
was_empty = g_tree_nnodes (delayed->priv->delayed) == 0;
g_tree_foreach (tree, g_delayed_settings_backend_add_to_tree, args);
g_settings_backend_changed_tree (backend, prefix, tree, origin_tag);
if (was_empty)
g_object_notify (G_OBJECT (delayed), "has-unapplied");
}
static GVariant *
g_delayed_settings_backend_read (GSettingsBackend *backend,
const gchar *key,
const GVariantType *expected_type)
{
GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (backend);
GVariant *result = NULL;
gchar *path;
if ((result = g_tree_lookup (delayed->priv->delayed, key)))
return g_variant_ref (result);
path = g_strconcat (delayed->priv->base_path, key, NULL);
result = g_settings_backend_read (delayed->priv->backend,
path, expected_type);
g_free (path);
return result;
}
gboolean
g_delayed_settings_backend_get_has_unapplied (GDelayedSettingsBackend *delayed)
{
return g_tree_nnodes (delayed->priv->delayed) > 0;
}
void
g_delayed_settings_backend_apply (GDelayedSettingsBackend *delayed)
{
if (g_tree_nnodes (delayed->priv->delayed))
{
GTree *tmp;
tmp = delayed->priv->delayed;
delayed->priv->delayed = g_settings_backend_create_tree ();
g_settings_backend_write (delayed->priv->backend,
delayed->priv->base_path,
tmp, delayed->priv);
g_tree_unref (tmp);
g_object_notify (G_OBJECT (delayed), "has-unapplied");
}
}
void
g_delayed_settings_backend_revert (GDelayedSettingsBackend *delayed)
{
if (g_tree_nnodes (delayed->priv->delayed))
{
GTree *tmp;
tmp = delayed->priv->delayed;
delayed->priv->delayed = g_settings_backend_create_tree ();
g_settings_backend_changed_tree (G_SETTINGS_BACKEND (delayed),
"", tmp, NULL);
g_tree_destroy (tmp);
g_object_notify (G_OBJECT (delayed), "has-unapplied");
}
}
static gboolean
g_delayed_settings_backend_get_writable (GSettingsBackend *backend,
const gchar *name)
{
GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (backend);
gboolean sensitive;
gchar *path;
path = g_strconcat (delayed->priv->base_path, name, NULL);
sensitive = g_settings_backend_get_writable (delayed->priv->backend, path);
g_free (path);
return sensitive;
}
static void
g_delayed_settings_backend_subscribe (GSettingsBackend *base,
const char *name)
{
}
static void
g_delayed_settings_backend_get_property (GObject *object, guint prop_id,
GValue *value, GParamSpec *pspec)
{
GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (object);
switch (prop_id)
{
gboolean has;
case PROP_HAS_UNAPPLIED:
has = g_delayed_settings_backend_get_has_unapplied (delayed);
g_value_set_boolean (value, has);
break;
default:
g_assert_not_reached ();
}
}
static void
g_delayed_settings_backend_set_property (GObject *object, guint prop_id,
const GValue *value, GParamSpec *pspec)
{
GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (object);
switch (prop_id)
{
case PROP_BACKEND:
g_assert (delayed->priv->backend == NULL);
delayed->priv->backend = g_value_dup_object (value);
break;
case PROP_BASE_PATH:
g_assert (delayed->priv->base_path == NULL);
delayed->priv->base_path = g_value_dup_string (value);
break;
default:
g_assert_not_reached ();
}
}
static void
g_delayed_settings_backend_backend_changed (GSettingsBackend *backend,
const gchar *prefix,
const gchar * const *items,
gint n_items,
gpointer origin_tag,
gpointer user_data)
{
GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (user_data);
if (origin_tag == delayed->priv)
return;
if (g_str_has_prefix (prefix, delayed->priv->base_path))
{
g_settings_backend_changed (G_SETTINGS_BACKEND (delayed),
prefix + strlen (delayed->priv->base_path),
items, n_items, origin_tag);
}
else if (g_str_has_prefix (delayed->priv->base_path, prefix))
{
const gchar **my_items;
const gchar *relative;
gint relative_length;
gint i, j;
relative = delayed->priv->base_path + strlen (prefix);
relative_length = strlen (relative);
my_items = g_new (const gchar *, n_items + 1);
for (i = j = 0; i < n_items; i++)
if (g_str_has_prefix (items[i], relative))
my_items[j++] = items[i] + relative_length;
my_items[j] = NULL;
if (j > 0)
g_settings_backend_changed (G_SETTINGS_BACKEND (delayed),
"", my_items, j, origin_tag);
g_free (my_items);
}
else
/* do nothing */;
}
static void
g_delayed_settings_backend_constructed (GObject *object)
{
GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (object);
g_assert (delayed->priv->backend != NULL);
g_assert (delayed->priv->base_path != NULL);
delayed->priv->handler_id =
g_signal_connect (delayed->priv->backend, "changed",
G_CALLBACK (g_delayed_settings_backend_backend_changed),
delayed);
g_settings_backend_subscribe (delayed->priv->backend,
delayed->priv->base_path);
}
static void
g_delayed_settings_backend_finalize (GObject *object)
{
GDelayedSettingsBackend *delayed = G_DELAYED_SETTINGS_BACKEND (object);
g_signal_handler_disconnect (delayed->priv->backend,
delayed->priv->handler_id);
g_settings_backend_unsubscribe (delayed->priv->backend,
delayed->priv->base_path);
g_object_unref (delayed->priv->backend);
g_free (delayed->priv->base_path);
}
static void
g_delayed_settings_backend_class_init (GDelayedSettingsBackendClass *class)
{
GSettingsBackendClass *backend_class = G_SETTINGS_BACKEND_CLASS (class);
GObjectClass *object_class = G_OBJECT_CLASS (class);
g_type_class_add_private (class, sizeof (GDelayedSettingsBackendPrivate));
backend_class->write = g_delayed_settings_backend_write;
backend_class->read = g_delayed_settings_backend_read;
backend_class->get_writable = g_delayed_settings_backend_get_writable;
backend_class->subscribe = g_delayed_settings_backend_subscribe;
backend_class->unsubscribe = g_delayed_settings_backend_subscribe;
object_class->get_property = g_delayed_settings_backend_get_property;
object_class->set_property = g_delayed_settings_backend_set_property;
object_class->constructed = g_delayed_settings_backend_constructed;
object_class->finalize = g_delayed_settings_backend_finalize;
g_object_class_install_property (object_class, PROP_BACKEND,
g_param_spec_object ("backend", "backend backend", "backend",
G_TYPE_SETTINGS_BACKEND, G_PARAM_CONSTRUCT_ONLY |
G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (object_class, PROP_BASE_PATH,
g_param_spec_string ("base-path", "base path", "base",
"", G_PARAM_CONSTRUCT_ONLY |
G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (object_class, PROP_HAS_UNAPPLIED,
g_param_spec_boolean ("has-unapplied", "has unapplied", "unapplied",
FALSE, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
}
static void
g_delayed_settings_backend_init (GDelayedSettingsBackend *delayed)
{
delayed->priv =
G_TYPE_INSTANCE_GET_PRIVATE (delayed, G_TYPE_DELAYED_SETTINGS_BACKEND,
GDelayedSettingsBackendPrivate);
delayed->priv->delayed = g_settings_backend_create_tree ();
}
GSettingsBackend *
g_delayed_settings_backend_new (GSettingsBackend *backend,
const gchar *base_path)
{
return g_object_new (G_TYPE_DELAYED_SETTINGS_BACKEND,
"backend", backend,
"base-path", base_path,
NULL);
}
#define _gsettingsdelayedbackend_c_
#include "gioaliasdef.c"

59
gio/gdelayedsettingsbackend.h Normal file
View File

@@ -0,0 +1,59 @@
/*
* Copyright © 2009 Codethink Limited
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of version 3 of the GNU General Public License as
* published by the Free Software Foundation.
*
* See the included COPYING file for more information.
*/
#ifndef _gsettingsdelayedbackend_h_
#define _gsettingsdelayedbackend_h_
#include <glib-object.h>
#include <gio/gsettingsbackend.h>
#define G_TYPE_DELAYED_SETTINGS_BACKEND (g_delayed_settings_backend_get_type ())
#define G_DELAYED_SETTINGS_BACKEND(inst) (G_TYPE_CHECK_INSTANCE_CAST ((inst), \
G_TYPE_DELAYED_SETTINGS_BACKEND, \
GDelayedSettingsBackend))
#define G_DELAYED_SETTINGS_BACKEND_CLASS(class) (G_TYPE_CHECK_CLASS_CAST ((class), \
G_TYPE_DELAYED_SETTINGS_BACKEND, \
GDelayedSettingsBackendClass))
#define G_IS_DELAYED_SETTINGS_BACKEND(inst) (G_TYPE_CHECK_INSTANCE_TYPE ((inst), \
G_TYPE_DELAYED_SETTINGS_BACKEND))
#define G_IS_DELAYED_SETTINGS_BACKEND_CLASS(class) (G_TYPE_CHECK_CLASS_TYPE ((class), \
G_TYPE_DELAYED_SETTINGS_BACKEND))
#define G_DELAYED_SETTINGS_BACKEND_GET_CLASS(inst) (G_TYPE_INSTANCE_GET_CLASS ((inst), \
G_TYPE_DELAYED_SETTINGS_BACKEND, \
GDelayedSettingsBackendClass))
typedef struct _GDelayedSettingsBackendPrivate GDelayedSettingsBackendPrivate;
typedef struct _GDelayedSettingsBackendClass GDelayedSettingsBackendClass;
typedef struct _GDelayedSettingsBackend GDelayedSettingsBackend;
struct _GDelayedSettingsBackendClass
{
GSettingsBackendClass parent_class;
};
struct _GDelayedSettingsBackend
{
GSettingsBackend parent_instance;
GDelayedSettingsBackendPrivate *priv;
};
G_BEGIN_DECLS
GType g_delayed_settings_backend_get_type (void);
GSettingsBackend * g_delayed_settings_backend_new (GSettingsBackend *backend,
const gchar *base_path);
void g_delayed_settings_backend_revert (GDelayedSettingsBackend *delayed);
void g_delayed_settings_backend_apply (GDelayedSettingsBackend *delayed);
gboolean g_delayed_settings_backend_get_has_unapplied (GDelayedSettingsBackend *delayed);
G_END_DECLS
#endif /* _gsettingsdelayedbackend_h_ */

2
gio/gio-marshal.list
View File

@@ -4,3 +4,5 @@ VOID:BOOLEAN,POINTER
VOID:OBJECT,OBJECT,ENUM VOID:OBJECT,OBJECT,ENUM
BOOLEAN:OBJECT,OBJECT BOOLEAN:OBJECT,OBJECT
VOID:STRING,BOXED,BOXED VOID:STRING,BOXED,BOXED
VOID:STRING,BOXED,INT,POINTER
VOID:POINTER,INT

98
gio/gmemorysettingsbackend.c Normal file
View File

@@ -0,0 +1,98 @@
#include "gmemorysettingsbackend.h"
G_DEFINE_TYPE_WITH_CODE (GMemorySettingsBackend,
g_memory_settings_backend,
G_TYPE_SETTINGS_BACKEND,
g_io_extension_point_implement (G_SETTINGS_BACKEND_EXTENSION_POINT_NAME,
g_define_type_id, "memory", 0))
struct _GMemorySettingsBackendPrivate
{
GHashTable *table;
};
static GVariant *
g_memory_settings_backend_read (GSettingsBackend *backend,
const gchar *key,
const GVariantType *expected_type)
{
GVariant *value;
GMemorySettingsBackend *memory = G_MEMORY_SETTINGS_BACKEND (backend);
value = g_hash_table_lookup (memory->priv->table, key);
if (value != NULL)
g_variant_ref (value);
return value;
}
static gboolean
g_memory_settings_backend_write_one (gpointer key,
gpointer value,
gpointer data)
{
GMemorySettingsBackend *memory = ((gpointer *) data)[0];
const gchar *prefix = ((gpointer *) data)[1];
g_hash_table_insert (memory->priv->table,
g_strjoin ("", prefix, key, NULL),
g_variant_ref (value));
return FALSE;
}
static void
g_memory_settings_backend_write (GSettingsBackend *backend,
const gchar *prefix,
GTree *tree,
gpointer origin_tag)
{
gpointer write_info[] = { backend, (gpointer) prefix };
g_tree_foreach (tree, g_memory_settings_backend_write_one, write_info);
g_settings_backend_changed_tree (backend, prefix, tree, origin_tag);
}
static gboolean
g_memory_settings_backend_get_writable (GSettingsBackend *backend,
const gchar *name)
{
return TRUE;
}
static void
g_memory_settings_backend_finalize (GObject *object)
{
GMemorySettingsBackend *memory = G_MEMORY_SETTINGS_BACKEND (object);
g_hash_table_unref (memory->priv->table);
G_OBJECT_CLASS (g_memory_settings_backend_parent_class)
->finalize (object);
}
static void
g_memory_settings_backend_init (GMemorySettingsBackend *memory)
{
memory->priv = G_TYPE_INSTANCE_GET_PRIVATE (memory,
G_TYPE_MEMORY_SETTINGS_BACKEND,
GMemorySettingsBackendPrivate);
memory->priv->table =
g_hash_table_new_full (g_str_hash, g_str_equal, g_free,
(GDestroyNotify) g_variant_unref);
}
static void
g_memory_settings_backend_class_init (GMemorySettingsBackendClass *class)
{
GSettingsBackendClass *backend_class = G_SETTINGS_BACKEND_CLASS (class);
GObjectClass *object_class = G_OBJECT_CLASS (class);
backend_class->read = g_memory_settings_backend_read;
backend_class->write = g_memory_settings_backend_write;
backend_class->get_writable = g_memory_settings_backend_get_writable;
object_class->finalize = g_memory_settings_backend_finalize;
g_type_class_add_private (class, sizeof (GMemorySettingsBackendPrivate));
}

51
gio/gmemorysettingsbackend.h Normal file
View File

@@ -0,0 +1,51 @@
#ifndef _gmemorysettingsbackend_h_
#define _gmemorysettingsbackend_h_
#include <gio/gsettingsbackend.h>
G_BEGIN_DECLS
#define G_TYPE_MEMORY_SETTINGS_BACKEND (g_memory_settings_backend_get_type ())
#define G_MEMORY_SETTINGS_BACKEND(inst) (G_TYPE_CHECK_INSTANCE_CAST ((inst), \
G_TYPE_MEMORY_SETTINGS_BACKEND, \
GMemorySettingsBackend))
#define G_MEMORY_SETTINGS_BACKEND_CLASS(class) (G_TYPE_CHECK_CLASS_CAST ((class), \
G_TYPE_MEMORY_SETTINGS_BACKEND, \
GMemorySettingsBackendClass))
#define G_IS_MEMORY_SETTINGS_BACKEND(inst) (G_TYPE_CHECK_INSTANCE_TYPE ((inst), \
G_TYPE_MEMORY_SETTINGS_BACKEND))
#define G_IS_MEMORY_SETTINGS_BACKEND_CLASS(class) (G_TYPE_CHECK_CLASS_TYPE ((class), \
G_TYPE_MEMORY_SETTINGS_BACKEND))
#define G_MEMORY_SETTINGS_BACKEND_GET_CLASS(inst) (G_TYPE_INSTANCE_GET_CLASS ((inst), \
G_TYPE_MEMORY_SETTINGS_BACKEND, \
GMemorySettingsBackendClass))
#define G_MEMORY_SETTINGS_BACKEND_EXTENSION_POINT_NAME "gsettings-backend"
/**
* GMemorySettingsBackend:
*
* A backend to GSettings that stores the settings in memory.
**/
typedef struct _GMemorySettingsBackendPrivate GMemorySettingsBackendPrivate;
typedef struct _GMemorySettingsBackendClass GMemorySettingsBackendClass;
typedef struct _GMemorySettingsBackend GMemorySettingsBackend;
struct _GMemorySettingsBackendClass
{
GSettingsBackendClass parent_class;
};
struct _GMemorySettingsBackend
{
GSettingsBackend parent_instance;
/*< private >*/
GMemorySettingsBackendPrivate *priv;
};
GType g_memory_settings_backend_get_type (void);
G_END_DECLS
#endif /* _gmemorysettingsbackend_h_ */

332
gio/gsettingsbackend.c Normal file
View File

@@ -0,0 +1,332 @@
/*
* Copyright © 2009 Codethink Limited
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of version 3 of the GNU General Public License as
* published by the Free Software Foundation.
*
* See the included COPYING file for more information.
*/
#include "gsettingsbackend.h"
#include "giomodule-priv.h"
#include "gio-marshal.h"
#include <string.h>
#include <stdlib.h>
#include <glib.h>
#include "gioalias.h"
G_DEFINE_ABSTRACT_TYPE (GSettingsBackend, g_settings_backend, G_TYPE_OBJECT)
static guint changed_signal;
/**
* SECTION:gsettingsbackend
* @short_description: an interface for settings backend implementations
*
* The #GSettingsBackend inteface defines a generic interface for
* non-strictly-typed data backend in a hierarchy.
*
* The interface defines methods for reading and writing values, a
* method for determining if writing of certain values will fail
* (lockdown) and a change notification signal.
*
* The semantics of the interface are very precisely defined and
* implementations must carefully adhere to the expectations of
* callers that are documented on each of the interface methods.
**/
/**
* g_settings_backend_changed:
* @backend: a #GSettingsBackend implementation
* @prefix: the longest common prefix
* @items: the NULL-terminated list of changed keys
* @n_items: the number of items in @items
* @origin_tag: the origin tag
*
* Emits the changed signal on @backend. This function should only be
* called by the implementation itself, to indicate that a change has
* occurred.
*
* The list of changed keys, relative to the root of the settings store,
* is @prefix prepended to each of the @items. It must either be the
* case that @prefix is equal to "" or ends in "/" or that @items
* contains exactly one item: "". @prefix need not be the largest
* possible prefix.
*
* The implementation must call this function during any call to
* g_settings_backend_write(), before the call returns (except in the
* case that no keys are actually changed). It may not rely on the
* existence of a mainloop for dispatching the signal later.
*
* The implementation may call this function at any other time it likes
* in response to other events (such as changes occuring outside of the
* program). These calls may originate from a mainloop or may originate
* in response to any other action (including from calls to
* g_settings_backend_write()).
*
* In the case that this call is in response to a call to
* g_settings_backend_write() then @origin_tag must be set to the same
* value that was passed to that call.
**/
void
g_settings_backend_changed (GSettingsBackend *backend,
const gchar *prefix,
gchar const * const *items,
gint n_items,
gpointer origin_tag)
{
if (n_items == -1)
for (n_items = 0; items[n_items]; n_items++);
g_assert (items[n_items] == NULL);
g_signal_emit (backend, changed_signal, 0,
prefix, items, n_items, origin_tag);
}
static gboolean
g_settings_backend_append_to_list (gpointer key,
gpointer value,
gpointer user_data)
{
return (*((*((gchar ***) user_data))++) = key, FALSE);
}
/**
* g_settings_backend_changed_tree:
* @backend: a #GSettingsBackend implementation
* @prefix: the longest common prefix
* @tree: a #GTree
* @origin_tag: the origin tag
*
* This call is a convenience wrapper around
* g_settings_backend_changed(). It gets the list of changes from
* @tree.
**/
void
g_settings_backend_changed_tree (GSettingsBackend *backend,
const gchar *prefix,
GTree *tree,
gpointer origin_tag)
{
gchar **list;
list = g_new (gchar *, g_tree_nnodes (tree) + 1);
{
gchar **ptr = list;
g_tree_foreach (tree, g_settings_backend_append_to_list, &ptr);
*ptr = NULL;
g_assert (list + g_tree_nnodes (tree) == ptr);
}
g_signal_emit (backend, changed_signal, 0,
prefix, list, g_tree_nnodes (tree), origin_tag);
g_free (list);
}
/**
* g_settings_backend_read:
* @backend: a #GSettingsBackend implementation
* @key: the key to read
* @expected_type: a #GVariantType hint
* @returns: the values that was read, or %NULL
*
* Reads a keys. This call will never block.
*
* If the key exists, it will be returned. If the key does not exist,
* %NULL will be returned.
*
* If @expected_type is given, it serves as a type hint to the backend.
* If you expect a key of a certain type then you should give
* @expected_type to increase your chances of getting it. Some backends
* may ignore this argument and return values of a different type; it is
* mostly used by backends that don't store strong type information.
**/
GVariant *
g_settings_backend_read (GSettingsBackend *backend,
const gchar *key,
const GVariantType *expected_type)
{
return G_SETTINGS_BACKEND_GET_CLASS (backend)
->read (backend, key, expected_type);
}
/**
* g_settings_backend_write:
* @backend: a #GSettingsBackend implementation
* @prefix: the longest common prefix
* @values: a #GTree containing values to write
* @origin_tag: the origin tag
*
* Writes one or more keys. This call will never block.
*
* For each item in @values, a key is written. The key to be written is
* @prefix prepended to the key used in the tree. The value stored in
* the tree is expected to be a #GVariant instance. It must either be
* the case that @prefix is equal to "" or ends in "/" or that @values
* contains exactly one item, with a key of "". @prefix need not be the
* largest possible prefix.
*
* This call does not fail. During this call a "changed" signal will be
* emitted if any keys have been changed. The new values of all updated
* keys will be visible to any signal callbacks.
*
* One possible method that an implementation might deal with failures
* is to emit a second "backend-changed" signal (either during this
* call, or later) to indicate that the affected keys have suddenly
* "changed back" to their old values.
**/
void
g_settings_backend_write (GSettingsBackend *backend,
const gchar *prefix,
GTree *values,
gpointer origin_tag)
{
G_SETTINGS_BACKEND_GET_CLASS (backend)
->write (backend, prefix, values, origin_tag);
}
/**
* g_settings_backend_get_writable:
* @backend: a #GSettingsBackend implementation
* @name: the name of a key, relative to the root of the backend
* @returns: %TRUE if the key is writable
*
* Ensures that a key is available for writing to. This is the
* interface through which 'lockdown' is implemented. Locked down
* keys will have %FALSE returned by this call.
*
* You should not write to locked-down keys, but if you do, the
* implementation will deal with it.
**/
gboolean
g_settings_backend_get_writable (GSettingsBackend *backend,
const gchar *name)
{
return G_SETTINGS_BACKEND_GET_CLASS (backend)
->get_writable (backend, name);
}
/**
* g_settings_backend_subscribe:
* @backend: a #GSettingsBackend
* @name: a key or path to subscribe to
*
* Reverses the effect of a previous call to
* g_settings_backend_subscribe().
**/
void
g_settings_backend_unsubscribe (GSettingsBackend *backend,
const char *name)
{
G_SETTINGS_BACKEND_GET_CLASS (backend)
->unsubscribe (backend, name);
}
/**
* g_settings_backend_subscribe:
* @backend: a #GSettingsBackend
* @name: a key or path to subscribe to
*
* Requests that change signals be emitted for events on @name.
**/
void
g_settings_backend_subscribe (GSettingsBackend *backend,
const gchar *name)
{
G_SETTINGS_BACKEND_GET_CLASS (backend)
->subscribe (backend, name);
}
static void
g_settings_backend_class_init (GSettingsBackendClass *class)
{
changed_signal =
g_signal_new ("changed", G_TYPE_SETTINGS_BACKEND,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GSettingsBackendClass, changed),
NULL, NULL,
_gio_marshal_VOID__STRING_BOXED_INT_POINTER, G_TYPE_NONE,
4, G_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE,
G_TYPE_STRV | G_SIGNAL_TYPE_STATIC_SCOPE,
G_TYPE_INT, G_TYPE_POINTER);
}
/**
* g_settings_backend_create_tree:
* @returns: a new #GTree
*
* This is a convenience function for creating a tree that is compatible
* with g_settings_backend_write(). It merely calls g_tree_new_full()
* with strcmp() g_free() and g_variant_unref().
**/
GTree *
g_settings_backend_create_tree (void)
{
return g_tree_new_full ((GCompareDataFunc) strcmp, NULL,
g_free, (GDestroyNotify) g_variant_unref);
}
static gpointer
get_default_backend (gpointer user_data)
{
GIOExtension *extension = NULL;
GIOExtensionPoint *point;
GList *extensions;
const gchar *env;
GType type;
_g_io_modules_ensure_loaded ();
point = g_io_extension_point_lookup (G_SETTINGS_BACKEND_EXTENSION_POINT_NAME);
if ((env = getenv ("GSETTINGS_BACKEND")))
{
extension = g_io_extension_point_get_extension_by_name (point, env);
if (extension == NULL)
g_warning ("Can't find GSettings backend '%s' given in "
"GSETTINGS_BACKEND environment variable", env);
}
if (extension == NULL)
{
extensions = g_io_extension_point_get_extensions (point);
if (extensions == NULL)
g_error ("No GSettingsBackend implementations exist.");
extension = extensions->data;
}
type = g_io_extension_get_type (extension);
return g_object_new (type, NULL);
}
/**
* g_settings_backend_get_default:
* @returns: the default #GSettingsBackend
*
* Returns the default #GSettingsBackend.
*
* The user does not own the return value and it must not be freed.
**/
GSettingsBackend *
g_settings_backend_get_default (void)
{
static GOnce once = G_ONCE_INIT;
return g_once (&once, get_default_backend, NULL);
}
static void
g_settings_backend_init (GSettingsBackend *backend)
{
}

108
gio/gsettingsbackend.h Normal file
View File

@@ -0,0 +1,108 @@
/*
* Copyright © 2009 Codethink Limited
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of version 3 of the GNU General Public License as
* published by the Free Software Foundation.
*
* See the included COPYING file for more information.
*/
#ifndef _gsettingsbackend_h_
#define _gsettingsbackend_h_
#include <glib-object.h>
G_BEGIN_DECLS
#define G_TYPE_SETTINGS_BACKEND (g_settings_backend_get_type ())
#define G_SETTINGS_BACKEND(inst) (G_TYPE_CHECK_INSTANCE_CAST ((inst), \
G_TYPE_SETTINGS_BACKEND, GSettingsBackend))
#define G_SETTINGS_BACKEND_CLASS(class) (G_TYPE_CHECK_CLASS_CAST ((class), \
G_TYPE_SETTINGS_BACKEND, GSettingsBackendClass))
#define G_IS_SETTINGS_BACKEND(inst) (G_TYPE_CHECK_INSTANCE_TYPE ((inst), \
G_TYPE_SETTINGS_BACKEND))
#define G_IS_SETTINGS_BACKEND_CLASS(class) (G_TYPE_CHECK_CLASS_TYPE ((class), \
G_TYPE_SETTINGS_BACKEND))
#define G_SETTINGS_BACKEND_GET_CLASS(inst) (G_TYPE_INSTANCE_GET_CLASS ((inst), \
G_TYPE_SETTINGS_BACKEND, GSettingsBackendClass))
#define G_SETTINGS_BACKEND_EXTENSION_POINT_NAME "gsettings-backend"
/**
* GSettingsBackend:
*
* An implementation of a settings storage repository.
**/
typedef struct _GSettingsBackendPrivate GSettingsBackendPrivate;
typedef struct _GSettingsBackendClass GSettingsBackendClass;
typedef struct _GSettingsBackend GSettingsBackend;
struct _GSettingsBackendClass
{
GObjectClass parent_class;
void (*changed) (GSettingsBackend *backend,
const gchar *prefix,
gchar const * const *names,
gint names_len,
gpointer origin_tag);
GVariant * (*read) (GSettingsBackend *backend,
const gchar *key,
const GVariantType *expected_type);
void (*write) (GSettingsBackend *backend,
const gchar *prefix,
GTree *tree,
gpointer origin_tag);
gboolean (*get_writable) (GSettingsBackend *backend,
const gchar *name);
void (*subscribe) (GSettingsBackend *backend,
const gchar *name);
void (*unsubscribe) (GSettingsBackend *backend,
const gchar *name);
};
struct _GSettingsBackend
{
GObject parent_instance;
/*< private >*/
GSettingsBackendPrivate *priv;
};
GType g_settings_backend_get_type (void);
GSettingsBackend * g_settings_backend_get_default (void);
void g_settings_backend_set_default (GSettingsBackend *backend);
GTree * g_settings_backend_create_tree (void);
GVariant * g_settings_backend_read (GSettingsBackend *backend,
const gchar *key,
const GVariantType *expected_type);
void g_settings_backend_write (GSettingsBackend *backend,
const gchar *prefix,
GTree *values,
gpointer origin_tag);
gboolean g_settings_backend_get_writable (GSettingsBackend *backend,
const char *name);
void g_settings_backend_unsubscribe (GSettingsBackend *backend,
const char *name);
void g_settings_backend_subscribe (GSettingsBackend *backend,
const char *name);
void g_settings_backend_changed (GSettingsBackend *backend,
const gchar *prefix,
gchar const * const *items,
gint n_items,
gpointer origin_tag);
void g_settings_backend_changed_tree (GSettingsBackend *backend,
const gchar *prefix,
GTree *tree,
gpointer origin_tag);
G_END_DECLS
#endif /* _gsettingsbackend_h_ */