mirror of
https://gitlab.gnome.org/GNOME/glib.git
synced 2024-11-02 15:46:17 +01:00
da386705f9
First, correct a rather dubious case of accessing a GSettingsSchemaKey after clearing it. This was technically okay because only the key name was accessed (and it is not owned by the struct) but it looks very wrong. Second, have g_settings_backend_write() sink the passed in GVariant*. Not all backends get this right, and I'm starting to like the pattern of virtual function wrappers being responsible for sinking the parameters that they are documented as consuming.
3111 lines
96 KiB
C
3111 lines
96 KiB
C
/*
|
|
* Copyright © 2009, 2010 Codethink Limited
|
|
*
|
|
* This library 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 of the licence, or (at your option) any later version.
|
|
*
|
|
* This library 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
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
* Boston, MA 02111-1307, USA.
|
|
*
|
|
* Author: Ryan Lortie <desrt@desrt.ca>
|
|
*/
|
|
|
|
/* Prelude {{{1 */
|
|
#include "config.h"
|
|
|
|
#include <glib.h>
|
|
#include <glibintl.h>
|
|
|
|
#include "gsettings.h"
|
|
|
|
#include "gdelayedsettingsbackend.h"
|
|
#include "gsettingsbackendinternal.h"
|
|
#include "gsettings-mapping.h"
|
|
#include "gsettingsschema-internal.h"
|
|
#include "gaction.h"
|
|
|
|
#include "strinfo.c"
|
|
|
|
/**
|
|
* SECTION:gsettings
|
|
* @short_description: High-level API for application settings
|
|
*
|
|
* The #GSettings class provides a convenient API for storing and retrieving
|
|
* application settings.
|
|
*
|
|
* Reads and writes can be considered to be non-blocking. Reading
|
|
* settings with #GSettings is typically extremely fast: on
|
|
* approximately the same order of magnitude (but slower than) a
|
|
* #GHashTable lookup. Writing settings is also extremely fast in terms
|
|
* of time to return to your application, but can be extremely expensive
|
|
* for other threads and other processes. Many settings backends
|
|
* (including dconf) have lazy initialisation which means in the common
|
|
* case of the user using their computer without modifying any settings
|
|
* a lot of work can be avoided. For dconf, the D-Bus service doesn't
|
|
* even need to be started in this case. For this reason, you should
|
|
* only ever modify #GSettings keys in response to explicit user action.
|
|
* Particular care should be paid to ensure that modifications are not
|
|
* made during startup -- for example, when setting the initial value
|
|
* of preferences widgets. The built-in g_settings_bind() functionality
|
|
* is careful not to write settings in response to notify signals as a
|
|
* result of modifications that it makes to widgets.
|
|
*
|
|
* When creating a GSettings instance, you have to specify a schema
|
|
* that describes the keys in your settings and their types and default
|
|
* values, as well as some other information.
|
|
*
|
|
* Normally, a schema has as fixed path that determines where the settings
|
|
* are stored in the conceptual global tree of settings. However, schemas
|
|
* can also be 'relocatable', i.e. not equipped with a fixed path. This is
|
|
* useful e.g. when the schema describes an 'account', and you want to be
|
|
* able to store a arbitrary number of accounts.
|
|
*
|
|
* Unlike other configuration systems (like GConf), GSettings does not
|
|
* restrict keys to basic types like strings and numbers. GSettings stores
|
|
* values as #GVariant, and allows any #GVariantType for keys. Key names
|
|
* are restricted to lowercase characters, numbers and '-'. Furthermore,
|
|
* the names must begin with a lowercase character, must not end
|
|
* with a '-', and must not contain consecutive dashes.
|
|
*
|
|
* Similar to GConf, the default values in GSettings schemas can be
|
|
* localized, but the localized values are stored in gettext catalogs
|
|
* and looked up with the domain that is specified in the
|
|
* <tag class="attribute">gettext-domain</tag> attribute of the
|
|
* <tag class="starttag">schemalist</tag> or <tag class="starttag">schema</tag>
|
|
* elements and the category that is specified in the l10n attribute of the
|
|
* <tag class="starttag">key</tag> element.
|
|
*
|
|
* GSettings uses schemas in a compact binary form that is created
|
|
* by the <link linkend="glib-compile-schemas">glib-compile-schemas</link>
|
|
* utility. The input is a schema description in an XML format that can be
|
|
* described by the following DTD:
|
|
* |[<xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../gio/gschema.dtd"><xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback></xi:include>]|
|
|
*
|
|
* glib-compile-schemas expects schema files to have the extension <filename>.gschema.xml</filename>
|
|
*
|
|
* At runtime, schemas are identified by their id (as specified
|
|
* in the <tag class="attribute">id</tag> attribute of the
|
|
* <tag class="starttag">schema</tag> element). The
|
|
* convention for schema ids is to use a dotted name, similar in
|
|
* style to a D-Bus bus name, e.g. "org.gnome.SessionManager". In particular,
|
|
* if the settings are for a specific service that owns a D-Bus bus name,
|
|
* the D-Bus bus name and schema id should match. For schemas which deal
|
|
* with settings not associated with one named application, the id should
|
|
* not use StudlyCaps, e.g. "org.gnome.font-rendering".
|
|
*
|
|
* In addition to #GVariant types, keys can have types that have enumerated
|
|
* types. These can be described by a <tag class="starttag">choice</tag>,
|
|
* <tag class="starttag">enum</tag> or <tag class="starttag">flags</tag> element, see
|
|
* <xref linkend="schema-enumerated"/>. The underlying type of
|
|
* such a key is string, but you can use g_settings_get_enum(),
|
|
* g_settings_set_enum(), g_settings_get_flags(), g_settings_set_flags()
|
|
* access the numeric values corresponding to the string value of enum
|
|
* and flags keys.
|
|
*
|
|
* <example id="schema-default-values"><title>Default values</title>
|
|
* <programlisting><![CDATA[
|
|
* <schemalist>
|
|
* <schema id="org.gtk.Test" path="/tests/" gettext-domain="test">
|
|
*
|
|
* <key name="greeting" type="s">
|
|
* <default l10n="messages">"Hello, earthlings"</default>
|
|
* <summary>A greeting</summary>
|
|
* <description>
|
|
* Greeting of the invading martians
|
|
* </description>
|
|
* </key>
|
|
*
|
|
* <key name="box" type="(ii)">
|
|
* <default>(20,30)</default>
|
|
* </key>
|
|
*
|
|
* </schema>
|
|
* </schemalist>
|
|
* ]]></programlisting></example>
|
|
*
|
|
* <example id="schema-enumerated"><title>Ranges, choices and enumerated types</title>
|
|
* <programlisting><![CDATA[
|
|
* <schemalist>
|
|
*
|
|
* <enum id="org.gtk.Test.myenum">
|
|
* <value nick="first" value="1"/>
|
|
* <value nick="second" value="2"/>
|
|
* </enum>
|
|
*
|
|
* <flags id="org.gtk.Test.myflags">
|
|
* <value nick="flag1" value="1"/>
|
|
* <value nick="flag2" value="2"/>
|
|
* <value nick="flag3" value="4"/>
|
|
* </flags>
|
|
*
|
|
* <schema id="org.gtk.Test">
|
|
*
|
|
* <key name="key-with-range" type="i">
|
|
* <range min="1" max="100"/>
|
|
* <default>10</default>
|
|
* </key>
|
|
*
|
|
* <key name="key-with-choices" type="s">
|
|
* <choices>
|
|
* <choice value='Elisabeth'/>
|
|
* <choice value='Annabeth'/>
|
|
* <choice value='Joe'/>
|
|
* </choices>
|
|
* <aliases>
|
|
* <alias value='Anna' target='Annabeth'/>
|
|
* <alias value='Beth' target='Elisabeth'/>
|
|
* </aliases>
|
|
* <default>'Joe'</default>
|
|
* </key>
|
|
*
|
|
* <key name='enumerated-key' enum='org.gtk.Test.myenum'>
|
|
* <default>'first'</default>
|
|
* </key>
|
|
*
|
|
* <key name='flags-key' flags='org.gtk.Test.myflags'>
|
|
* <default>["flag1",flag2"]</default>
|
|
* </key>
|
|
* </schema>
|
|
* </schemalist>
|
|
* ]]></programlisting></example>
|
|
*
|
|
* <refsect2>
|
|
* <title>Vendor overrides</title>
|
|
* <para>
|
|
* Default values are defined in the schemas that get installed by
|
|
* an application. Sometimes, it is necessary for a vendor or distributor
|
|
* to adjust these defaults. Since patching the XML source for the schema
|
|
* is inconvenient and error-prone,
|
|
* <link linkend="glib-compile-schemas">glib-compile-schemas</link> reads
|
|
* so-called 'vendor override' files. These are keyfiles in the same
|
|
* directory as the XML schema sources which can override default values.
|
|
* The schema id serves as the group name in the key file, and the values
|
|
* are expected in serialized GVariant form, as in the following example:
|
|
* <informalexample><programlisting>
|
|
* [org.gtk.Example]
|
|
* key1='string'
|
|
* key2=1.5
|
|
* </programlisting></informalexample>
|
|
* </para>
|
|
* <para>
|
|
* glib-compile-schemas expects schema files to have the extension
|
|
* <filename>.gschema.override</filename>
|
|
* </para>
|
|
* </refsect2>
|
|
*
|
|
* <refsect2>
|
|
* <title>Binding</title>
|
|
* <para>
|
|
* A very convenient feature of GSettings lets you bind #GObject properties
|
|
* directly to settings, using g_settings_bind(). Once a GObject property
|
|
* has been bound to a setting, changes on either side are automatically
|
|
* propagated to the other side. GSettings handles details like
|
|
* mapping between GObject and GVariant types, and preventing infinite
|
|
* cycles.
|
|
* </para>
|
|
* <para>
|
|
* This makes it very easy to hook up a preferences dialog to the
|
|
* underlying settings. To make this even more convenient, GSettings
|
|
* looks for a boolean property with the name "sensitivity" and
|
|
* automatically binds it to the writability of the bound setting.
|
|
* If this 'magic' gets in the way, it can be suppressed with the
|
|
* #G_SETTINGS_BIND_NO_SENSITIVITY flag.
|
|
* </para>
|
|
* </refsect2>
|
|
**/
|
|
|
|
struct _GSettingsPrivate
|
|
{
|
|
/* where the signals go... */
|
|
GMainContext *main_context;
|
|
|
|
GSettingsBackend *backend;
|
|
GSettingsSchema *schema;
|
|
gchar *path;
|
|
|
|
GDelayedSettingsBackend *delayed;
|
|
};
|
|
|
|
enum
|
|
{
|
|
PROP_0,
|
|
PROP_SCHEMA,
|
|
PROP_SCHEMA_ID,
|
|
PROP_BACKEND,
|
|
PROP_PATH,
|
|
PROP_HAS_UNAPPLIED,
|
|
PROP_DELAY_APPLY
|
|
};
|
|
|
|
enum
|
|
{
|
|
SIGNAL_WRITABLE_CHANGE_EVENT,
|
|
SIGNAL_WRITABLE_CHANGED,
|
|
SIGNAL_CHANGE_EVENT,
|
|
SIGNAL_CHANGED,
|
|
N_SIGNALS
|
|
};
|
|
|
|
static guint g_settings_signals[N_SIGNALS];
|
|
|
|
G_DEFINE_TYPE (GSettings, g_settings, G_TYPE_OBJECT)
|
|
|
|
/* Signals {{{1 */
|
|
static gboolean
|
|
g_settings_real_change_event (GSettings *settings,
|
|
const GQuark *keys,
|
|
gint n_keys)
|
|
{
|
|
gint i;
|
|
|
|
if (keys == NULL)
|
|
keys = g_settings_schema_list (settings->priv->schema, &n_keys);
|
|
|
|
for (i = 0; i < n_keys; i++)
|
|
g_signal_emit (settings, g_settings_signals[SIGNAL_CHANGED],
|
|
keys[i], g_quark_to_string (keys[i]));
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean
|
|
g_settings_real_writable_change_event (GSettings *settings,
|
|
GQuark key)
|
|
{
|
|
const GQuark *keys = &key;
|
|
gint n_keys = 1;
|
|
gint i;
|
|
|
|
if (key == 0)
|
|
keys = g_settings_schema_list (settings->priv->schema, &n_keys);
|
|
|
|
for (i = 0; i < n_keys; i++)
|
|
g_signal_emit (settings, g_settings_signals[SIGNAL_WRITABLE_CHANGED],
|
|
keys[i], g_quark_to_string (keys[i]));
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static void
|
|
settings_backend_changed (GObject *target,
|
|
GSettingsBackend *backend,
|
|
const gchar *key,
|
|
gpointer origin_tag)
|
|
{
|
|
GSettings *settings = G_SETTINGS (target);
|
|
gboolean ignore_this;
|
|
gint i;
|
|
|
|
/* We used to assert here:
|
|
*
|
|
* settings->priv->backend == backend
|
|
*
|
|
* but it could be the case that a notification is queued for delivery
|
|
* while someone calls g_settings_delay() (which changes the backend).
|
|
*
|
|
* Since the delay backend would just pass that straight through
|
|
* anyway, it doesn't make sense to try to detect this case.
|
|
* Therefore, we just accept it.
|
|
*/
|
|
|
|
for (i = 0; key[i] == settings->priv->path[i]; i++);
|
|
|
|
if (settings->priv->path[i] == '\0' &&
|
|
g_settings_schema_has_key (settings->priv->schema, key + i))
|
|
{
|
|
GQuark quark;
|
|
|
|
quark = g_quark_from_string (key + i);
|
|
g_signal_emit (settings, g_settings_signals[SIGNAL_CHANGE_EVENT],
|
|
0, &quark, 1, &ignore_this);
|
|
}
|
|
}
|
|
|
|
static void
|
|
settings_backend_path_changed (GObject *target,
|
|
GSettingsBackend *backend,
|
|
const gchar *path,
|
|
gpointer origin_tag)
|
|
{
|
|
GSettings *settings = G_SETTINGS (target);
|
|
gboolean ignore_this;
|
|
|
|
if (g_str_has_prefix (settings->priv->path, path))
|
|
g_signal_emit (settings, g_settings_signals[SIGNAL_CHANGE_EVENT],
|
|
0, NULL, 0, &ignore_this);
|
|
}
|
|
|
|
static void
|
|
settings_backend_keys_changed (GObject *target,
|
|
GSettingsBackend *backend,
|
|
const gchar *path,
|
|
const gchar * const *items,
|
|
gpointer origin_tag)
|
|
{
|
|
GSettings *settings = G_SETTINGS (target);
|
|
gboolean ignore_this;
|
|
gint i;
|
|
|
|
for (i = 0; settings->priv->path[i] &&
|
|
settings->priv->path[i] == path[i]; i++);
|
|
|
|
if (path[i] == '\0')
|
|
{
|
|
GQuark quarks[256];
|
|
gint j, l = 0;
|
|
|
|
for (j = 0; items[j]; j++)
|
|
{
|
|
const gchar *item = items[j];
|
|
gint k;
|
|
|
|
for (k = 0; item[k] == settings->priv->path[i + k]; k++);
|
|
|
|
if (settings->priv->path[i + k] == '\0' &&
|
|
g_settings_schema_has_key (settings->priv->schema, item + k))
|
|
quarks[l++] = g_quark_from_string (item + k);
|
|
|
|
/* "256 quarks ought to be enough for anybody!"
|
|
* If this bites you, I'm sorry. Please file a bug.
|
|
*/
|
|
g_assert (l < 256);
|
|
}
|
|
|
|
if (l > 0)
|
|
g_signal_emit (settings, g_settings_signals[SIGNAL_CHANGE_EVENT],
|
|
0, quarks, l, &ignore_this);
|
|
}
|
|
}
|
|
|
|
static void
|
|
settings_backend_writable_changed (GObject *target,
|
|
GSettingsBackend *backend,
|
|
const gchar *key)
|
|
{
|
|
GSettings *settings = G_SETTINGS (target);
|
|
gboolean ignore_this;
|
|
gint i;
|
|
|
|
for (i = 0; key[i] == settings->priv->path[i]; i++);
|
|
|
|
if (settings->priv->path[i] == '\0' &&
|
|
g_settings_schema_has_key (settings->priv->schema, key + i))
|
|
g_signal_emit (settings, g_settings_signals[SIGNAL_WRITABLE_CHANGE_EVENT],
|
|
0, g_quark_from_string (key + i), &ignore_this);
|
|
}
|
|
|
|
static void
|
|
settings_backend_path_writable_changed (GObject *target,
|
|
GSettingsBackend *backend,
|
|
const gchar *path)
|
|
{
|
|
GSettings *settings = G_SETTINGS (target);
|
|
gboolean ignore_this;
|
|
|
|
if (g_str_has_prefix (settings->priv->path, path))
|
|
g_signal_emit (settings, g_settings_signals[SIGNAL_WRITABLE_CHANGE_EVENT],
|
|
0, (GQuark) 0, &ignore_this);
|
|
}
|
|
|
|
/* Properties, Construction, Destruction {{{1 */
|
|
static void
|
|
g_settings_set_property (GObject *object,
|
|
guint prop_id,
|
|
const GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
GSettings *settings = G_SETTINGS (object);
|
|
|
|
switch (prop_id)
|
|
{
|
|
case PROP_SCHEMA:
|
|
{
|
|
GSettingsSchema *schema;
|
|
|
|
schema = g_value_dup_boxed (value);
|
|
|
|
/* we receive a set_property() call for "settings-schema" even
|
|
* if it was not specified (ie: with NULL value). ->schema
|
|
* could already be set at this point (ie: via "schema-id").
|
|
* check for NULL to avoid clobbering the existing value.
|
|
*/
|
|
if (schema != NULL)
|
|
{
|
|
g_assert (settings->priv->schema == NULL);
|
|
settings->priv->schema = schema;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case PROP_SCHEMA_ID:
|
|
{
|
|
const gchar *schema_id;
|
|
|
|
schema_id = g_value_get_string (value);
|
|
|
|
/* we receive a set_property() call for both "schema" and
|
|
* "schema-id", even if they are not set. Hopefully only one of
|
|
* them is non-NULL.
|
|
*/
|
|
if (schema_id != NULL)
|
|
{
|
|
GSettingsSchemaSource *default_source;
|
|
|
|
g_assert (settings->priv->schema == NULL);
|
|
default_source = g_settings_schema_source_get_default ();
|
|
|
|
if (default_source == NULL)
|
|
g_error ("No GSettings schemas are installed on the system");
|
|
|
|
settings->priv->schema = g_settings_schema_source_lookup (default_source, schema_id, TRUE);
|
|
|
|
if (settings->priv->schema == NULL)
|
|
g_error ("Settings schema '%s' is not installed\n", schema_id);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case PROP_PATH:
|
|
settings->priv->path = g_value_dup_string (value);
|
|
break;
|
|
|
|
case PROP_BACKEND:
|
|
settings->priv->backend = g_value_dup_object (value);
|
|
break;
|
|
|
|
default:
|
|
g_assert_not_reached ();
|
|
}
|
|
}
|
|
|
|
static void
|
|
g_settings_get_property (GObject *object,
|
|
guint prop_id,
|
|
GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
GSettings *settings = G_SETTINGS (object);
|
|
|
|
switch (prop_id)
|
|
{
|
|
case PROP_SCHEMA:
|
|
g_value_set_boxed (value, settings->priv->schema);
|
|
break;
|
|
|
|
case PROP_SCHEMA_ID:
|
|
g_value_set_string (value, g_settings_schema_get_id (settings->priv->schema));
|
|
break;
|
|
|
|
case PROP_BACKEND:
|
|
g_value_set_object (value, settings->priv->backend);
|
|
break;
|
|
|
|
case PROP_PATH:
|
|
g_value_set_string (value, settings->priv->path);
|
|
break;
|
|
|
|
case PROP_HAS_UNAPPLIED:
|
|
g_value_set_boolean (value, g_settings_get_has_unapplied (settings));
|
|
break;
|
|
|
|
case PROP_DELAY_APPLY:
|
|
g_value_set_boolean (value, settings->priv->delayed != NULL);
|
|
break;
|
|
|
|
default:
|
|
g_assert_not_reached ();
|
|
}
|
|
}
|
|
|
|
static const GSettingsListenerVTable listener_vtable = {
|
|
settings_backend_changed,
|
|
settings_backend_path_changed,
|
|
settings_backend_keys_changed,
|
|
settings_backend_writable_changed,
|
|
settings_backend_path_writable_changed
|
|
};
|
|
|
|
static void
|
|
g_settings_constructed (GObject *object)
|
|
{
|
|
GSettings *settings = G_SETTINGS (object);
|
|
const gchar *schema_path;
|
|
|
|
schema_path = g_settings_schema_get_path (settings->priv->schema);
|
|
|
|
if (settings->priv->path && schema_path && strcmp (settings->priv->path, schema_path) != 0)
|
|
g_error ("settings object created with schema '%s' and path '%s', but path '%s' is specified by schema",
|
|
g_settings_schema_get_id (settings->priv->schema), settings->priv->path, schema_path);
|
|
|
|
if (settings->priv->path == NULL)
|
|
{
|
|
if (schema_path == NULL)
|
|
g_error ("attempting to create schema '%s' without a path",
|
|
g_settings_schema_get_id (settings->priv->schema));
|
|
|
|
settings->priv->path = g_strdup (schema_path);
|
|
}
|
|
|
|
if (settings->priv->backend == NULL)
|
|
settings->priv->backend = g_settings_backend_get_default ();
|
|
|
|
g_settings_backend_watch (settings->priv->backend,
|
|
&listener_vtable, G_OBJECT (settings),
|
|
settings->priv->main_context);
|
|
g_settings_backend_subscribe (settings->priv->backend,
|
|
settings->priv->path);
|
|
}
|
|
|
|
static void
|
|
g_settings_finalize (GObject *object)
|
|
{
|
|
GSettings *settings = G_SETTINGS (object);
|
|
|
|
g_settings_backend_unsubscribe (settings->priv->backend,
|
|
settings->priv->path);
|
|
g_main_context_unref (settings->priv->main_context);
|
|
g_object_unref (settings->priv->backend);
|
|
g_settings_schema_unref (settings->priv->schema);
|
|
g_free (settings->priv->path);
|
|
|
|
G_OBJECT_CLASS (g_settings_parent_class)->finalize (object);
|
|
}
|
|
|
|
static void
|
|
g_settings_init (GSettings *settings)
|
|
{
|
|
settings->priv = G_TYPE_INSTANCE_GET_PRIVATE (settings,
|
|
G_TYPE_SETTINGS,
|
|
GSettingsPrivate);
|
|
|
|
settings->priv->main_context = g_main_context_ref_thread_default ();
|
|
}
|
|
|
|
static void
|
|
g_settings_class_init (GSettingsClass *class)
|
|
{
|
|
GObjectClass *object_class = G_OBJECT_CLASS (class);
|
|
|
|
class->writable_change_event = g_settings_real_writable_change_event;
|
|
class->change_event = g_settings_real_change_event;
|
|
|
|
object_class->set_property = g_settings_set_property;
|
|
object_class->get_property = g_settings_get_property;
|
|
object_class->constructed = g_settings_constructed;
|
|
object_class->finalize = g_settings_finalize;
|
|
|
|
g_type_class_add_private (object_class, sizeof (GSettingsPrivate));
|
|
|
|
/**
|
|
* GSettings::changed:
|
|
* @settings: the object on which the signal was emitted
|
|
* @key: the name of the key that changed
|
|
*
|
|
* The "changed" signal is emitted when a key has potentially changed.
|
|
* You should call one of the g_settings_get() calls to check the new
|
|
* value.
|
|
*
|
|
* This signal supports detailed connections. You can connect to the
|
|
* detailed signal "changed::x" in order to only receive callbacks
|
|
* when key "x" changes.
|
|
*/
|
|
g_settings_signals[SIGNAL_CHANGED] =
|
|
g_signal_new ("changed", G_TYPE_SETTINGS,
|
|
G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
|
|
G_STRUCT_OFFSET (GSettingsClass, changed),
|
|
NULL, NULL, g_cclosure_marshal_VOID__STRING, G_TYPE_NONE,
|
|
1, G_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE);
|
|
|
|
/**
|
|
* GSettings::change-event:
|
|
* @settings: the object on which the signal was emitted
|
|
* @keys: (array length=n_keys) (element-type GQuark) (allow-none):
|
|
* an array of #GQuark<!-- -->s for the changed keys, or %NULL
|
|
* @n_keys: the length of the @keys array, or 0
|
|
*
|
|
* The "change-event" signal is emitted once per change event that
|
|
* affects this settings object. You should connect to this signal
|
|
* only if you are interested in viewing groups of changes before they
|
|
* are split out into multiple emissions of the "changed" signal.
|
|
* For most use cases it is more appropriate to use the "changed" signal.
|
|
*
|
|
* In the event that the change event applies to one or more specified
|
|
* keys, @keys will be an array of #GQuark of length @n_keys. In the
|
|
* event that the change event applies to the #GSettings object as a
|
|
* whole (ie: potentially every key has been changed) then @keys will
|
|
* be %NULL and @n_keys will be 0.
|
|
*
|
|
* The default handler for this signal invokes the "changed" signal
|
|
* for each affected key. If any other connected handler returns
|
|
* %TRUE then this default functionality will be suppressed.
|
|
*
|
|
* Returns: %TRUE to stop other handlers from being invoked for the
|
|
* event. FALSE to propagate the event further.
|
|
*/
|
|
g_settings_signals[SIGNAL_CHANGE_EVENT] =
|
|
g_signal_new ("change-event", G_TYPE_SETTINGS,
|
|
G_SIGNAL_RUN_LAST,
|
|
G_STRUCT_OFFSET (GSettingsClass, change_event),
|
|
g_signal_accumulator_true_handled, NULL,
|
|
NULL,
|
|
G_TYPE_BOOLEAN, 2, G_TYPE_POINTER, G_TYPE_INT);
|
|
|
|
/**
|
|
* GSettings::writable-changed:
|
|
* @settings: the object on which the signal was emitted
|
|
* @key: the key
|
|
*
|
|
* The "writable-changed" signal is emitted when the writability of a
|
|
* key has potentially changed. You should call
|
|
* g_settings_is_writable() in order to determine the new status.
|
|
*
|
|
* This signal supports detailed connections. You can connect to the
|
|
* detailed signal "writable-changed::x" in order to only receive
|
|
* callbacks when the writability of "x" changes.
|
|
*/
|
|
g_settings_signals[SIGNAL_WRITABLE_CHANGED] =
|
|
g_signal_new ("writable-changed", G_TYPE_SETTINGS,
|
|
G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
|
|
G_STRUCT_OFFSET (GSettingsClass, writable_changed),
|
|
NULL, NULL, g_cclosure_marshal_VOID__STRING, G_TYPE_NONE,
|
|
1, G_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE);
|
|
|
|
/**
|
|
* GSettings::writable-change-event:
|
|
* @settings: the object on which the signal was emitted
|
|
* @key: the quark of the key, or 0
|
|
*
|
|
* The "writable-change-event" signal is emitted once per writability
|
|
* change event that affects this settings object. You should connect
|
|
* to this signal if you are interested in viewing groups of changes
|
|
* before they are split out into multiple emissions of the
|
|
* "writable-changed" signal. For most use cases it is more
|
|
* appropriate to use the "writable-changed" signal.
|
|
*
|
|
* In the event that the writability change applies only to a single
|
|
* key, @key will be set to the #GQuark for that key. In the event
|
|
* that the writability change affects the entire settings object,
|
|
* @key will be 0.
|
|
*
|
|
* The default handler for this signal invokes the "writable-changed"
|
|
* and "changed" signals for each affected key. This is done because
|
|
* changes in writability might also imply changes in value (if for
|
|
* example, a new mandatory setting is introduced). If any other
|
|
* connected handler returns %TRUE then this default functionality
|
|
* will be suppressed.
|
|
*
|
|
* Returns: %TRUE to stop other handlers from being invoked for the
|
|
* event. FALSE to propagate the event further.
|
|
*/
|
|
g_settings_signals[SIGNAL_WRITABLE_CHANGE_EVENT] =
|
|
g_signal_new ("writable-change-event", G_TYPE_SETTINGS,
|
|
G_SIGNAL_RUN_LAST,
|
|
G_STRUCT_OFFSET (GSettingsClass, writable_change_event),
|
|
g_signal_accumulator_true_handled, NULL,
|
|
NULL, G_TYPE_BOOLEAN, 1, G_TYPE_UINT);
|
|
|
|
/**
|
|
* GSettings:context:
|
|
*
|
|
* The name of the context that the settings are stored in.
|
|
*/
|
|
g_object_class_install_property (object_class, PROP_BACKEND,
|
|
g_param_spec_object ("backend",
|
|
P_("GSettingsBackend"),
|
|
P_("The GSettingsBackend for this settings object"),
|
|
G_TYPE_SETTINGS_BACKEND, G_PARAM_CONSTRUCT_ONLY |
|
|
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* GSettings:settings-schema:
|
|
*
|
|
* The #GSettingsSchema describing the types of keys for this
|
|
* #GSettings object.
|
|
*
|
|
* Ideally, this property would be called 'schema'. #GSettingsSchema
|
|
* has only existed since version 2.32, however, and before then the
|
|
* 'schema' property was used to refer to the ID of the schema rather
|
|
* than the schema itself. Take care.
|
|
*/
|
|
g_object_class_install_property (object_class, PROP_SCHEMA,
|
|
g_param_spec_boxed ("settings-schema",
|
|
P_("schema"),
|
|
P_("The GSettingsSchema for this settings object"),
|
|
G_TYPE_SETTINGS_SCHEMA,
|
|
G_PARAM_CONSTRUCT_ONLY |
|
|
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* GSettings:schema:
|
|
*
|
|
* The name of the schema that describes the types of keys
|
|
* for this #GSettings object.
|
|
*
|
|
* The type of this property is *not* #GSettingsSchema.
|
|
* #GSettingsSchema has only existed since version 2.32 and
|
|
* unfortunately this name was used in previous versions to refer to
|
|
* the schema ID rather than the schema itself. Take care to use the
|
|
* 'settings-schema' property if you wish to pass in a
|
|
* #GSettingsSchema.
|
|
*
|
|
* Deprecated:2.32:Use the 'schema-id' property instead. In a future
|
|
* version, this property may instead refer to a #GSettingsSchema.
|
|
*/
|
|
g_object_class_install_property (object_class, PROP_SCHEMA_ID,
|
|
g_param_spec_string ("schema",
|
|
P_("Schema name"),
|
|
P_("The name of the schema for this settings object"),
|
|
NULL,
|
|
G_PARAM_CONSTRUCT_ONLY |
|
|
G_PARAM_DEPRECATED | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* GSettings:schema-id:
|
|
*
|
|
* The name of the schema that describes the types of keys
|
|
* for this #GSettings object.
|
|
*/
|
|
g_object_class_install_property (object_class, PROP_SCHEMA_ID,
|
|
g_param_spec_string ("schema-id",
|
|
P_("Schema name"),
|
|
P_("The name of the schema for this settings object"),
|
|
NULL,
|
|
G_PARAM_CONSTRUCT_ONLY |
|
|
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* GSettings:path:
|
|
*
|
|
* The path within the backend where the settings are stored.
|
|
*/
|
|
g_object_class_install_property (object_class, PROP_PATH,
|
|
g_param_spec_string ("path",
|
|
P_("Base path"),
|
|
P_("The path within the backend where the settings are"),
|
|
NULL,
|
|
G_PARAM_CONSTRUCT_ONLY |
|
|
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* GSettings:has-unapplied:
|
|
*
|
|
* If this property is %TRUE, the #GSettings object has outstanding
|
|
* changes that will be applied when g_settings_apply() is called.
|
|
*/
|
|
g_object_class_install_property (object_class, PROP_HAS_UNAPPLIED,
|
|
g_param_spec_boolean ("has-unapplied",
|
|
P_("Has unapplied changes"),
|
|
P_("TRUE if there are outstanding changes to apply()"),
|
|
FALSE,
|
|
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* GSettings:delay-apply:
|
|
*
|
|
* Whether the #GSettings object is in 'delay-apply' mode. See
|
|
* g_settings_delay() for details.
|
|
*
|
|
* Since: 2.28
|
|
*/
|
|
g_object_class_install_property (object_class, PROP_DELAY_APPLY,
|
|
g_param_spec_boolean ("delay-apply",
|
|
P_("Delay-apply mode"),
|
|
P_("Whether this settings object is in 'delay-apply' mode"),
|
|
FALSE,
|
|
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
|
|
}
|
|
|
|
/* Construction (new, new_with_path, etc.) {{{1 */
|
|
/**
|
|
* g_settings_new:
|
|
* @schema_id: the id of the schema
|
|
*
|
|
* Creates a new #GSettings object with the schema specified by
|
|
* @schema_id.
|
|
*
|
|
* Signals on the newly created #GSettings object will be dispatched
|
|
* via the thread-default #GMainContext in effect at the time of the
|
|
* call to g_settings_new(). The new #GSettings will hold a reference
|
|
* on the context. See g_main_context_push_thread_default().
|
|
*
|
|
* Returns: a new #GSettings object
|
|
*
|
|
* Since: 2.26
|
|
*/
|
|
GSettings *
|
|
g_settings_new (const gchar *schema_id)
|
|
{
|
|
g_return_val_if_fail (schema_id != NULL, NULL);
|
|
|
|
return g_object_new (G_TYPE_SETTINGS,
|
|
"schema-id", schema_id,
|
|
NULL);
|
|
}
|
|
|
|
/**
|
|
* g_settings_new_with_path:
|
|
* @schema_id: the id of the schema
|
|
* @path: the path to use
|
|
*
|
|
* Creates a new #GSettings object with the relocatable schema specified
|
|
* by @schema_id and a given path.
|
|
*
|
|
* You only need to do this if you want to directly create a settings
|
|
* object with a schema that doesn't have a specified path of its own.
|
|
* That's quite rare.
|
|
*
|
|
* It is a programmer error to call this function for a schema that
|
|
* has an explicitly specified path.
|
|
*
|
|
* Returns: a new #GSettings object
|
|
*
|
|
* Since: 2.26
|
|
*/
|
|
GSettings *
|
|
g_settings_new_with_path (const gchar *schema_id,
|
|
const gchar *path)
|
|
{
|
|
g_return_val_if_fail (schema_id != NULL, NULL);
|
|
g_return_val_if_fail (path != NULL, NULL);
|
|
|
|
return g_object_new (G_TYPE_SETTINGS,
|
|
"schema-id", schema_id,
|
|
"path", path,
|
|
NULL);
|
|
}
|
|
|
|
/**
|
|
* g_settings_new_with_backend:
|
|
* @schema_id: the id of the schema
|
|
* @backend: the #GSettingsBackend to use
|
|
*
|
|
* Creates a new #GSettings object with the schema specified by
|
|
* @schema_id and a given #GSettingsBackend.
|
|
*
|
|
* Creating a #GSettings object with a different backend allows accessing
|
|
* settings from a database other than the usual one. For example, it may make
|
|
* sense to pass a backend corresponding to the "defaults" settings database on
|
|
* the system to get a settings object that modifies the system default
|
|
* settings instead of the settings for this user.
|
|
*
|
|
* Returns: a new #GSettings object
|
|
*
|
|
* Since: 2.26
|
|
*/
|
|
GSettings *
|
|
g_settings_new_with_backend (const gchar *schema_id,
|
|
GSettingsBackend *backend)
|
|
{
|
|
g_return_val_if_fail (schema_id != NULL, NULL);
|
|
g_return_val_if_fail (G_IS_SETTINGS_BACKEND (backend), NULL);
|
|
|
|
return g_object_new (G_TYPE_SETTINGS,
|
|
"schema-id", schema_id,
|
|
"backend", backend,
|
|
NULL);
|
|
}
|
|
|
|
/**
|
|
* g_settings_new_with_backend_and_path:
|
|
* @schema_id: the id of the schema
|
|
* @backend: the #GSettingsBackend to use
|
|
* @path: the path to use
|
|
*
|
|
* Creates a new #GSettings object with the schema specified by
|
|
* @schema_id and a given #GSettingsBackend and path.
|
|
*
|
|
* This is a mix of g_settings_new_with_backend() and
|
|
* g_settings_new_with_path().
|
|
*
|
|
* Returns: a new #GSettings object
|
|
*
|
|
* Since: 2.26
|
|
*/
|
|
GSettings *
|
|
g_settings_new_with_backend_and_path (const gchar *schema_id,
|
|
GSettingsBackend *backend,
|
|
const gchar *path)
|
|
{
|
|
g_return_val_if_fail (schema_id != NULL, NULL);
|
|
g_return_val_if_fail (G_IS_SETTINGS_BACKEND (backend), NULL);
|
|
g_return_val_if_fail (path != NULL, NULL);
|
|
|
|
return g_object_new (G_TYPE_SETTINGS,
|
|
"schema-id", schema_id,
|
|
"backend", backend,
|
|
"path", path,
|
|
NULL);
|
|
}
|
|
|
|
/**
|
|
* g_settings_new_full:
|
|
* @schema: a #GSettingsSchema
|
|
* @backend: (allow-none): a #GSettingsBackend
|
|
* @path: (allow-none): the path to use
|
|
*
|
|
* Creates a new #GSettings object with a given schema, backend and
|
|
* path.
|
|
*
|
|
* It should be extremely rare that you ever want to use this function.
|
|
* It is made available for advanced use-cases (such as plugin systems
|
|
* that want to provide access to schemas loaded from custom locations,
|
|
* etc).
|
|
*
|
|
* At the most basic level, a #GSettings object is a pure composition of
|
|
* 4 things: a #GSettingsSchema, a #GSettingsBackend, a path within that
|
|
* backend, and a #GMainContext to which signals are dispatched.
|
|
*
|
|
* This constructor therefore gives you full control over constructing
|
|
* #GSettings instances. The first 4 parameters are given directly as
|
|
* @schema, @backend and @path, and the main context is taken from the
|
|
* thread-default (as per g_settings_new()).
|
|
*
|
|
* If @backend is %NULL then the default backend is used.
|
|
*
|
|
* If @path is %NULL then the path from the schema is used. It is an
|
|
* error f @path is %NULL and the schema has no path of its own or if
|
|
* @path is non-%NULL and not equal to the path that the schema does
|
|
* have.
|
|
*
|
|
* Returns: a new #GSettings object
|
|
*
|
|
* Since: 2.32
|
|
*/
|
|
GSettings *
|
|
g_settings_new_full (GSettingsSchema *schema,
|
|
GSettingsBackend *backend,
|
|
const gchar *path)
|
|
{
|
|
return g_object_new (G_TYPE_SETTINGS,
|
|
"settings-schema", schema,
|
|
"backend", backend,
|
|
"path", path,
|
|
NULL);
|
|
}
|
|
|
|
/* Internal read/write utilities {{{1 */
|
|
static gboolean
|
|
g_settings_write_to_backend (GSettings *settings,
|
|
GSettingsSchemaKey *key,
|
|
GVariant *value)
|
|
{
|
|
gboolean success;
|
|
gchar *path;
|
|
|
|
path = g_strconcat (settings->priv->path, key->name, NULL);
|
|
success = g_settings_backend_write (settings->priv->backend, path, value, NULL);
|
|
g_free (path);
|
|
|
|
return success;
|
|
}
|
|
|
|
static GVariant *
|
|
g_settings_read_from_backend (GSettings *settings,
|
|
GSettingsSchemaKey *key)
|
|
{
|
|
GVariant *value;
|
|
GVariant *fixup;
|
|
gchar *path;
|
|
|
|
path = g_strconcat (settings->priv->path, key->name, NULL);
|
|
value = g_settings_backend_read (settings->priv->backend, path, key->type, FALSE);
|
|
g_free (path);
|
|
|
|
if (value != NULL)
|
|
{
|
|
fixup = g_settings_schema_key_range_fixup (key, value);
|
|
g_variant_unref (value);
|
|
}
|
|
else
|
|
fixup = NULL;
|
|
|
|
return fixup;
|
|
}
|
|
|
|
/* Public Get/Set API {{{1 (get, get_value, set, set_value, get_mapped) */
|
|
/**
|
|
* g_settings_get_value:
|
|
* @settings: a #GSettings object
|
|
* @key: the key to get the value for
|
|
*
|
|
* Gets the value that is stored in @settings for @key.
|
|
*
|
|
* It is a programmer error to give a @key that isn't contained in the
|
|
* schema for @settings.
|
|
*
|
|
* Returns: a new #GVariant
|
|
*
|
|
* Since: 2.26
|
|
*/
|
|
GVariant *
|
|
g_settings_get_value (GSettings *settings,
|
|
const gchar *key)
|
|
{
|
|
GSettingsSchemaKey skey;
|
|
GVariant *value;
|
|
|
|
g_return_val_if_fail (G_IS_SETTINGS (settings), NULL);
|
|
g_return_val_if_fail (key != NULL, NULL);
|
|
|
|
g_settings_schema_key_init (&skey, settings->priv->schema, key);
|
|
value = g_settings_read_from_backend (settings, &skey);
|
|
|
|
if (value == NULL)
|
|
value = g_settings_schema_key_get_translated_default (&skey);
|
|
|
|
if (value == NULL)
|
|
value = g_variant_ref (skey.default_value);
|
|
|
|
g_settings_schema_key_clear (&skey);
|
|
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
* g_settings_get_enum:
|
|
* @settings: a #GSettings object
|
|
* @key: the key to get the value for
|
|
*
|
|
* Gets the value that is stored in @settings for @key and converts it
|
|
* to the enum value that it represents.
|
|
*
|
|
* In order to use this function the type of the value must be a string
|
|
* and it must be marked in the schema file as an enumerated type.
|
|
*
|
|
* It is a programmer error to give a @key that isn't contained in the
|
|
* schema for @settings or is not marked as an enumerated type.
|
|
*
|
|
* If the value stored in the configuration database is not a valid
|
|
* value for the enumerated type then this function will return the
|
|
* default value.
|
|
*
|
|
* Returns: the enum value
|
|
*
|
|
* Since: 2.26
|
|
**/
|
|
gint
|
|
g_settings_get_enum (GSettings *settings,
|
|
const gchar *key)
|
|
{
|
|
GSettingsSchemaKey skey;
|
|
GVariant *value;
|
|
gint result;
|
|
|
|
g_return_val_if_fail (G_IS_SETTINGS (settings), -1);
|
|
g_return_val_if_fail (key != NULL, -1);
|
|
|
|
g_settings_schema_key_init (&skey, settings->priv->schema, key);
|
|
|
|
if (!skey.is_enum)
|
|
{
|
|
g_critical ("g_settings_get_enum() called on key `%s' which is not "
|
|
"associated with an enumerated type", skey.name);
|
|
g_settings_schema_key_clear (&skey);
|
|
return -1;
|
|
}
|
|
|
|
value = g_settings_read_from_backend (settings, &skey);
|
|
|
|
if (value == NULL)
|
|
value = g_settings_schema_key_get_translated_default (&skey);
|
|
|
|
if (value == NULL)
|
|
value = g_variant_ref (skey.default_value);
|
|
|
|
result = g_settings_schema_key_to_enum (&skey, value);
|
|
g_settings_schema_key_clear (&skey);
|
|
g_variant_unref (value);
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* g_settings_set_enum:
|
|
* @settings: a #GSettings object
|
|
* @key: a key, within @settings
|
|
* @value: an enumerated value
|
|
*
|
|
* Looks up the enumerated type nick for @value and writes it to @key,
|
|
* within @settings.
|
|
*
|
|
* It is a programmer error to give a @key that isn't contained in the
|
|
* schema for @settings or is not marked as an enumerated type, or for
|
|
* @value not to be a valid value for the named type.
|
|
*
|
|
* After performing the write, accessing @key directly with
|
|
* g_settings_get_string() will return the 'nick' associated with
|
|
* @value.
|
|
*
|
|
* Returns: %TRUE, if the set succeeds
|
|
**/
|
|
gboolean
|
|
g_settings_set_enum (GSettings *settings,
|
|
const gchar *key,
|
|
gint value)
|
|
{
|
|
GSettingsSchemaKey skey;
|
|
GVariant *variant;
|
|
gboolean success;
|
|
|
|
g_return_val_if_fail (G_IS_SETTINGS (settings), FALSE);
|
|
g_return_val_if_fail (key != NULL, FALSE);
|
|
|
|
g_settings_schema_key_init (&skey, settings->priv->schema, key);
|
|
|
|
if (!skey.is_enum)
|
|
{
|
|
g_critical ("g_settings_set_enum() called on key `%s' which is not "
|
|
"associated with an enumerated type", skey.name);
|
|
return FALSE;
|
|
}
|
|
|
|
if (!(variant = g_settings_schema_key_from_enum (&skey, value)))
|
|
{
|
|
g_critical ("g_settings_set_enum(): invalid enum value %d for key `%s' "
|
|
"in schema `%s'. Doing nothing.", value, skey.name,
|
|
g_settings_schema_get_id (skey.schema));
|
|
g_settings_schema_key_clear (&skey);
|
|
return FALSE;
|
|
}
|
|
|
|
success = g_settings_write_to_backend (settings, &skey, variant);
|
|
g_settings_schema_key_clear (&skey);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* g_settings_get_flags:
|
|
* @settings: a #GSettings object
|
|
* @key: the key to get the value for
|
|
*
|
|
* Gets the value that is stored in @settings for @key and converts it
|
|
* to the flags value that it represents.
|
|
*
|
|
* In order to use this function the type of the value must be an array
|
|
* of strings and it must be marked in the schema file as an flags type.
|
|
*
|
|
* It is a programmer error to give a @key that isn't contained in the
|
|
* schema for @settings or is not marked as a flags type.
|
|
*
|
|
* If the value stored in the configuration database is not a valid
|
|
* value for the flags type then this function will return the default
|
|
* value.
|
|
*
|
|
* Returns: the flags value
|
|
*
|
|
* Since: 2.26
|
|
**/
|
|
guint
|
|
g_settings_get_flags (GSettings *settings,
|
|
const gchar *key)
|
|
{
|
|
GSettingsSchemaKey skey;
|
|
GVariant *value;
|
|
guint result;
|
|
|
|
g_return_val_if_fail (G_IS_SETTINGS (settings), -1);
|
|
g_return_val_if_fail (key != NULL, -1);
|
|
|
|
g_settings_schema_key_init (&skey, settings->priv->schema, key);
|
|
|
|
if (!skey.is_flags)
|
|
{
|
|
g_critical ("g_settings_get_flags() called on key `%s' which is not "
|
|
"associated with a flags type", skey.name);
|
|
g_settings_schema_key_clear (&skey);
|
|
return -1;
|
|
}
|
|
|
|
value = g_settings_read_from_backend (settings, &skey);
|
|
|
|
if (value == NULL)
|
|
value = g_settings_schema_key_get_translated_default (&skey);
|
|
|
|
if (value == NULL)
|
|
value = g_variant_ref (skey.default_value);
|
|
|
|
result = g_settings_schema_key_to_flags (&skey, value);
|
|
g_settings_schema_key_clear (&skey);
|
|
g_variant_unref (value);
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* g_settings_set_flags:
|
|
* @settings: a #GSettings object
|
|
* @key: a key, within @settings
|
|
* @value: a flags value
|
|
*
|
|
* Looks up the flags type nicks for the bits specified by @value, puts
|
|
* them in an array of strings and writes the array to @key, within
|
|
* @settings.
|
|
*
|
|
* It is a programmer error to give a @key that isn't contained in the
|
|
* schema for @settings or is not marked as a flags type, or for @value
|
|
* to contain any bits that are not value for the named type.
|
|
*
|
|
* After performing the write, accessing @key directly with
|
|
* g_settings_get_strv() will return an array of 'nicks'; one for each
|
|
* bit in @value.
|
|
*
|
|
* Returns: %TRUE, if the set succeeds
|
|
**/
|
|
gboolean
|
|
g_settings_set_flags (GSettings *settings,
|
|
const gchar *key,
|
|
guint value)
|
|
{
|
|
GSettingsSchemaKey skey;
|
|
GVariant *variant;
|
|
gboolean success;
|
|
|
|
g_return_val_if_fail (G_IS_SETTINGS (settings), FALSE);
|
|
g_return_val_if_fail (key != NULL, FALSE);
|
|
|
|
g_settings_schema_key_init (&skey, settings->priv->schema, key);
|
|
|
|
if (!skey.is_flags)
|
|
{
|
|
g_critical ("g_settings_set_flags() called on key `%s' which is not "
|
|
"associated with a flags type", skey.name);
|
|
return FALSE;
|
|
}
|
|
|
|
if (!(variant = g_settings_schema_key_from_flags (&skey, value)))
|
|
{
|
|
g_critical ("g_settings_set_flags(): invalid flags value 0x%08x "
|
|
"for key `%s' in schema `%s'. Doing nothing.",
|
|
value, skey.name, g_settings_schema_get_id (skey.schema));
|
|
g_settings_schema_key_clear (&skey);
|
|
return FALSE;
|
|
}
|
|
|
|
success = g_settings_write_to_backend (settings, &skey, variant);
|
|
g_settings_schema_key_clear (&skey);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* g_settings_set_value:
|
|
* @settings: a #GSettings object
|
|
* @key: the name of the key to set
|
|
* @value: a #GVariant of the correct type
|
|
*
|
|
* Sets @key in @settings to @value.
|
|
*
|
|
* It is a programmer error to give a @key that isn't contained in the
|
|
* schema for @settings or for @value to have the incorrect type, per
|
|
* the schema.
|
|
*
|
|
* If @value is floating then this function consumes the reference.
|
|
*
|
|
* Returns: %TRUE if setting the key succeeded,
|
|
* %FALSE if the key was not writable
|
|
*
|
|
* Since: 2.26
|
|
**/
|
|
gboolean
|
|
g_settings_set_value (GSettings *settings,
|
|
const gchar *key,
|
|
GVariant *value)
|
|
{
|
|
GSettingsSchemaKey skey;
|
|
gboolean success;
|
|
|
|
g_return_val_if_fail (G_IS_SETTINGS (settings), FALSE);
|
|
g_return_val_if_fail (key != NULL, FALSE);
|
|
|
|
g_settings_schema_key_init (&skey, settings->priv->schema, key);
|
|
|
|
if (!g_settings_schema_key_type_check (&skey, value))
|
|
{
|
|
g_critical ("g_settings_set_value: key '%s' in '%s' expects type '%s', but a GVariant of type '%s' was given",
|
|
key,
|
|
g_settings_schema_get_id (settings->priv->schema),
|
|
g_variant_type_peek_string (skey.type),
|
|
g_variant_get_type_string (value));
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
if (!g_settings_schema_key_range_check (&skey, value))
|
|
{
|
|
g_warning ("g_settings_set_value: value for key '%s' in schema '%s' "
|
|
"is outside of valid range",
|
|
key,
|
|
g_settings_schema_get_id (settings->priv->schema));
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
success = g_settings_write_to_backend (settings, &skey, value);
|
|
g_settings_schema_key_clear (&skey);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* g_settings_get:
|
|
* @settings: a #GSettings object
|
|
* @key: the key to get the value for
|
|
* @format: a #GVariant format string
|
|
* @...: arguments as per @format
|
|
*
|
|
* Gets the value that is stored at @key in @settings.
|
|
*
|
|
* A convenience function that combines g_settings_get_value() with
|
|
* g_variant_get().
|
|
*
|
|
* It is a programmer error to give a @key that isn't contained in the
|
|
* schema for @settings or for the #GVariantType of @format to mismatch
|
|
* the type given in the schema.
|
|
*
|
|
* Since: 2.26
|
|
*/
|
|
void
|
|
g_settings_get (GSettings *settings,
|
|
const gchar *key,
|
|
const gchar *format,
|
|
...)
|
|
{
|
|
GVariant *value;
|
|
va_list ap;
|
|
|
|
value = g_settings_get_value (settings, key);
|
|
|
|
va_start (ap, format);
|
|
g_variant_get_va (value, format, NULL, &ap);
|
|
va_end (ap);
|
|
|
|
g_variant_unref (value);
|
|
}
|
|
|
|
/**
|
|
* g_settings_set:
|
|
* @settings: a #GSettings object
|
|
* @key: the name of the key to set
|
|
* @format: a #GVariant format string
|
|
* @...: arguments as per @format
|
|
*
|
|
* Sets @key in @settings to @value.
|
|
*
|
|
* A convenience function that combines g_settings_set_value() with
|
|
* g_variant_new().
|
|
*
|
|
* It is a programmer error to give a @key that isn't contained in the
|
|
* schema for @settings or for the #GVariantType of @format to mismatch
|
|
* the type given in the schema.
|
|
*
|
|
* Returns: %TRUE if setting the key succeeded,
|
|
* %FALSE if the key was not writable
|
|
*
|
|
* Since: 2.26
|
|
*/
|
|
gboolean
|
|
g_settings_set (GSettings *settings,
|
|
const gchar *key,
|
|
const gchar *format,
|
|
...)
|
|
{
|
|
GVariant *value;
|
|
va_list ap;
|
|
|
|
va_start (ap, format);
|
|
value = g_variant_new_va (format, NULL, &ap);
|
|
va_end (ap);
|
|
|
|
return g_settings_set_value (settings, key, value);
|
|
}
|
|
|
|
/**
|
|
* g_settings_get_mapped:
|
|
* @settings: a #GSettings object
|
|
* @key: the key to get the value for
|
|
* @mapping: (scope call): the function to map the value in the
|
|
* settings database to the value used by the application
|
|
* @user_data: user data for @mapping
|
|
*
|
|
* Gets the value that is stored at @key in @settings, subject to
|
|
* application-level validation/mapping.
|
|
*
|
|
* You should use this function when the application needs to perform
|
|
* some processing on the value of the key (for example, parsing). The
|
|
* @mapping function performs that processing. If the function
|
|
* indicates that the processing was unsuccessful (due to a parse error,
|
|
* for example) then the mapping is tried again with another value.
|
|
*
|
|
* This allows a robust 'fall back to defaults' behaviour to be
|
|
* implemented somewhat automatically.
|
|
*
|
|
* The first value that is tried is the user's setting for the key. If
|
|
* the mapping function fails to map this value, other values may be
|
|
* tried in an unspecified order (system or site defaults, translated
|
|
* schema default values, untranslated schema default values, etc).
|
|
*
|
|
* If the mapping function fails for all possible values, one additional
|
|
* attempt is made: the mapping function is called with a %NULL value.
|
|
* If the mapping function still indicates failure at this point then
|
|
* the application will be aborted.
|
|
*
|
|
* The result parameter for the @mapping function is pointed to a
|
|
* #gpointer which is initially set to %NULL. The same pointer is given
|
|
* to each invocation of @mapping. The final value of that #gpointer is
|
|
* what is returned by this function. %NULL is valid; it is returned
|
|
* just as any other value would be.
|
|
*
|
|
* Returns: (transfer full): the result, which may be %NULL
|
|
**/
|
|
gpointer
|
|
g_settings_get_mapped (GSettings *settings,
|
|
const gchar *key,
|
|
GSettingsGetMapping mapping,
|
|
gpointer user_data)
|
|
{
|
|
gpointer result = NULL;
|
|
GSettingsSchemaKey skey;
|
|
GVariant *value;
|
|
gboolean okay;
|
|
|
|
g_return_val_if_fail (G_IS_SETTINGS (settings), NULL);
|
|
g_return_val_if_fail (key != NULL, NULL);
|
|
g_return_val_if_fail (mapping != NULL, NULL);
|
|
|
|
g_settings_schema_key_init (&skey, settings->priv->schema, key);
|
|
|
|
if ((value = g_settings_read_from_backend (settings, &skey)))
|
|
{
|
|
okay = mapping (value, &result, user_data);
|
|
g_variant_unref (value);
|
|
if (okay) goto okay;
|
|
}
|
|
|
|
if ((value = g_settings_schema_key_get_translated_default (&skey)))
|
|
{
|
|
okay = mapping (value, &result, user_data);
|
|
g_variant_unref (value);
|
|
if (okay) goto okay;
|
|
}
|
|
|
|
if (mapping (skey.default_value, &result, user_data))
|
|
goto okay;
|
|
|
|
if (!mapping (NULL, &result, user_data))
|
|
g_error ("The mapping function given to g_settings_get_mapped() for key "
|
|
"`%s' in schema `%s' returned FALSE when given a NULL value.",
|
|
key, g_settings_schema_get_id (settings->priv->schema));
|
|
|
|
okay:
|
|
g_settings_schema_key_clear (&skey);
|
|
|
|
return result;
|
|
}
|
|
|
|
/* Convenience API (get, set_string, int, double, boolean, strv) {{{1 */
|
|
/**
|
|
* g_settings_get_string:
|
|
* @settings: a #GSettings object
|
|
* @key: the key to get the value for
|
|
*
|
|
* Gets the value that is stored at @key in @settings.
|
|
*
|
|
* A convenience variant of g_settings_get() for strings.
|
|
*
|
|
* It is a programmer error to give a @key that isn't specified as
|
|
* having a string type in the schema for @settings.
|
|
*
|
|
* Returns: a newly-allocated string
|
|
*
|
|
* Since: 2.26
|
|
*/
|
|
gchar *
|
|
g_settings_get_string (GSettings *settings,
|
|
const gchar *key)
|
|
{
|
|
GVariant *value;
|
|
gchar *result;
|
|
|
|
value = g_settings_get_value (settings, key);
|
|
result = g_variant_dup_string (value, NULL);
|
|
g_variant_unref (value);
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* g_settings_set_string:
|
|
* @settings: a #GSettings object
|
|
* @key: the name of the key to set
|
|
* @value: the value to set it to
|
|
*
|
|
* Sets @key in @settings to @value.
|
|
*
|
|
* A convenience variant of g_settings_set() for strings.
|
|
*
|
|
* It is a programmer error to give a @key that isn't specified as
|
|
* having a string type in the schema for @settings.
|
|
*
|
|
* Returns: %TRUE if setting the key succeeded,
|
|
* %FALSE if the key was not writable
|
|
*
|
|
* Since: 2.26
|
|
*/
|
|
gboolean
|
|
g_settings_set_string (GSettings *settings,
|
|
const gchar *key,
|
|
const gchar *value)
|
|
{
|
|
return g_settings_set_value (settings, key, g_variant_new_string (value));
|
|
}
|
|
|
|
/**
|
|
* g_settings_get_int:
|
|
* @settings: a #GSettings object
|
|
* @key: the key to get the value for
|
|
*
|
|
* Gets the value that is stored at @key in @settings.
|
|
*
|
|
* A convenience variant of g_settings_get() for 32-bit integers.
|
|
*
|
|
* It is a programmer error to give a @key that isn't specified as
|
|
* having a int32 type in the schema for @settings.
|
|
*
|
|
* Returns: an integer
|
|
*
|
|
* Since: 2.26
|
|
*/
|
|
gint
|
|
g_settings_get_int (GSettings *settings,
|
|
const gchar *key)
|
|
{
|
|
GVariant *value;
|
|
gint result;
|
|
|
|
value = g_settings_get_value (settings, key);
|
|
result = g_variant_get_int32 (value);
|
|
g_variant_unref (value);
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* g_settings_set_int:
|
|
* @settings: a #GSettings object
|
|
* @key: the name of the key to set
|
|
* @value: the value to set it to
|
|
*
|
|
* Sets @key in @settings to @value.
|
|
*
|
|
* A convenience variant of g_settings_set() for 32-bit integers.
|
|
*
|
|
* It is a programmer error to give a @key that isn't specified as
|
|
* having a int32 type in the schema for @settings.
|
|
*
|
|
* Returns: %TRUE if setting the key succeeded,
|
|
* %FALSE if the key was not writable
|
|
*
|
|
* Since: 2.26
|
|
*/
|
|
gboolean
|
|
g_settings_set_int (GSettings *settings,
|
|
const gchar *key,
|
|
gint value)
|
|
{
|
|
return g_settings_set_value (settings, key, g_variant_new_int32 (value));
|
|
}
|
|
|
|
/**
|
|
* g_settings_get_uint:
|
|
* @settings: a #GSettings object
|
|
* @key: the key to get the value for
|
|
*
|
|
* Gets the value that is stored at @key in @settings.
|
|
*
|
|
* A convenience variant of g_settings_get() for 32-bit unsigned
|
|
* integers.
|
|
*
|
|
* It is a programmer error to give a @key that isn't specified as
|
|
* having a uint32 type in the schema for @settings.
|
|
*
|
|
* Returns: an unsigned integer
|
|
*
|
|
* Since: 2.30
|
|
*/
|
|
guint
|
|
g_settings_get_uint (GSettings *settings,
|
|
const gchar *key)
|
|
{
|
|
GVariant *value;
|
|
guint result;
|
|
|
|
value = g_settings_get_value (settings, key);
|
|
result = g_variant_get_uint32 (value);
|
|
g_variant_unref (value);
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* g_settings_set_uint:
|
|
* @settings: a #GSettings object
|
|
* @key: the name of the key to set
|
|
* @value: the value to set it to
|
|
*
|
|
* Sets @key in @settings to @value.
|
|
*
|
|
* A convenience variant of g_settings_set() for 32-bit unsigned
|
|
* integers.
|
|
*
|
|
* It is a programmer error to give a @key that isn't specified as
|
|
* having a uint32 type in the schema for @settings.
|
|
*
|
|
* Returns: %TRUE if setting the key succeeded,
|
|
* %FALSE if the key was not writable
|
|
*
|
|
* Since: 2.30
|
|
*/
|
|
gboolean
|
|
g_settings_set_uint (GSettings *settings,
|
|
const gchar *key,
|
|
guint value)
|
|
{
|
|
return g_settings_set_value (settings, key, g_variant_new_uint32 (value));
|
|
}
|
|
|
|
/**
|
|
* g_settings_get_double:
|
|
* @settings: a #GSettings object
|
|
* @key: the key to get the value for
|
|
*
|
|
* Gets the value that is stored at @key in @settings.
|
|
*
|
|
* A convenience variant of g_settings_get() for doubles.
|
|
*
|
|
* It is a programmer error to give a @key that isn't specified as
|
|
* having a 'double' type in the schema for @settings.
|
|
*
|
|
* Returns: a double
|
|
*
|
|
* Since: 2.26
|
|
*/
|
|
gdouble
|
|
g_settings_get_double (GSettings *settings,
|
|
const gchar *key)
|
|
{
|
|
GVariant *value;
|
|
gdouble result;
|
|
|
|
value = g_settings_get_value (settings, key);
|
|
result = g_variant_get_double (value);
|
|
g_variant_unref (value);
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* g_settings_set_double:
|
|
* @settings: a #GSettings object
|
|
* @key: the name of the key to set
|
|
* @value: the value to set it to
|
|
*
|
|
* Sets @key in @settings to @value.
|
|
*
|
|
* A convenience variant of g_settings_set() for doubles.
|
|
*
|
|
* It is a programmer error to give a @key that isn't specified as
|
|
* having a 'double' type in the schema for @settings.
|
|
*
|
|
* Returns: %TRUE if setting the key succeeded,
|
|
* %FALSE if the key was not writable
|
|
*
|
|
* Since: 2.26
|
|
*/
|
|
gboolean
|
|
g_settings_set_double (GSettings *settings,
|
|
const gchar *key,
|
|
gdouble value)
|
|
{
|
|
return g_settings_set_value (settings, key, g_variant_new_double (value));
|
|
}
|
|
|
|
/**
|
|
* g_settings_get_boolean:
|
|
* @settings: a #GSettings object
|
|
* @key: the key to get the value for
|
|
*
|
|
* Gets the value that is stored at @key in @settings.
|
|
*
|
|
* A convenience variant of g_settings_get() for booleans.
|
|
*
|
|
* It is a programmer error to give a @key that isn't specified as
|
|
* having a boolean type in the schema for @settings.
|
|
*
|
|
* Returns: a boolean
|
|
*
|
|
* Since: 2.26
|
|
*/
|
|
gboolean
|
|
g_settings_get_boolean (GSettings *settings,
|
|
const gchar *key)
|
|
{
|
|
GVariant *value;
|
|
gboolean result;
|
|
|
|
value = g_settings_get_value (settings, key);
|
|
result = g_variant_get_boolean (value);
|
|
g_variant_unref (value);
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* g_settings_set_boolean:
|
|
* @settings: a #GSettings object
|
|
* @key: the name of the key to set
|
|
* @value: the value to set it to
|
|
*
|
|
* Sets @key in @settings to @value.
|
|
*
|
|
* A convenience variant of g_settings_set() for booleans.
|
|
*
|
|
* It is a programmer error to give a @key that isn't specified as
|
|
* having a boolean type in the schema for @settings.
|
|
*
|
|
* Returns: %TRUE if setting the key succeeded,
|
|
* %FALSE if the key was not writable
|
|
*
|
|
* Since: 2.26
|
|
*/
|
|
gboolean
|
|
g_settings_set_boolean (GSettings *settings,
|
|
const gchar *key,
|
|
gboolean value)
|
|
{
|
|
return g_settings_set_value (settings, key, g_variant_new_boolean (value));
|
|
}
|
|
|
|
/**
|
|
* g_settings_get_strv:
|
|
* @settings: a #GSettings object
|
|
* @key: the key to get the value for
|
|
*
|
|
* A convenience variant of g_settings_get() for string arrays.
|
|
*
|
|
* It is a programmer error to give a @key that isn't specified as
|
|
* having an array of strings type in the schema for @settings.
|
|
*
|
|
* Returns: (array zero-terminated=1) (transfer full): a
|
|
* newly-allocated, %NULL-terminated array of strings, the value that
|
|
* is stored at @key in @settings.
|
|
*
|
|
* Since: 2.26
|
|
*/
|
|
gchar **
|
|
g_settings_get_strv (GSettings *settings,
|
|
const gchar *key)
|
|
{
|
|
GVariant *value;
|
|
gchar **result;
|
|
|
|
value = g_settings_get_value (settings, key);
|
|
result = g_variant_dup_strv (value, NULL);
|
|
g_variant_unref (value);
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* g_settings_set_strv:
|
|
* @settings: a #GSettings object
|
|
* @key: the name of the key to set
|
|
* @value: (allow-none) (array zero-terminated=1): the value to set it to, or %NULL
|
|
*
|
|
* Sets @key in @settings to @value.
|
|
*
|
|
* A convenience variant of g_settings_set() for string arrays. If
|
|
* @value is %NULL, then @key is set to be the empty array.
|
|
*
|
|
* It is a programmer error to give a @key that isn't specified as
|
|
* having an array of strings type in the schema for @settings.
|
|
*
|
|
* Returns: %TRUE if setting the key succeeded,
|
|
* %FALSE if the key was not writable
|
|
*
|
|
* Since: 2.26
|
|
*/
|
|
gboolean
|
|
g_settings_set_strv (GSettings *settings,
|
|
const gchar *key,
|
|
const gchar * const *value)
|
|
{
|
|
GVariant *array;
|
|
|
|
if (value != NULL)
|
|
array = g_variant_new_strv (value, -1);
|
|
else
|
|
array = g_variant_new_strv (NULL, 0);
|
|
|
|
return g_settings_set_value (settings, key, array);
|
|
}
|
|
|
|
/* Delayed apply (delay, apply, revert, get_has_unapplied) {{{1 */
|
|
/**
|
|
* g_settings_delay:
|
|
* @settings: a #GSettings object
|
|
*
|
|
* Changes the #GSettings object into 'delay-apply' mode. In this
|
|
* mode, changes to @settings are not immediately propagated to the
|
|
* backend, but kept locally until g_settings_apply() is called.
|
|
*
|
|
* Since: 2.26
|
|
*/
|
|
void
|
|
g_settings_delay (GSettings *settings)
|
|
{
|
|
g_return_if_fail (G_IS_SETTINGS (settings));
|
|
|
|
if (settings->priv->delayed)
|
|
return;
|
|
|
|
settings->priv->delayed =
|
|
g_delayed_settings_backend_new (settings->priv->backend,
|
|
settings,
|
|
settings->priv->main_context);
|
|
g_settings_backend_unwatch (settings->priv->backend, G_OBJECT (settings));
|
|
g_object_unref (settings->priv->backend);
|
|
|
|
settings->priv->backend = G_SETTINGS_BACKEND (settings->priv->delayed);
|
|
g_settings_backend_watch (settings->priv->backend,
|
|
&listener_vtable, G_OBJECT (settings),
|
|
settings->priv->main_context);
|
|
|
|
g_object_notify (G_OBJECT (settings), "delay-apply");
|
|
}
|
|
|
|
/**
|
|
* g_settings_apply:
|
|
* @settings: a #GSettings instance
|
|
*
|
|
* Applies any changes that have been made to the settings. This
|
|
* function does nothing unless @settings is in 'delay-apply' mode;
|
|
* see g_settings_delay(). In the normal case settings are always
|
|
* applied immediately.
|
|
**/
|
|
void
|
|
g_settings_apply (GSettings *settings)
|
|
{
|
|
if (settings->priv->delayed)
|
|
{
|
|
GDelayedSettingsBackend *delayed;
|
|
|
|
delayed = G_DELAYED_SETTINGS_BACKEND (settings->priv->backend);
|
|
g_delayed_settings_backend_apply (delayed);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* g_settings_revert:
|
|
* @settings: a #GSettings instance
|
|
*
|
|
* Reverts all non-applied changes to the settings. This function
|
|
* does nothing unless @settings is in 'delay-apply' mode; see
|
|
* g_settings_delay(). In the normal case settings are always applied
|
|
* immediately.
|
|
*
|
|
* Change notifications will be emitted for affected keys.
|
|
**/
|
|
void
|
|
g_settings_revert (GSettings *settings)
|
|
{
|
|
if (settings->priv->delayed)
|
|
{
|
|
GDelayedSettingsBackend *delayed;
|
|
|
|
delayed = G_DELAYED_SETTINGS_BACKEND (settings->priv->backend);
|
|
g_delayed_settings_backend_revert (delayed);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* g_settings_get_has_unapplied:
|
|
* @settings: a #GSettings object
|
|
*
|
|
* Returns whether the #GSettings object has any unapplied
|
|
* changes. This can only be the case if it is in 'delayed-apply' mode.
|
|
*
|
|
* Returns: %TRUE if @settings has unapplied changes
|
|
*
|
|
* Since: 2.26
|
|
*/
|
|
gboolean
|
|
g_settings_get_has_unapplied (GSettings *settings)
|
|
{
|
|
g_return_val_if_fail (G_IS_SETTINGS (settings), FALSE);
|
|
|
|
return settings->priv->delayed &&
|
|
g_delayed_settings_backend_get_has_unapplied (
|
|
G_DELAYED_SETTINGS_BACKEND (settings->priv->backend));
|
|
}
|
|
|
|
/* Extra API (reset, sync, get_child, is_writable, list_*, ranges) {{{1 */
|
|
/**
|
|
* g_settings_reset:
|
|
* @settings: a #GSettings object
|
|
* @key: the name of a key
|
|
*
|
|
* Resets @key to its default value.
|
|
*
|
|
* This call resets the key, as much as possible, to its default value.
|
|
* That might the value specified in the schema or the one set by the
|
|
* administrator.
|
|
**/
|
|
void
|
|
g_settings_reset (GSettings *settings,
|
|
const gchar *key)
|
|
{
|
|
gchar *path;
|
|
|
|
path = g_strconcat (settings->priv->path, key, NULL);
|
|
g_settings_backend_reset (settings->priv->backend, path, NULL);
|
|
g_free (path);
|
|
}
|
|
|
|
/**
|
|
* g_settings_sync:
|
|
*
|
|
* Ensures that all pending operations for the given are complete for
|
|
* the default backend.
|
|
*
|
|
* Writes made to a #GSettings are handled asynchronously. For this
|
|
* reason, it is very unlikely that the changes have it to disk by the
|
|
* time g_settings_set() returns.
|
|
*
|
|
* This call will block until all of the writes have made it to the
|
|
* backend. Since the mainloop is not running, no change notifications
|
|
* will be dispatched during this call (but some may be queued by the
|
|
* time the call is done).
|
|
**/
|
|
void
|
|
g_settings_sync (void)
|
|
{
|
|
g_settings_backend_sync_default ();
|
|
}
|
|
|
|
/**
|
|
* g_settings_is_writable:
|
|
* @settings: a #GSettings object
|
|
* @name: the name of a key
|
|
*
|
|
* Finds out if a key can be written or not
|
|
*
|
|
* Returns: %TRUE if the key @name is writable
|
|
*
|
|
* Since: 2.26
|
|
*/
|
|
gboolean
|
|
g_settings_is_writable (GSettings *settings,
|
|
const gchar *name)
|
|
{
|
|
gboolean writable;
|
|
gchar *path;
|
|
|
|
g_return_val_if_fail (G_IS_SETTINGS (settings), FALSE);
|
|
|
|
path = g_strconcat (settings->priv->path, name, NULL);
|
|
writable = g_settings_backend_get_writable (settings->priv->backend, path);
|
|
g_free (path);
|
|
|
|
return writable;
|
|
}
|
|
|
|
/**
|
|
* g_settings_get_child:
|
|
* @settings: a #GSettings object
|
|
* @name: the name of the 'child' schema
|
|
*
|
|
* Creates a 'child' settings object which has a base path of
|
|
* <replaceable>base-path</replaceable>/@name, where
|
|
* <replaceable>base-path</replaceable> is the base path of @settings.
|
|
*
|
|
* The schema for the child settings object must have been declared
|
|
* in the schema of @settings using a <tag class="starttag">child</tag> element.
|
|
*
|
|
* Returns: (transfer full): a 'child' settings object
|
|
*
|
|
* Since: 2.26
|
|
*/
|
|
GSettings *
|
|
g_settings_get_child (GSettings *settings,
|
|
const gchar *name)
|
|
{
|
|
const gchar *child_schema;
|
|
gchar *child_path;
|
|
gchar *child_name;
|
|
GSettings *child;
|
|
|
|
g_return_val_if_fail (G_IS_SETTINGS (settings), NULL);
|
|
|
|
child_name = g_strconcat (name, "/", NULL);
|
|
child_schema = g_settings_schema_get_string (settings->priv->schema,
|
|
child_name);
|
|
if (child_schema == NULL)
|
|
g_error ("Schema '%s' has no child '%s'",
|
|
g_settings_schema_get_id (settings->priv->schema), name);
|
|
|
|
child_path = g_strconcat (settings->priv->path, child_name, NULL);
|
|
child = g_object_new (G_TYPE_SETTINGS,
|
|
"schema-id", child_schema,
|
|
"path", child_path,
|
|
NULL);
|
|
g_free (child_path);
|
|
g_free (child_name);
|
|
|
|
return child;
|
|
}
|
|
|
|
/**
|
|
* g_settings_list_keys:
|
|
* @settings: a #GSettings object
|
|
*
|
|
* Introspects the list of keys on @settings.
|
|
*
|
|
* You should probably not be calling this function from "normal" code
|
|
* (since you should already know what keys are in your schema). This
|
|
* function is intended for introspection reasons.
|
|
*
|
|
* You should free the return value with g_strfreev() when you are done
|
|
* with it.
|
|
*
|
|
* Returns: (transfer full) (element-type utf8): a list of the keys on @settings
|
|
*/
|
|
gchar **
|
|
g_settings_list_keys (GSettings *settings)
|
|
{
|
|
const GQuark *keys;
|
|
gchar **strv;
|
|
gint n_keys;
|
|
gint i, j;
|
|
|
|
keys = g_settings_schema_list (settings->priv->schema, &n_keys);
|
|
strv = g_new (gchar *, n_keys + 1);
|
|
for (i = j = 0; i < n_keys; i++)
|
|
{
|
|
const gchar *key = g_quark_to_string (keys[i]);
|
|
|
|
if (!g_str_has_suffix (key, "/"))
|
|
strv[j++] = g_strdup (key);
|
|
}
|
|
strv[j] = NULL;
|
|
|
|
return strv;
|
|
}
|
|
|
|
/**
|
|
* g_settings_list_children:
|
|
* @settings: a #GSettings object
|
|
*
|
|
* Gets the list of children on @settings.
|
|
*
|
|
* The list is exactly the list of strings for which it is not an error
|
|
* to call g_settings_get_child().
|
|
*
|
|
* For GSettings objects that are lists, this value can change at any
|
|
* time and you should connect to the "children-changed" signal to watch
|
|
* for those changes. Note that there is a race condition here: you may
|
|
* request a child after listing it only for it to have been destroyed
|
|
* in the meantime. For this reason, g_settings_get_child() may return
|
|
* %NULL even for a child that was listed by this function.
|
|
*
|
|
* For GSettings objects that are not lists, you should probably not be
|
|
* calling this function from "normal" code (since you should already
|
|
* know what children are in your schema). This function may still be
|
|
* useful there for introspection reasons, however.
|
|
*
|
|
* You should free the return value with g_strfreev() when you are done
|
|
* with it.
|
|
*
|
|
* Returns: (transfer full) (element-type utf8): a list of the children on @settings
|
|
*/
|
|
gchar **
|
|
g_settings_list_children (GSettings *settings)
|
|
{
|
|
const GQuark *keys;
|
|
gchar **strv;
|
|
gint n_keys;
|
|
gint i, j;
|
|
|
|
keys = g_settings_schema_list (settings->priv->schema, &n_keys);
|
|
strv = g_new (gchar *, n_keys + 1);
|
|
for (i = j = 0; i < n_keys; i++)
|
|
{
|
|
const gchar *key = g_quark_to_string (keys[i]);
|
|
|
|
if (g_str_has_suffix (key, "/"))
|
|
{
|
|
gint length = strlen (key);
|
|
|
|
strv[j] = g_memdup (key, length);
|
|
strv[j][length - 1] = '\0';
|
|
j++;
|
|
}
|
|
}
|
|
strv[j] = NULL;
|
|
|
|
return strv;
|
|
}
|
|
|
|
/**
|
|
* g_settings_get_range:
|
|
* @settings: a #GSettings
|
|
* @key: the key to query the range of
|
|
*
|
|
* Queries the range of a key.
|
|
*
|
|
* This function will return a #GVariant that fully describes the range
|
|
* of values that are valid for @key.
|
|
*
|
|
* The type of #GVariant returned is <literal>(sv)</literal>. The
|
|
* string describes the type of range restriction in effect. The type
|
|
* and meaning of the value contained in the variant depends on the
|
|
* string.
|
|
*
|
|
* If the string is <literal>'type'</literal> then the variant contains
|
|
* an empty array. The element type of that empty array is the expected
|
|
* type of value and all values of that type are valid.
|
|
*
|
|
* If the string is <literal>'enum'</literal> then the variant contains
|
|
* an array enumerating the possible values. Each item in the array is
|
|
* a possible valid value and no other values are valid.
|
|
*
|
|
* If the string is <literal>'flags'</literal> then the variant contains
|
|
* an array. Each item in the array is a value that may appear zero or
|
|
* one times in an array to be used as the value for this key. For
|
|
* example, if the variant contained the array <literal>['x',
|
|
* 'y']</literal> then the valid values for the key would be
|
|
* <literal>[]</literal>, <literal>['x']</literal>,
|
|
* <literal>['y']</literal>, <literal>['x', 'y']</literal> and
|
|
* <literal>['y', 'x']</literal>.
|
|
*
|
|
* Finally, if the string is <literal>'range'</literal> then the variant
|
|
* contains a pair of like-typed values -- the minimum and maximum
|
|
* permissible values for this key.
|
|
*
|
|
* This information should not be used by normal programs. It is
|
|
* considered to be a hint for introspection purposes. Normal programs
|
|
* should already know what is permitted by their own schema. The
|
|
* format may change in any way in the future -- but particularly, new
|
|
* forms may be added to the possibilities described above.
|
|
*
|
|
* It is a programmer error to give a @key that isn't contained in the
|
|
* schema for @settings.
|
|
*
|
|
* You should free the returned value with g_variant_unref() when it is
|
|
* no longer needed.
|
|
*
|
|
* Returns: a #GVariant describing the range
|
|
*
|
|
* Since: 2.28
|
|
**/
|
|
GVariant *
|
|
g_settings_get_range (GSettings *settings,
|
|
const gchar *key)
|
|
{
|
|
GSettingsSchemaKey skey;
|
|
const gchar *type;
|
|
GVariant *range;
|
|
|
|
g_settings_schema_key_init (&skey, settings->priv->schema, key);
|
|
|
|
if (skey.minimum)
|
|
{
|
|
range = g_variant_new ("(**)", skey.minimum, skey.maximum);
|
|
type = "range";
|
|
}
|
|
else if (skey.strinfo)
|
|
{
|
|
range = strinfo_enumerate (skey.strinfo, skey.strinfo_length);
|
|
type = skey.is_flags ? "flags" : "enum";
|
|
}
|
|
else
|
|
{
|
|
range = g_variant_new_array (skey.type, NULL, 0);
|
|
type = "type";
|
|
}
|
|
|
|
g_settings_schema_key_clear (&skey);
|
|
|
|
return g_variant_ref_sink (g_variant_new ("(sv)", type, range));
|
|
}
|
|
|
|
/**
|
|
* g_settings_range_check:
|
|
* @settings: a #GSettings
|
|
* @key: the key to check
|
|
* @value: the value to check
|
|
*
|
|
* Checks if the given @value is of the correct type and within the
|
|
* permitted range for @key.
|
|
*
|
|
* This API is not intended to be used by normal programs -- they should
|
|
* already know what is permitted by their own schemas. This API is
|
|
* meant to be used by programs such as editors or commandline tools.
|
|
*
|
|
* It is a programmer error to give a @key that isn't contained in the
|
|
* schema for @settings.
|
|
*
|
|
* Returns: %TRUE if @value is valid for @key
|
|
*
|
|
* Since: 2.28
|
|
**/
|
|
gboolean
|
|
g_settings_range_check (GSettings *settings,
|
|
const gchar *key,
|
|
GVariant *value)
|
|
{
|
|
GSettingsSchemaKey skey;
|
|
gboolean good;
|
|
|
|
g_settings_schema_key_init (&skey, settings->priv->schema, key);
|
|
good = g_settings_schema_key_type_check (&skey, value) &&
|
|
g_settings_schema_key_range_check (&skey, value);
|
|
g_settings_schema_key_clear (&skey);
|
|
|
|
return good;
|
|
}
|
|
|
|
/* Binding {{{1 */
|
|
typedef struct
|
|
{
|
|
GSettingsSchemaKey key;
|
|
GSettings *settings;
|
|
GObject *object;
|
|
|
|
GSettingsBindGetMapping get_mapping;
|
|
GSettingsBindSetMapping set_mapping;
|
|
gpointer user_data;
|
|
GDestroyNotify destroy;
|
|
|
|
guint writable_handler_id;
|
|
guint property_handler_id;
|
|
const GParamSpec *property;
|
|
guint key_handler_id;
|
|
|
|
/* prevent recursion */
|
|
gboolean running;
|
|
} GSettingsBinding;
|
|
|
|
static void
|
|
g_settings_binding_free (gpointer data)
|
|
{
|
|
GSettingsBinding *binding = data;
|
|
|
|
g_assert (!binding->running);
|
|
|
|
if (binding->writable_handler_id)
|
|
g_signal_handler_disconnect (binding->settings,
|
|
binding->writable_handler_id);
|
|
|
|
if (binding->key_handler_id)
|
|
g_signal_handler_disconnect (binding->settings,
|
|
binding->key_handler_id);
|
|
|
|
if (g_signal_handler_is_connected (binding->object,
|
|
binding->property_handler_id))
|
|
g_signal_handler_disconnect (binding->object,
|
|
binding->property_handler_id);
|
|
|
|
g_settings_schema_key_clear (&binding->key);
|
|
|
|
if (binding->destroy)
|
|
binding->destroy (binding->user_data);
|
|
|
|
g_object_unref (binding->settings);
|
|
|
|
g_slice_free (GSettingsBinding, binding);
|
|
}
|
|
|
|
static GQuark
|
|
g_settings_binding_quark (const char *property)
|
|
{
|
|
GQuark quark;
|
|
gchar *tmp;
|
|
|
|
tmp = g_strdup_printf ("gsettingsbinding-%s", property);
|
|
quark = g_quark_from_string (tmp);
|
|
g_free (tmp);
|
|
|
|
return quark;
|
|
}
|
|
|
|
static void
|
|
g_settings_binding_key_changed (GSettings *settings,
|
|
const gchar *key,
|
|
gpointer user_data)
|
|
{
|
|
GSettingsBinding *binding = user_data;
|
|
GValue value = G_VALUE_INIT;
|
|
GVariant *variant;
|
|
|
|
g_assert (settings == binding->settings);
|
|
g_assert (key == binding->key.name);
|
|
|
|
if (binding->running)
|
|
return;
|
|
|
|
binding->running = TRUE;
|
|
|
|
g_value_init (&value, binding->property->value_type);
|
|
|
|
variant = g_settings_read_from_backend (binding->settings, &binding->key);
|
|
if (variant && !binding->get_mapping (&value, variant, binding->user_data))
|
|
{
|
|
/* silently ignore errors in the user's config database */
|
|
g_variant_unref (variant);
|
|
variant = NULL;
|
|
}
|
|
|
|
if (variant == NULL)
|
|
{
|
|
variant = g_settings_schema_key_get_translated_default (&binding->key);
|
|
if (variant &&
|
|
!binding->get_mapping (&value, variant, binding->user_data))
|
|
{
|
|
/* flag translation errors with a warning */
|
|
g_warning ("Translated default `%s' for key `%s' in schema `%s' "
|
|
"was rejected by the binding mapping function",
|
|
binding->key.unparsed, binding->key.name,
|
|
g_settings_schema_get_id (binding->key.schema));
|
|
g_variant_unref (variant);
|
|
variant = NULL;
|
|
}
|
|
}
|
|
|
|
if (variant == NULL)
|
|
{
|
|
variant = g_variant_ref (binding->key.default_value);
|
|
if (!binding->get_mapping (&value, variant, binding->user_data))
|
|
g_error ("The schema default value for key `%s' in schema `%s' "
|
|
"was rejected by the binding mapping function.",
|
|
binding->key.name, g_settings_schema_get_id (binding->key.schema));
|
|
}
|
|
|
|
g_object_set_property (binding->object, binding->property->name, &value);
|
|
g_variant_unref (variant);
|
|
g_value_unset (&value);
|
|
|
|
binding->running = FALSE;
|
|
}
|
|
|
|
static void
|
|
g_settings_binding_property_changed (GObject *object,
|
|
const GParamSpec *pspec,
|
|
gpointer user_data)
|
|
{
|
|
GSettingsBinding *binding = user_data;
|
|
GValue value = G_VALUE_INIT;
|
|
GVariant *variant;
|
|
|
|
g_assert (object == binding->object);
|
|
g_assert (pspec == binding->property);
|
|
|
|
if (binding->running)
|
|
return;
|
|
|
|
binding->running = TRUE;
|
|
|
|
g_value_init (&value, pspec->value_type);
|
|
g_object_get_property (object, pspec->name, &value);
|
|
if ((variant = binding->set_mapping (&value, binding->key.type,
|
|
binding->user_data)))
|
|
{
|
|
g_variant_take_ref (variant);
|
|
|
|
if (!g_settings_schema_key_type_check (&binding->key, variant))
|
|
{
|
|
g_critical ("binding mapping function for key `%s' returned "
|
|
"GVariant of type `%s' when type `%s' was requested",
|
|
binding->key.name, g_variant_get_type_string (variant),
|
|
g_variant_type_dup_string (binding->key.type));
|
|
return;
|
|
}
|
|
|
|
if (!g_settings_schema_key_range_check (&binding->key, variant))
|
|
{
|
|
g_critical ("GObject property `%s' on a `%s' object is out of "
|
|
"schema-specified range for key `%s' of `%s': %s",
|
|
binding->property->name, g_type_name (binding->property->owner_type),
|
|
binding->key.name, g_settings_schema_get_id (binding->key.schema),
|
|
g_variant_print (variant, TRUE));
|
|
return;
|
|
}
|
|
|
|
g_settings_write_to_backend (binding->settings, &binding->key, variant);
|
|
g_variant_unref (variant);
|
|
}
|
|
g_value_unset (&value);
|
|
|
|
binding->running = FALSE;
|
|
}
|
|
|
|
static gboolean
|
|
g_settings_bind_invert_boolean_get_mapping (GValue *value,
|
|
GVariant *variant,
|
|
gpointer user_data)
|
|
{
|
|
g_value_set_boolean (value, !g_variant_get_boolean (variant));
|
|
return TRUE;
|
|
}
|
|
|
|
static GVariant *
|
|
g_settings_bind_invert_boolean_set_mapping (const GValue *value,
|
|
const GVariantType *expected_type,
|
|
gpointer user_data)
|
|
{
|
|
return g_variant_new_boolean (!g_value_get_boolean (value));
|
|
}
|
|
|
|
/**
|
|
* g_settings_bind:
|
|
* @settings: a #GSettings object
|
|
* @key: the key to bind
|
|
* @object: (type GObject.Object): a #GObject
|
|
* @property: the name of the property to bind
|
|
* @flags: flags for the binding
|
|
*
|
|
* Create a binding between the @key in the @settings object
|
|
* and the property @property of @object.
|
|
*
|
|
* The binding uses the default GIO mapping functions to map
|
|
* between the settings and property values. These functions
|
|
* handle booleans, numeric types and string types in a
|
|
* straightforward way. Use g_settings_bind_with_mapping() if
|
|
* you need a custom mapping, or map between types that are not
|
|
* supported by the default mapping functions.
|
|
*
|
|
* Unless the @flags include %G_SETTINGS_BIND_NO_SENSITIVITY, this
|
|
* function also establishes a binding between the writability of
|
|
* @key and the "sensitive" property of @object (if @object has
|
|
* a boolean property by that name). See g_settings_bind_writable()
|
|
* for more details about writable bindings.
|
|
*
|
|
* Note that the lifecycle of the binding is tied to the object,
|
|
* and that you can have only one binding per object property.
|
|
* If you bind the same property twice on the same object, the second
|
|
* binding overrides the first one.
|
|
*
|
|
* Since: 2.26
|
|
*/
|
|
void
|
|
g_settings_bind (GSettings *settings,
|
|
const gchar *key,
|
|
gpointer object,
|
|
const gchar *property,
|
|
GSettingsBindFlags flags)
|
|
{
|
|
GSettingsBindGetMapping get_mapping = NULL;
|
|
GSettingsBindSetMapping set_mapping = NULL;
|
|
|
|
if (flags & G_SETTINGS_BIND_INVERT_BOOLEAN)
|
|
{
|
|
get_mapping = g_settings_bind_invert_boolean_get_mapping;
|
|
set_mapping = g_settings_bind_invert_boolean_set_mapping;
|
|
|
|
/* can't pass this flag to g_settings_bind_with_mapping() */
|
|
flags &= ~G_SETTINGS_BIND_INVERT_BOOLEAN;
|
|
}
|
|
|
|
g_settings_bind_with_mapping (settings, key, object, property, flags,
|
|
get_mapping, set_mapping, NULL, NULL);
|
|
}
|
|
|
|
/**
|
|
* g_settings_bind_with_mapping: (skip)
|
|
* @settings: a #GSettings object
|
|
* @key: the key to bind
|
|
* @object: (type GObject.Object): a #GObject
|
|
* @property: the name of the property to bind
|
|
* @flags: flags for the binding
|
|
* @get_mapping: a function that gets called to convert values
|
|
* from @settings to @object, or %NULL to use the default GIO mapping
|
|
* @set_mapping: a function that gets called to convert values
|
|
* from @object to @settings, or %NULL to use the default GIO mapping
|
|
* @user_data: data that gets passed to @get_mapping and @set_mapping
|
|
* @destroy: #GDestroyNotify function for @user_data
|
|
*
|
|
* Create a binding between the @key in the @settings object
|
|
* and the property @property of @object.
|
|
*
|
|
* The binding uses the provided mapping functions to map between
|
|
* settings and property values.
|
|
*
|
|
* Note that the lifecycle of the binding is tied to the object,
|
|
* and that you can have only one binding per object property.
|
|
* If you bind the same property twice on the same object, the second
|
|
* binding overrides the first one.
|
|
*
|
|
* Since: 2.26
|
|
*/
|
|
void
|
|
g_settings_bind_with_mapping (GSettings *settings,
|
|
const gchar *key,
|
|
gpointer object,
|
|
const gchar *property,
|
|
GSettingsBindFlags flags,
|
|
GSettingsBindGetMapping get_mapping,
|
|
GSettingsBindSetMapping set_mapping,
|
|
gpointer user_data,
|
|
GDestroyNotify destroy)
|
|
{
|
|
GSettingsBinding *binding;
|
|
GObjectClass *objectclass;
|
|
gchar *detailed_signal;
|
|
GQuark binding_quark;
|
|
|
|
g_return_if_fail (G_IS_SETTINGS (settings));
|
|
g_return_if_fail (key != NULL);
|
|
g_return_if_fail (G_IS_OBJECT (object));
|
|
g_return_if_fail (property != NULL);
|
|
g_return_if_fail (~flags & G_SETTINGS_BIND_INVERT_BOOLEAN);
|
|
|
|
objectclass = G_OBJECT_GET_CLASS (object);
|
|
|
|
binding = g_slice_new0 (GSettingsBinding);
|
|
g_settings_schema_key_init (&binding->key, settings->priv->schema, key);
|
|
binding->settings = g_object_ref (settings);
|
|
binding->object = object;
|
|
binding->property = g_object_class_find_property (objectclass, property);
|
|
binding->user_data = user_data;
|
|
binding->destroy = destroy;
|
|
binding->get_mapping = get_mapping ? get_mapping : g_settings_get_mapping;
|
|
binding->set_mapping = set_mapping ? set_mapping : g_settings_set_mapping;
|
|
|
|
if (!(flags & (G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET)))
|
|
flags |= G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET;
|
|
|
|
if (binding->property == NULL)
|
|
{
|
|
g_critical ("g_settings_bind: no property '%s' on class '%s'",
|
|
property, G_OBJECT_TYPE_NAME (object));
|
|
return;
|
|
}
|
|
|
|
if ((flags & G_SETTINGS_BIND_GET) &&
|
|
(binding->property->flags & G_PARAM_WRITABLE) == 0)
|
|
{
|
|
g_critical ("g_settings_bind: property '%s' on class '%s' is not "
|
|
"writable", property, G_OBJECT_TYPE_NAME (object));
|
|
return;
|
|
}
|
|
if ((flags & G_SETTINGS_BIND_SET) &&
|
|
(binding->property->flags & G_PARAM_READABLE) == 0)
|
|
{
|
|
g_critical ("g_settings_bind: property '%s' on class '%s' is not "
|
|
"readable", property, G_OBJECT_TYPE_NAME (object));
|
|
return;
|
|
}
|
|
|
|
if (get_mapping == g_settings_bind_invert_boolean_get_mapping)
|
|
{
|
|
/* g_settings_bind_invert_boolean_get_mapping() is a private
|
|
* function, so if we are here it means that g_settings_bind() was
|
|
* called with G_SETTINGS_BIND_INVERT_BOOLEAN.
|
|
*
|
|
* Ensure that both sides are boolean.
|
|
*/
|
|
|
|
if (binding->property->value_type != G_TYPE_BOOLEAN)
|
|
{
|
|
g_critical ("g_settings_bind: G_SETTINGS_BIND_INVERT_BOOLEAN "
|
|
"was specified, but property `%s' on type `%s' has "
|
|
"type `%s'", property, G_OBJECT_TYPE_NAME (object),
|
|
g_type_name ((binding->property->value_type)));
|
|
return;
|
|
}
|
|
|
|
if (!g_variant_type_equal (binding->key.type, G_VARIANT_TYPE_BOOLEAN))
|
|
{
|
|
g_critical ("g_settings_bind: G_SETTINGS_BIND_INVERT_BOOLEAN "
|
|
"was specified, but key `%s' on schema `%s' has "
|
|
"type `%s'", key, g_settings_schema_get_id (settings->priv->schema),
|
|
g_variant_type_dup_string (binding->key.type));
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
else if (((get_mapping == NULL && (flags & G_SETTINGS_BIND_GET)) ||
|
|
(set_mapping == NULL && (flags & G_SETTINGS_BIND_SET))) &&
|
|
!g_settings_mapping_is_compatible (binding->property->value_type,
|
|
binding->key.type))
|
|
{
|
|
g_critical ("g_settings_bind: property '%s' on class '%s' has type "
|
|
"'%s' which is not compatible with type '%s' of key '%s' "
|
|
"on schema '%s'", property, G_OBJECT_TYPE_NAME (object),
|
|
g_type_name (binding->property->value_type),
|
|
g_variant_type_dup_string (binding->key.type), key,
|
|
g_settings_schema_get_id (settings->priv->schema));
|
|
return;
|
|
}
|
|
|
|
if ((flags & G_SETTINGS_BIND_SET) &&
|
|
(~flags & G_SETTINGS_BIND_NO_SENSITIVITY))
|
|
{
|
|
GParamSpec *sensitive;
|
|
|
|
sensitive = g_object_class_find_property (objectclass, "sensitive");
|
|
|
|
if (sensitive && sensitive->value_type == G_TYPE_BOOLEAN &&
|
|
(sensitive->flags & G_PARAM_WRITABLE))
|
|
g_settings_bind_writable (settings, binding->key.name, object, "sensitive", FALSE);
|
|
}
|
|
|
|
if (flags & G_SETTINGS_BIND_SET)
|
|
{
|
|
detailed_signal = g_strdup_printf ("notify::%s", property);
|
|
binding->property_handler_id =
|
|
g_signal_connect (object, detailed_signal,
|
|
G_CALLBACK (g_settings_binding_property_changed),
|
|
binding);
|
|
g_free (detailed_signal);
|
|
|
|
if (~flags & G_SETTINGS_BIND_GET)
|
|
g_settings_binding_property_changed (object,
|
|
binding->property,
|
|
binding);
|
|
}
|
|
|
|
if (flags & G_SETTINGS_BIND_GET)
|
|
{
|
|
if (~flags & G_SETTINGS_BIND_GET_NO_CHANGES)
|
|
{
|
|
detailed_signal = g_strdup_printf ("changed::%s", key);
|
|
binding->key_handler_id =
|
|
g_signal_connect (settings, detailed_signal,
|
|
G_CALLBACK (g_settings_binding_key_changed),
|
|
binding);
|
|
g_free (detailed_signal);
|
|
}
|
|
|
|
g_settings_binding_key_changed (settings, binding->key.name, binding);
|
|
}
|
|
|
|
binding_quark = g_settings_binding_quark (property);
|
|
g_object_set_qdata_full (object, binding_quark,
|
|
binding, g_settings_binding_free);
|
|
}
|
|
|
|
/* Writability binding {{{1 */
|
|
typedef struct
|
|
{
|
|
GSettings *settings;
|
|
gpointer object;
|
|
const gchar *key;
|
|
const gchar *property;
|
|
gboolean inverted;
|
|
gulong handler_id;
|
|
} GSettingsWritableBinding;
|
|
|
|
static void
|
|
g_settings_writable_binding_free (gpointer data)
|
|
{
|
|
GSettingsWritableBinding *binding = data;
|
|
|
|
g_signal_handler_disconnect (binding->settings, binding->handler_id);
|
|
g_object_unref (binding->settings);
|
|
g_slice_free (GSettingsWritableBinding, binding);
|
|
}
|
|
|
|
static void
|
|
g_settings_binding_writable_changed (GSettings *settings,
|
|
const gchar *key,
|
|
gpointer user_data)
|
|
{
|
|
GSettingsWritableBinding *binding = user_data;
|
|
gboolean writable;
|
|
|
|
g_assert (settings == binding->settings);
|
|
g_assert (key == binding->key);
|
|
|
|
writable = g_settings_is_writable (settings, key);
|
|
|
|
if (binding->inverted)
|
|
writable = !writable;
|
|
|
|
g_object_set (binding->object, binding->property, writable, NULL);
|
|
}
|
|
|
|
/**
|
|
* g_settings_bind_writable:
|
|
* @settings: a #GSettings object
|
|
* @key: the key to bind
|
|
* @object: (type GObject.Object):a #GObject
|
|
* @property: the name of a boolean property to bind
|
|
* @inverted: whether to 'invert' the value
|
|
*
|
|
* Create a binding between the writability of @key in the
|
|
* @settings object and the property @property of @object.
|
|
* The property must be boolean; "sensitive" or "visible"
|
|
* properties of widgets are the most likely candidates.
|
|
*
|
|
* Writable bindings are always uni-directional; changes of the
|
|
* writability of the setting will be propagated to the object
|
|
* property, not the other way.
|
|
*
|
|
* When the @inverted argument is %TRUE, the binding inverts the
|
|
* value as it passes from the setting to the object, i.e. @property
|
|
* will be set to %TRUE if the key is <emphasis>not</emphasis>
|
|
* writable.
|
|
*
|
|
* Note that the lifecycle of the binding is tied to the object,
|
|
* and that you can have only one binding per object property.
|
|
* If you bind the same property twice on the same object, the second
|
|
* binding overrides the first one.
|
|
*
|
|
* Since: 2.26
|
|
*/
|
|
void
|
|
g_settings_bind_writable (GSettings *settings,
|
|
const gchar *key,
|
|
gpointer object,
|
|
const gchar *property,
|
|
gboolean inverted)
|
|
{
|
|
GSettingsWritableBinding *binding;
|
|
gchar *detailed_signal;
|
|
GParamSpec *pspec;
|
|
|
|
g_return_if_fail (G_IS_SETTINGS (settings));
|
|
|
|
pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (object), property);
|
|
if (pspec == NULL)
|
|
{
|
|
g_critical ("g_settings_bind_writable: no property '%s' on class '%s'",
|
|
property, G_OBJECT_TYPE_NAME (object));
|
|
return;
|
|
}
|
|
if ((pspec->flags & G_PARAM_WRITABLE) == 0)
|
|
{
|
|
g_critical ("g_settings_bind_writable: property '%s' on class '%s' is not writable",
|
|
property, G_OBJECT_TYPE_NAME (object));
|
|
return;
|
|
}
|
|
|
|
binding = g_slice_new (GSettingsWritableBinding);
|
|
binding->settings = g_object_ref (settings);
|
|
binding->object = object;
|
|
binding->key = g_intern_string (key);
|
|
binding->property = g_intern_string (property);
|
|
binding->inverted = inverted;
|
|
|
|
detailed_signal = g_strdup_printf ("writable-changed::%s", key);
|
|
binding->handler_id =
|
|
g_signal_connect (settings, detailed_signal,
|
|
G_CALLBACK (g_settings_binding_writable_changed),
|
|
binding);
|
|
g_free (detailed_signal);
|
|
|
|
g_object_set_qdata_full (object, g_settings_binding_quark (property),
|
|
binding, g_settings_writable_binding_free);
|
|
|
|
g_settings_binding_writable_changed (settings, binding->key, binding);
|
|
}
|
|
|
|
/**
|
|
* g_settings_unbind:
|
|
* @object: the object
|
|
* @property: the property whose binding is removed
|
|
*
|
|
* Removes an existing binding for @property on @object.
|
|
*
|
|
* Note that bindings are automatically removed when the
|
|
* object is finalized, so it is rarely necessary to call this
|
|
* function.
|
|
*
|
|
* Since: 2.26
|
|
*/
|
|
void
|
|
g_settings_unbind (gpointer object,
|
|
const gchar *property)
|
|
{
|
|
GQuark binding_quark;
|
|
|
|
binding_quark = g_settings_binding_quark (property);
|
|
g_object_set_qdata (object, binding_quark, NULL);
|
|
}
|
|
|
|
/* GAction {{{1 */
|
|
|
|
typedef struct
|
|
{
|
|
GObject parent_instance;
|
|
|
|
GSettingsSchemaKey key;
|
|
GSettings *settings;
|
|
} GSettingsAction;
|
|
|
|
typedef GObjectClass GSettingsActionClass;
|
|
|
|
static GType g_settings_action_get_type (void);
|
|
static void g_settings_action_iface_init (GActionInterface *iface);
|
|
G_DEFINE_TYPE_WITH_CODE (GSettingsAction, g_settings_action, G_TYPE_OBJECT,
|
|
G_IMPLEMENT_INTERFACE (G_TYPE_ACTION, g_settings_action_iface_init))
|
|
|
|
enum
|
|
{
|
|
ACTION_PROP_0,
|
|
ACTION_PROP_NAME,
|
|
ACTION_PROP_PARAMETER_TYPE,
|
|
ACTION_PROP_ENABLED,
|
|
ACTION_PROP_STATE_TYPE,
|
|
ACTION_PROP_STATE
|
|
};
|
|
|
|
static const gchar *
|
|
g_settings_action_get_name (GAction *action)
|
|
{
|
|
GSettingsAction *gsa = (GSettingsAction *) action;
|
|
|
|
return gsa->key.name;
|
|
}
|
|
|
|
static const GVariantType *
|
|
g_settings_action_get_parameter_type (GAction *action)
|
|
{
|
|
GSettingsAction *gsa = (GSettingsAction *) action;
|
|
const GVariantType *type;
|
|
|
|
type = g_variant_get_type (gsa->key.default_value);
|
|
if (g_variant_type_equal (type, G_VARIANT_TYPE_BOOLEAN))
|
|
type = NULL;
|
|
|
|
return type;
|
|
}
|
|
|
|
static gboolean
|
|
g_settings_action_get_enabled (GAction *action)
|
|
{
|
|
GSettingsAction *gsa = (GSettingsAction *) action;
|
|
|
|
return g_settings_is_writable (gsa->settings, gsa->key.name);
|
|
}
|
|
|
|
static const GVariantType *
|
|
g_settings_action_get_state_type (GAction *action)
|
|
{
|
|
GSettingsAction *gsa = (GSettingsAction *) action;
|
|
|
|
return g_variant_get_type (gsa->key.default_value);
|
|
}
|
|
|
|
static GVariant *
|
|
g_settings_action_get_state (GAction *action)
|
|
{
|
|
GSettingsAction *gsa = (GSettingsAction *) action;
|
|
GVariant *value;
|
|
|
|
value = g_settings_read_from_backend (gsa->settings, &gsa->key);
|
|
|
|
if (value == NULL)
|
|
value = g_settings_schema_key_get_translated_default (&gsa->key);
|
|
|
|
if (value == NULL)
|
|
value = g_variant_ref (gsa->key.default_value);
|
|
|
|
return value;
|
|
}
|
|
|
|
static GVariant *
|
|
g_settings_action_get_state_hint (GAction *action)
|
|
{
|
|
GSettingsAction *gsa = (GSettingsAction *) action;
|
|
|
|
/* no point in reimplementing this... */
|
|
return g_settings_get_range (gsa->settings, gsa->key.name);
|
|
}
|
|
|
|
static void
|
|
g_settings_action_change_state (GAction *action,
|
|
GVariant *value)
|
|
{
|
|
GSettingsAction *gsa = (GSettingsAction *) action;
|
|
|
|
if (g_settings_schema_key_type_check (&gsa->key, value) && g_settings_schema_key_range_check (&gsa->key, value))
|
|
g_settings_write_to_backend (gsa->settings, &gsa->key, value);
|
|
}
|
|
|
|
static void
|
|
g_settings_action_activate (GAction *action,
|
|
GVariant *parameter)
|
|
{
|
|
GSettingsAction *gsa = (GSettingsAction *) action;
|
|
|
|
if (g_variant_is_of_type (gsa->key.default_value, G_VARIANT_TYPE_BOOLEAN))
|
|
{
|
|
GVariant *old;
|
|
|
|
if (parameter != NULL)
|
|
return;
|
|
|
|
old = g_settings_action_get_state (action);
|
|
parameter = g_variant_new_boolean (!g_variant_get_boolean (old));
|
|
g_variant_unref (old);
|
|
}
|
|
|
|
g_action_change_state (action, parameter);
|
|
}
|
|
|
|
static void
|
|
g_settings_action_get_property (GObject *object, guint prop_id,
|
|
GValue *value, GParamSpec *pspec)
|
|
{
|
|
GAction *action = G_ACTION (object);
|
|
|
|
switch (prop_id)
|
|
{
|
|
case ACTION_PROP_NAME:
|
|
g_value_set_string (value, g_settings_action_get_name (action));
|
|
break;
|
|
|
|
case ACTION_PROP_PARAMETER_TYPE:
|
|
g_value_set_boxed (value, g_settings_action_get_parameter_type (action));
|
|
break;
|
|
|
|
case ACTION_PROP_ENABLED:
|
|
g_value_set_boolean (value, g_settings_action_get_enabled (action));
|
|
break;
|
|
|
|
case ACTION_PROP_STATE_TYPE:
|
|
g_value_set_boxed (value, g_settings_action_get_state_type (action));
|
|
break;
|
|
|
|
case ACTION_PROP_STATE:
|
|
g_value_set_variant (value, g_settings_action_get_state (action));
|
|
break;
|
|
|
|
default:
|
|
g_assert_not_reached ();
|
|
}
|
|
}
|
|
|
|
static void
|
|
g_settings_action_finalize (GObject *object)
|
|
{
|
|
GSettingsAction *gsa = (GSettingsAction *) object;
|
|
|
|
g_signal_handlers_disconnect_by_data (gsa->settings, gsa);
|
|
g_object_unref (gsa->settings);
|
|
|
|
G_OBJECT_CLASS (g_settings_action_parent_class)
|
|
->finalize (object);
|
|
}
|
|
|
|
static void
|
|
g_settings_action_init (GSettingsAction *gsa)
|
|
{
|
|
}
|
|
|
|
static void
|
|
g_settings_action_iface_init (GActionInterface *iface)
|
|
{
|
|
iface->get_name = g_settings_action_get_name;
|
|
iface->get_parameter_type = g_settings_action_get_parameter_type;
|
|
iface->get_enabled = g_settings_action_get_enabled;
|
|
iface->get_state_type = g_settings_action_get_state_type;
|
|
iface->get_state = g_settings_action_get_state;
|
|
iface->get_state_hint = g_settings_action_get_state_hint;
|
|
iface->change_state = g_settings_action_change_state;
|
|
iface->activate = g_settings_action_activate;
|
|
}
|
|
|
|
static void
|
|
g_settings_action_class_init (GSettingsActionClass *class)
|
|
{
|
|
class->get_property = g_settings_action_get_property;
|
|
class->finalize = g_settings_action_finalize;
|
|
|
|
g_object_class_override_property (class, ACTION_PROP_NAME, "name");
|
|
g_object_class_override_property (class, ACTION_PROP_PARAMETER_TYPE, "parameter-type");
|
|
g_object_class_override_property (class, ACTION_PROP_ENABLED, "enabled");
|
|
g_object_class_override_property (class, ACTION_PROP_STATE_TYPE, "state-type");
|
|
g_object_class_override_property (class, ACTION_PROP_STATE, "state");
|
|
}
|
|
|
|
static void
|
|
g_settings_action_changed (GSettings *settings,
|
|
const gchar *key,
|
|
gpointer user_data)
|
|
{
|
|
g_object_notify (user_data, "state");
|
|
}
|
|
|
|
static void
|
|
g_settings_action_enabled_changed (GSettings *settings,
|
|
const gchar *key,
|
|
gpointer user_data)
|
|
{
|
|
g_object_notify (user_data, "enabled");
|
|
}
|
|
|
|
/**
|
|
* g_settings_create_action:
|
|
* @settings: a #GSettings
|
|
* @key: the name of a key in @settings
|
|
*
|
|
* Creates a #GAction corresponding to a given #GSettings key.
|
|
*
|
|
* The action has the same name as the key.
|
|
*
|
|
* The value of the key becomes the state of the action and the action
|
|
* is enabled when the key is writable. Changing the state of the
|
|
* action results in the key being written to. Changes to the value or
|
|
* writability of the key cause appropriate change notifications to be
|
|
* emitted for the action.
|
|
*
|
|
* For boolean-valued keys, action activations take no parameter and
|
|
* result in the toggling of the value. For all other types,
|
|
* activations take the new value for the key (which must have the
|
|
* correct type).
|
|
*
|
|
* Returns: (transfer full): a new #GAction
|
|
*
|
|
* Since: 2.32
|
|
**/
|
|
GAction *
|
|
g_settings_create_action (GSettings *settings,
|
|
const gchar *key)
|
|
{
|
|
GSettingsAction *gsa;
|
|
gchar *detailed_signal;
|
|
|
|
g_return_val_if_fail (G_IS_SETTINGS (settings), NULL);
|
|
g_return_val_if_fail (key != NULL, NULL);
|
|
|
|
gsa = g_object_new (g_settings_action_get_type (), NULL);
|
|
gsa->settings = g_object_ref (settings);
|
|
g_settings_schema_key_init (&gsa->key, settings->priv->schema, key);
|
|
|
|
detailed_signal = g_strdup_printf ("changed::%s", key);
|
|
g_signal_connect (settings, detailed_signal, G_CALLBACK (g_settings_action_changed), gsa);
|
|
g_free (detailed_signal);
|
|
detailed_signal = g_strdup_printf ("writable-changed::%s", key);
|
|
g_signal_connect (settings, detailed_signal, G_CALLBACK (g_settings_action_enabled_changed), gsa);
|
|
g_free (detailed_signal);
|
|
|
|
return G_ACTION (gsa);
|
|
}
|
|
|
|
/* Epilogue {{{1 */
|
|
|
|
/* vim:set foldmethod=marker: */
|