* 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.
+ * License along with this library; if not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
/**
* SECTION:gsettingsschema
- * @short_description: Introspecting and controlling the loading of
- * GSettings schemas
+ * @short_description: Introspecting and controlling the loading
+ * of GSettings schemas
+ * @include: gio/gio.h
*
* The #GSettingsSchemaSource and #GSettingsSchema APIs provide a
* mechanism for advanced control over the loading of schemas and a
*
* Consider the following example:
*
- * |[
+ * |[<!-- language="C" -->
* typedef struct
* {
* ...
* ships a gschemas.compiled file as part of itself, and then simply do
* the following:
*
- * |[
+ * |[<!-- language="C" -->
* {
* GSettings *settings;
* gint some_value;
* This function is not required for normal uses of #GSettings but it
* may be useful to authors of plugin management systems.
*
- * The directory should contain a file called
- * <filename>gschemas.compiled</filename> as produced by
- * <command>glib-compile-schemas</command>.
+ * The directory should contain a file called `gschemas.compiled` as
+ * produced by the [glib-compile-schemas][glib-compile-schemas] tool.
*
- * If @trusted is %TRUE then <filename>gschemas.compiled</filename> is
- * trusted not to be corrupted. This assumption has a performance
- * advantage, but can result in crashes or inconsistent behaviour in the
- * case of a corrupted file. Generally, you should set @trusted to
- * %TRUE for files installed by the system and to %FALSE for files in
- * the home directory.
+ * If @trusted is %TRUE then `gschemas.compiled` is trusted not to be
+ * corrupted. This assumption has a performance advantage, but can result
+ * in crashes or inconsistent behaviour in the case of a corrupted file.
+ * Generally, you should set @trusted to %TRUE for files installed by the
+ * system and to %FALSE for files in the home directory.
*
* If @parent is non-%NULL then there are two effects.
*
* source, the lookup will recurse to the parent.
*
* Second, any references to other schemas specified within this
- * source (ie: <literal>child</literal> or <literal>extends</literal>)
- * references may be resolved from the @parent.
+ * source (ie: `child` or `extends`) references may be resolved
+ * from the @parent.
*
* For this second reason, except in very unusual situations, the
* @parent should probably be given as the default schema source, as
*
* The returned source may actually consist of multiple schema sources
* from different directories, depending on which directories were given
- * in <envar>XDG_DATA_DIRS</envar> and
- * <envar>GSETTINGS_SCHEMA_DIR</envar>. For this reason, all lookups
- * performed against the default source should probably be done
+ * in `XDG_DATA_DIRS` and `GSETTINGS_SCHEMA_DIR`. For this reason, all
+ * lookups performed against the default source should probably be done
* recursively.
*
* Returns: (transfer none): the default schema source
*
* If the schema isn't found, %NULL is returned.
*
- * Returns: (transfer full): a new #GSettingsSchema
+ * Returns: (nullable) (transfer full): a new #GSettingsSchema
*
* Since: 2.32
**/
GMarkupParseContext *context;
context = g_markup_parse_context_new (&parser, G_MARKUP_TREAT_CDATA_AS_TEXT, &info, NULL);
+ /* Ignore errors here, this is best effort only. */
if (g_markup_parse_context_parse (context, contents, size, NULL))
- g_markup_parse_context_end_parse (context, NULL);
+ (void) g_markup_parse_context_end_parse (context, NULL);
g_markup_parse_context_free (context);
/* Clean up dangling stuff in case there was an error. */
g_free (filename);
}
+
+ g_dir_close (dir);
}
static GHashTable **
* g_settings_schema_source_list_schemas:
* @source: a #GSettingsSchemaSource
* @recursive: if we should recurse
- * @non_relocatable_schemas: (out) (transfer full): the list of
- * non-relocatable schemas
- * @relocatable_schemas: (out) (transfer full): the list of relocatable
- * schemas
+ * @non_relocatable: (out) (transfer full) (array zero-terminated=1): the
+ * list of non-relocatable schemas
+ * @relocatable: (out) (transfer full) (array zero-terminated=1): the list
+ * of relocatable schemas
*
* Lists the schemas in a given source.
*
void
g_settings_schema_source_list_schemas (GSettingsSchemaSource *source,
gboolean recursive,
- gchar ***non_relocatable_schemas,
- gchar ***relocatable_schemas)
+ gchar ***non_relocatable,
+ gchar ***relocatable)
{
GHashTable *single, *reloc;
GSettingsSchemaSource *s;
break;
}
- if (non_relocatable_schemas)
+ if (non_relocatable)
{
- *non_relocatable_schemas = (gchar **) g_hash_table_get_keys_as_array (single, NULL);
+ *non_relocatable = (gchar **) g_hash_table_get_keys_as_array (single, NULL);
g_hash_table_steal_all (single);
}
- if (relocatable_schemas)
+ if (relocatable)
{
- *relocatable_schemas = (gchar **) g_hash_table_get_keys_as_array (reloc, NULL);
+ *relocatable = (gchar **) g_hash_table_get_keys_as_array (reloc, NULL);
g_hash_table_steal_all (reloc);
}
*
* Since: 2.26
*
- * Deprecated:2.40: Use g_settings_schema_source_list_schemas() instead
+ * Deprecated:2.40: Use g_settings_schema_source_list_schemas() instead.
+ * If you used g_settings_list_schemas() to check for the presence of
+ * a particular schema, use g_settings_schema_source_lookup() instead
+ * of your whole loop.
**/
const gchar * const *
g_settings_list_schemas (void)
g_return_val_if_fail (schema != NULL, NULL);
- for (s = schema; s; s = schema->extends)
- if ((value = gvdb_table_get_raw_value (schema->table, key)))
+ for (s = schema; s; s = s->extends)
+ if ((value = gvdb_table_get_raw_value (s->table, key)))
break;
if G_UNLIKELY (value == NULL || !g_variant_is_of_type (value, G_VARIANT_TYPE_TUPLE))
return schema->gettext_domain;
}
+/**
+ * g_settings_schema_has_key:
+ * @schema: a #GSettingsSchema
+ * @name: the name of a key
+ *
+ * Checks if @schema has a key named @name.
+ *
+ * Returns: %TRUE if such a key exists
+ *
+ * Since: 2.40
+ **/
gboolean
g_settings_schema_has_key (GSettingsSchema *schema,
const gchar *key)
list = gvdb_table_list (s->table, "");
- for (i = 0; list[i]; i++)
- g_hash_table_add (items, list[i]); /* transfer ownership */
+ if (list)
+ {
+ for (i = 0; list[i]; i++)
+ g_hash_table_add (items, list[i]); /* transfer ownership */
- g_free (list); /* free container only */
+ g_free (list); /* free container only */
+ }
}
/* Do a first pass to eliminate child items that do not map to
/* Now create the list */
len = g_hash_table_size (items);
- schema->items = g_new (GQuark, len + 1);
+ schema->items = g_new (GQuark, len);
i = 0;
g_hash_table_iter_init (&iter, items);
while (g_hash_table_iter_next (&iter, &name, NULL))
- {
- schema->items[i++] = g_quark_from_string (name);
- g_hash_table_iter_steal (&iter);
- }
+ schema->items[i++] = g_quark_from_string (name);
schema->n_items = i;
g_assert (i == len);
return g_variant_is_of_type (value, key->type);
}
-gboolean
-g_settings_schema_key_range_check (GSettingsSchemaKey *key,
- GVariant *value)
-{
- if (key->minimum == NULL && key->strinfo == NULL)
- return TRUE;
-
- if (g_variant_is_container (value))
- {
- gboolean ok = TRUE;
- GVariantIter iter;
- GVariant *child;
-
- g_variant_iter_init (&iter, value);
- while (ok && (child = g_variant_iter_next_value (&iter)))
- {
- ok = g_settings_schema_key_range_check (key, child);
- g_variant_unref (child);
- }
-
- return ok;
- }
-
- if (key->minimum)
- {
- return g_variant_compare (key->minimum, value) <= 0 &&
- g_variant_compare (value, key->maximum) <= 0;
- }
-
- return strinfo_is_string_valid (key->strinfo, key->strinfo_length,
- g_variant_get_string (value, NULL));
-}
-
GVariant *
g_settings_schema_key_range_fixup (GSettingsSchemaKey *key,
GVariant *value)
return target ? g_variant_ref_sink (g_variant_new_string (target)) : NULL;
}
-
GVariant *
g_settings_schema_key_get_translated_default (GSettingsSchemaKey *key)
{
if (value == NULL)
{
g_warning ("Failed to parse translated string '%s' for "
- "key '%s' in schema '%s': %s", key->unparsed, key->name,
+ "key '%s' in schema '%s': %s", translated, key->name,
g_settings_schema_get_id (key->schema), error->message);
g_warning ("Using untranslated default instead.");
g_error_free (error);
return descriptions ? g_hash_table_lookup (descriptions, key->name) : NULL;
}
+
+/**
+ * g_settings_schema_key_get_value_type:
+ * @key: a #GSettingsSchemaKey
+ *
+ * Gets the #GVariantType of @key.
+ *
+ * Returns: (transfer none): the type of @key
+ *
+ * Since: 2.40
+ **/
+const GVariantType *
+g_settings_schema_key_get_value_type (GSettingsSchemaKey *key)
+{
+ g_return_val_if_fail (key, NULL);
+
+ return key->type;
+}
+
+/**
+ * g_settings_schema_key_get_default_value:
+ * @key: a #GSettingsSchemaKey
+ *
+ * Gets the default value for @key.
+ *
+ * Note that this is the default value according to the schema. System
+ * administrator defaults and lockdown are not visible via this API.
+ *
+ * Returns: (transfer full): the default value for the key
+ *
+ * Since: 2.40
+ **/
+GVariant *
+g_settings_schema_key_get_default_value (GSettingsSchemaKey *key)
+{
+ GVariant *value;
+
+ g_return_val_if_fail (key, NULL);
+
+ value = g_settings_schema_key_get_translated_default (key);
+
+ if (!value)
+ value = g_variant_ref (key->default_value);
+
+ return value;
+}
+
+/**
+ * g_settings_schema_key_get_range:
+ * @key: a #GSettingsSchemaKey
+ *
+ * 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 `(sv)`. 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 `'type'` 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 `'enum'` 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 `'flags'` 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 `['x', 'y']` then the valid values for
+ * the key would be `[]`, `['x']`, `['y']`, `['x', 'y']` and
+ * `['y', 'x']`.
+ *
+ * Finally, if the string is `'range'` 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.
+ *
+ * You should free the returned value with g_variant_unref() when it is
+ * no longer needed.
+ *
+ * Returns: (transfer full): a #GVariant describing the range
+ *
+ * Since: 2.40
+ **/
+GVariant *
+g_settings_schema_key_get_range (GSettingsSchemaKey *key)
+{
+ const gchar *type;
+ GVariant *range;
+
+ if (key->minimum)
+ {
+ range = g_variant_new ("(**)", key->minimum, key->maximum);
+ type = "range";
+ }
+ else if (key->strinfo)
+ {
+ range = strinfo_enumerate (key->strinfo, key->strinfo_length);
+ type = key->is_flags ? "flags" : "enum";
+ }
+ else
+ {
+ range = g_variant_new_array (key->type, NULL, 0);
+ type = "type";
+ }
+
+ return g_variant_ref_sink (g_variant_new ("(sv)", type, range));
+}
+
+/**
+ * g_settings_schema_key_range_check:
+ * @key: a #GSettingsSchemaKey
+ * @value: the value to check
+ *
+ * Checks if the given @value is of the correct type and within the
+ * permitted range for @key.
+ *
+ * It is a programmer error if @value is not of the correct type -- you
+ * must check for this first.
+ *
+ * Returns: %TRUE if @value is valid for @key
+ *
+ * Since: 2.40
+ **/
+gboolean
+g_settings_schema_key_range_check (GSettingsSchemaKey *key,
+ GVariant *value)
+{
+ if (key->minimum == NULL && key->strinfo == NULL)
+ return TRUE;
+
+ if (g_variant_is_container (value))
+ {
+ gboolean ok = TRUE;
+ GVariantIter iter;
+ GVariant *child;
+
+ g_variant_iter_init (&iter, value);
+ while (ok && (child = g_variant_iter_next_value (&iter)))
+ {
+ ok = g_settings_schema_key_range_check (key, child);
+ g_variant_unref (child);
+ }
+
+ return ok;
+ }
+
+ if (key->minimum)
+ {
+ return g_variant_compare (key->minimum, value) <= 0 &&
+ g_variant_compare (value, key->maximum) <= 0;
+ }
+
+ return strinfo_is_string_valid (key->strinfo, key->strinfo_length,
+ g_variant_get_string (value, NULL));
+}
projects / platform / upstream / glib.git / blobdiff