1 /*
2  * This file is part of gtkD.
3  *
4  * gtkD is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU Lesser General Public License
6  * as published by the Free Software Foundation; either version 3
7  * of the License, or (at your option) any later version, with
8  * some exceptions, please read the COPYING file.
9  *
10  * gtkD is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public License
16  * along with gtkD; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA
18  */
19 
20 // generated automatically - do not change
21 // find conversion definition on APILookup.txt
22 // implement new conversion functionalities on the wrap.utils pakage
23 
24 
25 module gio.Settings;
26 
27 private import gio.ActionIF;
28 private import gio.SettingsBackend;
29 private import gio.SettingsSchema;
30 private import gio.c.functions;
31 public  import gio.c.types;
32 private import glib.ConstructionException;
33 private import glib.Str;
34 private import glib.Variant;
35 private import gobject.ObjectG;
36 private import gobject.Signals;
37 public  import gtkc.giotypes;
38 private import std.algorithm;
39 
40 
41 /**
42  * The #GSettings class provides a convenient API for storing and retrieving
43  * application settings.
44  * 
45  * Reads and writes can be considered to be non-blocking.  Reading
46  * settings with #GSettings is typically extremely fast: on
47  * approximately the same order of magnitude (but slower than) a
48  * #GHashTable lookup.  Writing settings is also extremely fast in terms
49  * of time to return to your application, but can be extremely expensive
50  * for other threads and other processes.  Many settings backends
51  * (including dconf) have lazy initialisation which means in the common
52  * case of the user using their computer without modifying any settings
53  * a lot of work can be avoided.  For dconf, the D-Bus service doesn't
54  * even need to be started in this case.  For this reason, you should
55  * only ever modify #GSettings keys in response to explicit user action.
56  * Particular care should be paid to ensure that modifications are not
57  * made during startup -- for example, when setting the initial value
58  * of preferences widgets.  The built-in g_settings_bind() functionality
59  * is careful not to write settings in response to notify signals as a
60  * result of modifications that it makes to widgets.
61  * 
62  * When creating a GSettings instance, you have to specify a schema
63  * that describes the keys in your settings and their types and default
64  * values, as well as some other information.
65  * 
66  * Normally, a schema has a fixed path that determines where the settings
67  * are stored in the conceptual global tree of settings. However, schemas
68  * can also be '[relocatable][gsettings-relocatable]', i.e. not equipped with
69  * a fixed path. This is
70  * useful e.g. when the schema describes an 'account', and you want to be
71  * able to store a arbitrary number of accounts.
72  * 
73  * Paths must start with and end with a forward slash character ('/')
74  * and must not contain two sequential slash characters.  Paths should
75  * be chosen based on a domain name associated with the program or
76  * library to which the settings belong.  Examples of paths are
77  * "/org/gtk/settings/file-chooser/" and "/ca/desrt/dconf-editor/".
78  * Paths should not start with "/apps/", "/desktop/" or "/system/" as
79  * they often did in GConf.
80  * 
81  * Unlike other configuration systems (like GConf), GSettings does not
82  * restrict keys to basic types like strings and numbers. GSettings stores
83  * values as #GVariant, and allows any #GVariantType for keys. Key names
84  * are restricted to lowercase characters, numbers and '-'. Furthermore,
85  * the names must begin with a lowercase character, must not end
86  * with a '-', and must not contain consecutive dashes.
87  * 
88  * Similar to GConf, the default values in GSettings schemas can be
89  * localized, but the localized values are stored in gettext catalogs
90  * and looked up with the domain that is specified in the
91  * `gettext-domain` attribute of the <schemalist> or <schema>
92  * elements and the category that is specified in the `l10n` attribute of
93  * the <default> element. The string which is translated includes all text in
94  * the <default> element, including any surrounding quotation marks.
95  * 
96  * The `l10n` attribute must be set to `messages` or `time`, and sets the
97  * [locale category for
98  * translation](https://www.gnu.org/software/gettext/manual/html_node/Aspects.html#index-locale-categories-1).
99  * The `messages` category should be used by default; use `time` for
100  * translatable date or time formats. A translation comment can be added as an
101  * XML comment immediately above the <default> element — it is recommended to
102  * add these comments to aid translators understand the meaning and
103  * implications of the default value. An optional translation `context`
104  * attribute can be set on the <default> element to disambiguate multiple
105  * defaults which use the same string.
106  * 
107  * For example:
108  * |[
109  * <!-- Translators: A list of words which are not allowed to be typed, in
110  * GVariant serialization syntax.
111  * See: https://developer.gnome.org/glib/stable/gvariant-text.html -->
112  * <default l10n='messages' context='Banned words'>['bad', 'words']</default>
113  * ]|
114  * 
115  * Translations of default values must remain syntactically valid serialized
116  * #GVariants (e.g. retaining any surrounding quotation marks) or runtime
117  * errors will occur.
118  * 
119  * GSettings uses schemas in a compact binary form that is created
120  * by the [glib-compile-schemas][glib-compile-schemas]
121  * utility. The input is a schema description in an XML format.
122  * 
123  * A DTD for the gschema XML format can be found here:
124  * [gschema.dtd](https://git.gnome.org/browse/glib/tree/gio/gschema.dtd)
125  * 
126  * The [glib-compile-schemas][glib-compile-schemas] tool expects schema
127  * files to have the extension `.gschema.xml`.
128  * 
129  * At runtime, schemas are identified by their id (as specified in the
130  * id attribute of the <schema> element). The convention for schema
131  * ids is to use a dotted name, similar in style to a D-Bus bus name,
132  * e.g. "org.gnome.SessionManager". In particular, if the settings are
133  * for a specific service that owns a D-Bus bus name, the D-Bus bus name
134  * and schema id should match. For schemas which deal with settings not
135  * associated with one named application, the id should not use
136  * StudlyCaps, e.g. "org.gnome.font-rendering".
137  * 
138  * In addition to #GVariant types, keys can have types that have
139  * enumerated types. These can be described by a <choice>,
140  * <enum> or <flags> element, as seen in the
141  * [example][schema-enumerated]. The underlying type of such a key
142  * is string, but you can use g_settings_get_enum(), g_settings_set_enum(),
143  * g_settings_get_flags(), g_settings_set_flags() access the numeric values
144  * corresponding to the string value of enum and flags keys.
145  * 
146  * An example for default value:
147  * |[
148  * <schemalist>
149  * <schema id="org.gtk.Test" path="/org/gtk/Test/" gettext-domain="test">
150  * 
151  * <key name="greeting" type="s">
152  * <default l10n="messages">"Hello, earthlings"</default>
153  * <summary>A greeting</summary>
154  * <description>
155  * Greeting of the invading martians
156  * </description>
157  * </key>
158  * 
159  * <key name="box" type="(ii)">
160  * <default>(20,30)</default>
161  * </key>
162  * 
163  * <key name="empty-string" type="s">
164  * <default>""</default>
165  * <summary>Empty strings have to be provided in GVariant form</summary>
166  * </key>
167  * 
168  * </schema>
169  * </schemalist>
170  * ]|
171  * 
172  * An example for ranges, choices and enumerated types:
173  * |[
174  * <schemalist>
175  * 
176  * <enum id="org.gtk.Test.myenum">
177  * <value nick="first" value="1"/>
178  * <value nick="second" value="2"/>
179  * </enum>
180  * 
181  * <flags id="org.gtk.Test.myflags">
182  * <value nick="flag1" value="1"/>
183  * <value nick="flag2" value="2"/>
184  * <value nick="flag3" value="4"/>
185  * </flags>
186  * 
187  * <schema id="org.gtk.Test">
188  * 
189  * <key name="key-with-range" type="i">
190  * <range min="1" max="100"/>
191  * <default>10</default>
192  * </key>
193  * 
194  * <key name="key-with-choices" type="s">
195  * <choices>
196  * <choice value='Elisabeth'/>
197  * <choice value='Annabeth'/>
198  * <choice value='Joe'/>
199  * </choices>
200  * <aliases>
201  * <alias value='Anna' target='Annabeth'/>
202  * <alias value='Beth' target='Elisabeth'/>
203  * </aliases>
204  * <default>'Joe'</default>
205  * </key>
206  * 
207  * <key name='enumerated-key' enum='org.gtk.Test.myenum'>
208  * <default>'first'</default>
209  * </key>
210  * 
211  * <key name='flags-key' flags='org.gtk.Test.myflags'>
212  * <default>["flag1","flag2"]</default>
213  * </key>
214  * </schema>
215  * </schemalist>
216  * ]|
217  * 
218  * ## Vendor overrides
219  * 
220  * Default values are defined in the schemas that get installed by
221  * an application. Sometimes, it is necessary for a vendor or distributor
222  * to adjust these defaults. Since patching the XML source for the schema
223  * is inconvenient and error-prone,
224  * [glib-compile-schemas][glib-compile-schemas] reads so-called vendor
225  * override' files. These are keyfiles in the same directory as the XML
226  * schema sources which can override default values. The schema id serves
227  * as the group name in the key file, and the values are expected in
228  * serialized GVariant form, as in the following example:
229  * |[
230  * [org.gtk.Example]
231  * key1='string'
232  * key2=1.5
233  * ]|
234  * 
235  * glib-compile-schemas expects schema files to have the extension
236  * `.gschema.override`.
237  * 
238  * ## Binding
239  * 
240  * A very convenient feature of GSettings lets you bind #GObject properties
241  * directly to settings, using g_settings_bind(). Once a GObject property
242  * has been bound to a setting, changes on either side are automatically
243  * propagated to the other side. GSettings handles details like mapping
244  * between GObject and GVariant types, and preventing infinite cycles.
245  * 
246  * This makes it very easy to hook up a preferences dialog to the
247  * underlying settings. To make this even more convenient, GSettings
248  * looks for a boolean property with the name "sensitivity" and
249  * automatically binds it to the writability of the bound setting.
250  * If this 'magic' gets in the way, it can be suppressed with the
251  * #G_SETTINGS_BIND_NO_SENSITIVITY flag.
252  * 
253  * ## Relocatable schemas # {#gsettings-relocatable}
254  * 
255  * A relocatable schema is one with no `path` attribute specified on its
256  * <schema> element. By using g_settings_new_with_path(), a #GSettings object
257  * can be instantiated for a relocatable schema, assigning a path to the
258  * instance. Paths passed to g_settings_new_with_path() will typically be
259  * constructed dynamically from a constant prefix plus some form of instance
260  * identifier; but they must still be valid GSettings paths. Paths could also
261  * be constant and used with a globally installed schema originating from a
262  * dependency library.
263  * 
264  * For example, a relocatable schema could be used to store geometry information
265  * for different windows in an application. If the schema ID was
266  * `org.foo.MyApp.Window`, it could be instantiated for paths
267  * `/org/foo/MyApp/main/`, `/org/foo/MyApp/document-1/`,
268  * `/org/foo/MyApp/document-2/`, etc. If any of the paths are well-known
269  * they can be specified as <child> elements in the parent schema, e.g.:
270  * |[
271  * <schema id="org.foo.MyApp" path="/org/foo/MyApp/">
272  * <child name="main" schema="org.foo.MyApp.Window"/>
273  * </schema>
274  * ]|
275  * 
276  * ## Build system integration # {#gsettings-build-system}
277  * 
278  * GSettings comes with autotools integration to simplify compiling and
279  * installing schemas. To add GSettings support to an application, add the
280  * following to your `configure.ac`:
281  * |[
282  * GLIB_GSETTINGS
283  * ]|
284  * 
285  * In the appropriate `Makefile.am`, use the following snippet to compile and
286  * install the named schema:
287  * |[
288  * gsettings_SCHEMAS = org.foo.MyApp.gschema.xml
289  * EXTRA_DIST = $(gsettings_SCHEMAS)
290  * 
291  * @GSETTINGS_RULES@
292  * ]|
293  * 
294  * No changes are needed to the build system to mark a schema XML file for
295  * translation. Assuming it sets the `gettext-domain` attribute, a schema may
296  * be marked for translation by adding it to `POTFILES.in`, assuming gettext
297  * 0.19 is in use (the preferred method for translation):
298  * |[
299  * data/org.foo.MyApp.gschema.xml
300  * ]|
301  * 
302  * Alternatively, if intltool 0.50.1 is in use:
303  * |[
304  * [type: gettext/gsettings]data/org.foo.MyApp.gschema.xml
305  * ]|
306  * 
307  * GSettings will use gettext to look up translations for the <summary> and
308  * <description> elements, and also any <default> elements which have a `l10n`
309  * attribute set. Translations must not be included in the `.gschema.xml` file
310  * by the build system, for example by using intltool XML rules with a
311  * `.gschema.xml.in` template.
312  * 
313  * If an enumerated type defined in a C header file is to be used in a GSettings
314  * schema, it can either be defined manually using an <enum> element in the
315  * schema XML, or it can be extracted automatically from the C header. This
316  * approach is preferred, as it ensures the two representations are always
317  * synchronised. To do so, add the following to the relevant `Makefile.am`:
318  * |[
319  * gsettings_ENUM_NAMESPACE = org.foo.MyApp
320  * gsettings_ENUM_FILES = my-app-enums.h my-app-misc.h
321  * ]|
322  * 
323  * `gsettings_ENUM_NAMESPACE` specifies the schema namespace for the enum files,
324  * which are specified in `gsettings_ENUM_FILES`. This will generate a
325  * `org.foo.MyApp.enums.xml` file containing the extracted enums, which will be
326  * automatically included in the schema compilation, install and uninstall
327  * rules. It should not be committed to version control or included in
328  * `EXTRA_DIST`.
329  */
330 public class Settings : ObjectG
331 {
332 	/** the main Gtk struct */
333 	protected GSettings* gSettings;
334 
335 	/** Get the main Gtk struct */
336 	public GSettings* getSettingsStruct(bool transferOwnership = false)
337 	{
338 		if (transferOwnership)
339 			ownedRef = false;
340 		return gSettings;
341 	}
342 
343 	/** the main Gtk struct as a void* */
344 	protected override void* getStruct()
345 	{
346 		return cast(void*)gSettings;
347 	}
348 
349 	/**
350 	 * Sets our main struct and passes it to the parent class.
351 	 */
352 	public this (GSettings* gSettings, bool ownedRef = false)
353 	{
354 		this.gSettings = gSettings;
355 		super(cast(GObject*)gSettings, ownedRef);
356 	}
357 
358 
359 	/** */
360 	public static GType getType()
361 	{
362 		return g_settings_get_type();
363 	}
364 
365 	/**
366 	 * Creates a new #GSettings object with the schema specified by
367 	 * @schema_id.
368 	 *
369 	 * Signals on the newly created #GSettings object will be dispatched
370 	 * via the thread-default #GMainContext in effect at the time of the
371 	 * call to g_settings_new().  The new #GSettings will hold a reference
372 	 * on the context.  See g_main_context_push_thread_default().
373 	 *
374 	 * Params:
375 	 *     schemaId = the id of the schema
376 	 *
377 	 * Returns: a new #GSettings object
378 	 *
379 	 * Since: 2.26
380 	 *
381 	 * Throws: ConstructionException GTK+ fails to create the object.
382 	 */
383 	public this(string schemaId)
384 	{
385 		auto p = g_settings_new(Str.toStringz(schemaId));
386 
387 		if(p is null)
388 		{
389 			throw new ConstructionException("null returned by new");
390 		}
391 
392 		this(cast(GSettings*) p, true);
393 	}
394 
395 	/**
396 	 * Creates a new #GSettings object with a given schema, backend and
397 	 * path.
398 	 *
399 	 * It should be extremely rare that you ever want to use this function.
400 	 * It is made available for advanced use-cases (such as plugin systems
401 	 * that want to provide access to schemas loaded from custom locations,
402 	 * etc).
403 	 *
404 	 * At the most basic level, a #GSettings object is a pure composition of
405 	 * 4 things: a #GSettingsSchema, a #GSettingsBackend, a path within that
406 	 * backend, and a #GMainContext to which signals are dispatched.
407 	 *
408 	 * This constructor therefore gives you full control over constructing
409 	 * #GSettings instances.  The first 3 parameters are given directly as
410 	 * @schema, @backend and @path, and the main context is taken from the
411 	 * thread-default (as per g_settings_new()).
412 	 *
413 	 * If @backend is %NULL then the default backend is used.
414 	 *
415 	 * If @path is %NULL then the path from the schema is used.  It is an
416 	 * error if @path is %NULL and the schema has no path of its own or if
417 	 * @path is non-%NULL and not equal to the path that the schema does
418 	 * have.
419 	 *
420 	 * Params:
421 	 *     schema = a #GSettingsSchema
422 	 *     backend = a #GSettingsBackend
423 	 *     path = the path to use
424 	 *
425 	 * Returns: a new #GSettings object
426 	 *
427 	 * Since: 2.32
428 	 *
429 	 * Throws: ConstructionException GTK+ fails to create the object.
430 	 */
431 	public this(SettingsSchema schema, SettingsBackend backend, string path)
432 	{
433 		auto p = g_settings_new_full((schema is null) ? null : schema.getSettingsSchemaStruct(), (backend is null) ? null : backend.getSettingsBackendStruct(), Str.toStringz(path));
434 
435 		if(p is null)
436 		{
437 			throw new ConstructionException("null returned by new_full");
438 		}
439 
440 		this(cast(GSettings*) p, true);
441 	}
442 
443 	/**
444 	 * Creates a new #GSettings object with the schema specified by
445 	 * @schema_id and a given #GSettingsBackend.
446 	 *
447 	 * Creating a #GSettings object with a different backend allows accessing
448 	 * settings from a database other than the usual one. For example, it may make
449 	 * sense to pass a backend corresponding to the "defaults" settings database on
450 	 * the system to get a settings object that modifies the system default
451 	 * settings instead of the settings for this user.
452 	 *
453 	 * Params:
454 	 *     schemaId = the id of the schema
455 	 *     backend = the #GSettingsBackend to use
456 	 *
457 	 * Returns: a new #GSettings object
458 	 *
459 	 * Since: 2.26
460 	 *
461 	 * Throws: ConstructionException GTK+ fails to create the object.
462 	 */
463 	public this(string schemaId, SettingsBackend backend)
464 	{
465 		auto p = g_settings_new_with_backend(Str.toStringz(schemaId), (backend is null) ? null : backend.getSettingsBackendStruct());
466 
467 		if(p is null)
468 		{
469 			throw new ConstructionException("null returned by new_with_backend");
470 		}
471 
472 		this(cast(GSettings*) p, true);
473 	}
474 
475 	/**
476 	 * Creates a new #GSettings object with the schema specified by
477 	 * @schema_id and a given #GSettingsBackend and path.
478 	 *
479 	 * This is a mix of g_settings_new_with_backend() and
480 	 * g_settings_new_with_path().
481 	 *
482 	 * Params:
483 	 *     schemaId = the id of the schema
484 	 *     backend = the #GSettingsBackend to use
485 	 *     path = the path to use
486 	 *
487 	 * Returns: a new #GSettings object
488 	 *
489 	 * Since: 2.26
490 	 *
491 	 * Throws: ConstructionException GTK+ fails to create the object.
492 	 */
493 	public this(string schemaId, SettingsBackend backend, string path)
494 	{
495 		auto p = g_settings_new_with_backend_and_path(Str.toStringz(schemaId), (backend is null) ? null : backend.getSettingsBackendStruct(), Str.toStringz(path));
496 
497 		if(p is null)
498 		{
499 			throw new ConstructionException("null returned by new_with_backend_and_path");
500 		}
501 
502 		this(cast(GSettings*) p, true);
503 	}
504 
505 	/**
506 	 * Creates a new #GSettings object with the relocatable schema specified
507 	 * by @schema_id and a given path.
508 	 *
509 	 * You only need to do this if you want to directly create a settings
510 	 * object with a schema that doesn't have a specified path of its own.
511 	 * That's quite rare.
512 	 *
513 	 * It is a programmer error to call this function for a schema that
514 	 * has an explicitly specified path.
515 	 *
516 	 * It is a programmer error if @path is not a valid path.  A valid path
517 	 * begins and ends with '/' and does not contain two consecutive '/'
518 	 * characters.
519 	 *
520 	 * Params:
521 	 *     schemaId = the id of the schema
522 	 *     path = the path to use
523 	 *
524 	 * Returns: a new #GSettings object
525 	 *
526 	 * Since: 2.26
527 	 *
528 	 * Throws: ConstructionException GTK+ fails to create the object.
529 	 */
530 	public this(string schemaId, string path)
531 	{
532 		auto p = g_settings_new_with_path(Str.toStringz(schemaId), Str.toStringz(path));
533 
534 		if(p is null)
535 		{
536 			throw new ConstructionException("null returned by new_with_path");
537 		}
538 
539 		this(cast(GSettings*) p, true);
540 	}
541 
542 	/**
543 	 * Deprecated.
544 	 *
545 	 * Deprecated: Use g_settings_schema_source_list_schemas() instead
546 	 *
547 	 * Returns: a list of relocatable
548 	 *     #GSettings schemas that are available.  The list must not be
549 	 *     modified or freed.
550 	 *
551 	 * Since: 2.28
552 	 */
553 	public static string[] listRelocatableSchemas()
554 	{
555 		return Str.toStringArray(g_settings_list_relocatable_schemas());
556 	}
557 
558 	/**
559 	 * Deprecated.
560 	 *
561 	 * Deprecated: Use g_settings_schema_source_list_schemas() instead.
562 	 * If you used g_settings_list_schemas() to check for the presence of
563 	 * a particular schema, use g_settings_schema_source_lookup() instead
564 	 * of your whole loop.
565 	 *
566 	 * Returns: a list of #GSettings
567 	 *     schemas that are available.  The list must not be modified or
568 	 *     freed.
569 	 *
570 	 * Since: 2.26
571 	 */
572 	public static string[] listSchemas()
573 	{
574 		return Str.toStringArray(g_settings_list_schemas());
575 	}
576 
577 	/**
578 	 * Ensures that all pending operations are complete for the default backend.
579 	 *
580 	 * Writes made to a #GSettings are handled asynchronously.  For this
581 	 * reason, it is very unlikely that the changes have it to disk by the
582 	 * time g_settings_set() returns.
583 	 *
584 	 * This call will block until all of the writes have made it to the
585 	 * backend.  Since the mainloop is not running, no change notifications
586 	 * will be dispatched during this call (but some may be queued by the
587 	 * time the call is done).
588 	 */
589 	public static void sync()
590 	{
591 		g_settings_sync();
592 	}
593 
594 	/**
595 	 * Removes an existing binding for @property on @object.
596 	 *
597 	 * Note that bindings are automatically removed when the
598 	 * object is finalized, so it is rarely necessary to call this
599 	 * function.
600 	 *
601 	 * Params:
602 	 *     object = the object
603 	 *     property = the property whose binding is removed
604 	 *
605 	 * Since: 2.26
606 	 */
607 	public static void unbind(ObjectG object, string property)
608 	{
609 		g_settings_unbind((object is null) ? null : object.getObjectGStruct(), Str.toStringz(property));
610 	}
611 
612 	/**
613 	 * Applies any changes that have been made to the settings.  This
614 	 * function does nothing unless @settings is in 'delay-apply' mode;
615 	 * see g_settings_delay().  In the normal case settings are always
616 	 * applied immediately.
617 	 */
618 	public void apply()
619 	{
620 		g_settings_apply(gSettings);
621 	}
622 
623 	/**
624 	 * Create a binding between the @key in the @settings object
625 	 * and the property @property of @object.
626 	 *
627 	 * The binding uses the default GIO mapping functions to map
628 	 * between the settings and property values. These functions
629 	 * handle booleans, numeric types and string types in a
630 	 * straightforward way. Use g_settings_bind_with_mapping() if
631 	 * you need a custom mapping, or map between types that are not
632 	 * supported by the default mapping functions.
633 	 *
634 	 * Unless the @flags include %G_SETTINGS_BIND_NO_SENSITIVITY, this
635 	 * function also establishes a binding between the writability of
636 	 * @key and the "sensitive" property of @object (if @object has
637 	 * a boolean property by that name). See g_settings_bind_writable()
638 	 * for more details about writable bindings.
639 	 *
640 	 * Note that the lifecycle of the binding is tied to @object,
641 	 * and that you can have only one binding per object property.
642 	 * If you bind the same property twice on the same object, the second
643 	 * binding overrides the first one.
644 	 *
645 	 * Params:
646 	 *     key = the key to bind
647 	 *     object = a #GObject
648 	 *     property = the name of the property to bind
649 	 *     flags = flags for the binding
650 	 *
651 	 * Since: 2.26
652 	 */
653 	public void bind(string key, ObjectG object, string property, GSettingsBindFlags flags)
654 	{
655 		g_settings_bind(gSettings, Str.toStringz(key), (object is null) ? null : object.getObjectGStruct(), Str.toStringz(property), flags);
656 	}
657 
658 	/**
659 	 * Create a binding between the @key in the @settings object
660 	 * and the property @property of @object.
661 	 *
662 	 * The binding uses the provided mapping functions to map between
663 	 * settings and property values.
664 	 *
665 	 * Note that the lifecycle of the binding is tied to @object,
666 	 * and that you can have only one binding per object property.
667 	 * If you bind the same property twice on the same object, the second
668 	 * binding overrides the first one.
669 	 *
670 	 * Params:
671 	 *     key = the key to bind
672 	 *     object = a #GObject
673 	 *     property = the name of the property to bind
674 	 *     flags = flags for the binding
675 	 *     getMapping = a function that gets called to convert values
676 	 *         from @settings to @object, or %NULL to use the default GIO mapping
677 	 *     setMapping = a function that gets called to convert values
678 	 *         from @object to @settings, or %NULL to use the default GIO mapping
679 	 *     userData = data that gets passed to @get_mapping and @set_mapping
680 	 *     destroy = #GDestroyNotify function for @user_data
681 	 *
682 	 * Since: 2.26
683 	 */
684 	public void bindWithMapping(string key, ObjectG object, string property, GSettingsBindFlags flags, GSettingsBindGetMapping getMapping, GSettingsBindSetMapping setMapping, void* userData, GDestroyNotify destroy)
685 	{
686 		g_settings_bind_with_mapping(gSettings, Str.toStringz(key), (object is null) ? null : object.getObjectGStruct(), Str.toStringz(property), flags, getMapping, setMapping, userData, destroy);
687 	}
688 
689 	/**
690 	 * Create a binding between the writability of @key in the
691 	 * @settings object and the property @property of @object.
692 	 * The property must be boolean; "sensitive" or "visible"
693 	 * properties of widgets are the most likely candidates.
694 	 *
695 	 * Writable bindings are always uni-directional; changes of the
696 	 * writability of the setting will be propagated to the object
697 	 * property, not the other way.
698 	 *
699 	 * When the @inverted argument is %TRUE, the binding inverts the
700 	 * value as it passes from the setting to the object, i.e. @property
701 	 * will be set to %TRUE if the key is not writable.
702 	 *
703 	 * Note that the lifecycle of the binding is tied to @object,
704 	 * and that you can have only one binding per object property.
705 	 * If you bind the same property twice on the same object, the second
706 	 * binding overrides the first one.
707 	 *
708 	 * Params:
709 	 *     key = the key to bind
710 	 *     object = a #GObject
711 	 *     property = the name of a boolean property to bind
712 	 *     inverted = whether to 'invert' the value
713 	 *
714 	 * Since: 2.26
715 	 */
716 	public void bindWritable(string key, ObjectG object, string property, bool inverted)
717 	{
718 		g_settings_bind_writable(gSettings, Str.toStringz(key), (object is null) ? null : object.getObjectGStruct(), Str.toStringz(property), inverted);
719 	}
720 
721 	/**
722 	 * Creates a #GAction corresponding to a given #GSettings key.
723 	 *
724 	 * The action has the same name as the key.
725 	 *
726 	 * The value of the key becomes the state of the action and the action
727 	 * is enabled when the key is writable.  Changing the state of the
728 	 * action results in the key being written to.  Changes to the value or
729 	 * writability of the key cause appropriate change notifications to be
730 	 * emitted for the action.
731 	 *
732 	 * For boolean-valued keys, action activations take no parameter and
733 	 * result in the toggling of the value.  For all other types,
734 	 * activations take the new value for the key (which must have the
735 	 * correct type).
736 	 *
737 	 * Params:
738 	 *     key = the name of a key in @settings
739 	 *
740 	 * Returns: a new #GAction
741 	 *
742 	 * Since: 2.32
743 	 */
744 	public ActionIF createAction(string key)
745 	{
746 		auto p = g_settings_create_action(gSettings, Str.toStringz(key));
747 
748 		if(p is null)
749 		{
750 			return null;
751 		}
752 
753 		return ObjectG.getDObject!(ActionIF)(cast(GAction*) p, true);
754 	}
755 
756 	/**
757 	 * Changes the #GSettings object into 'delay-apply' mode. In this
758 	 * mode, changes to @settings are not immediately propagated to the
759 	 * backend, but kept locally until g_settings_apply() is called.
760 	 *
761 	 * Since: 2.26
762 	 */
763 	public void delay()
764 	{
765 		g_settings_delay(gSettings);
766 	}
767 
768 	/**
769 	 * Gets the value that is stored at @key in @settings.
770 	 *
771 	 * A convenience variant of g_settings_get() for booleans.
772 	 *
773 	 * It is a programmer error to give a @key that isn't specified as
774 	 * having a boolean type in the schema for @settings.
775 	 *
776 	 * Params:
777 	 *     key = the key to get the value for
778 	 *
779 	 * Returns: a boolean
780 	 *
781 	 * Since: 2.26
782 	 */
783 	public bool getBoolean(string key)
784 	{
785 		return g_settings_get_boolean(gSettings, Str.toStringz(key)) != 0;
786 	}
787 
788 	/**
789 	 * Creates a child settings object which has a base path of
790 	 * `base-path/@name`, where `base-path` is the base path of
791 	 * @settings.
792 	 *
793 	 * The schema for the child settings object must have been declared
794 	 * in the schema of @settings using a <child> element.
795 	 *
796 	 * Params:
797 	 *     name = the name of the child schema
798 	 *
799 	 * Returns: a 'child' settings object
800 	 *
801 	 * Since: 2.26
802 	 */
803 	public Settings getChild(string name)
804 	{
805 		auto p = g_settings_get_child(gSettings, Str.toStringz(name));
806 
807 		if(p is null)
808 		{
809 			return null;
810 		}
811 
812 		return ObjectG.getDObject!(Settings)(cast(GSettings*) p, true);
813 	}
814 
815 	/**
816 	 * Gets the "default value" of a key.
817 	 *
818 	 * This is the value that would be read if g_settings_reset() were to be
819 	 * called on the key.
820 	 *
821 	 * Note that this may be a different value than returned by
822 	 * g_settings_schema_key_get_default_value() if the system administrator
823 	 * has provided a default value.
824 	 *
825 	 * Comparing the return values of g_settings_get_default_value() and
826 	 * g_settings_get_value() is not sufficient for determining if a value
827 	 * has been set because the user may have explicitly set the value to
828 	 * something that happens to be equal to the default.  The difference
829 	 * here is that if the default changes in the future, the user's key
830 	 * will still be set.
831 	 *
832 	 * This function may be useful for adding an indication to a UI of what
833 	 * the default value was before the user set it.
834 	 *
835 	 * It is a programmer error to give a @key that isn't contained in the
836 	 * schema for @settings.
837 	 *
838 	 * Params:
839 	 *     key = the key to get the default value for
840 	 *
841 	 * Returns: the default value
842 	 *
843 	 * Since: 2.40
844 	 */
845 	public Variant getDefaultValue(string key)
846 	{
847 		auto p = g_settings_get_default_value(gSettings, Str.toStringz(key));
848 
849 		if(p is null)
850 		{
851 			return null;
852 		}
853 
854 		return new Variant(cast(GVariant*) p, true);
855 	}
856 
857 	/**
858 	 * Gets the value that is stored at @key in @settings.
859 	 *
860 	 * A convenience variant of g_settings_get() for doubles.
861 	 *
862 	 * It is a programmer error to give a @key that isn't specified as
863 	 * having a 'double' type in the schema for @settings.
864 	 *
865 	 * Params:
866 	 *     key = the key to get the value for
867 	 *
868 	 * Returns: a double
869 	 *
870 	 * Since: 2.26
871 	 */
872 	public double getDouble(string key)
873 	{
874 		return g_settings_get_double(gSettings, Str.toStringz(key));
875 	}
876 
877 	/**
878 	 * Gets the value that is stored in @settings for @key and converts it
879 	 * to the enum value that it represents.
880 	 *
881 	 * In order to use this function the type of the value must be a string
882 	 * and it must be marked in the schema file as an enumerated type.
883 	 *
884 	 * It is a programmer error to give a @key that isn't contained in the
885 	 * schema for @settings or is not marked as an enumerated type.
886 	 *
887 	 * If the value stored in the configuration database is not a valid
888 	 * value for the enumerated type then this function will return the
889 	 * default value.
890 	 *
891 	 * Params:
892 	 *     key = the key to get the value for
893 	 *
894 	 * Returns: the enum value
895 	 *
896 	 * Since: 2.26
897 	 */
898 	public int getEnum(string key)
899 	{
900 		return g_settings_get_enum(gSettings, Str.toStringz(key));
901 	}
902 
903 	/**
904 	 * Gets the value that is stored in @settings for @key and converts it
905 	 * to the flags value that it represents.
906 	 *
907 	 * In order to use this function the type of the value must be an array
908 	 * of strings and it must be marked in the schema file as an flags type.
909 	 *
910 	 * It is a programmer error to give a @key that isn't contained in the
911 	 * schema for @settings or is not marked as a flags type.
912 	 *
913 	 * If the value stored in the configuration database is not a valid
914 	 * value for the flags type then this function will return the default
915 	 * value.
916 	 *
917 	 * Params:
918 	 *     key = the key to get the value for
919 	 *
920 	 * Returns: the flags value
921 	 *
922 	 * Since: 2.26
923 	 */
924 	public uint getFlags(string key)
925 	{
926 		return g_settings_get_flags(gSettings, Str.toStringz(key));
927 	}
928 
929 	/**
930 	 * Returns whether the #GSettings object has any unapplied
931 	 * changes.  This can only be the case if it is in 'delayed-apply' mode.
932 	 *
933 	 * Returns: %TRUE if @settings has unapplied changes
934 	 *
935 	 * Since: 2.26
936 	 */
937 	public bool getHasUnapplied()
938 	{
939 		return g_settings_get_has_unapplied(gSettings) != 0;
940 	}
941 
942 	/**
943 	 * Gets the value that is stored at @key in @settings.
944 	 *
945 	 * A convenience variant of g_settings_get() for 32-bit integers.
946 	 *
947 	 * It is a programmer error to give a @key that isn't specified as
948 	 * having a int32 type in the schema for @settings.
949 	 *
950 	 * Params:
951 	 *     key = the key to get the value for
952 	 *
953 	 * Returns: an integer
954 	 *
955 	 * Since: 2.26
956 	 */
957 	public int getInt(string key)
958 	{
959 		return g_settings_get_int(gSettings, Str.toStringz(key));
960 	}
961 
962 	/**
963 	 * Gets the value that is stored at @key in @settings.
964 	 *
965 	 * A convenience variant of g_settings_get() for 64-bit integers.
966 	 *
967 	 * It is a programmer error to give a @key that isn't specified as
968 	 * having a int64 type in the schema for @settings.
969 	 *
970 	 * Params:
971 	 *     key = the key to get the value for
972 	 *
973 	 * Returns: a 64-bit integer
974 	 *
975 	 * Since: 2.50
976 	 */
977 	public long getInt64(string key)
978 	{
979 		return g_settings_get_int64(gSettings, Str.toStringz(key));
980 	}
981 
982 	/**
983 	 * Gets the value that is stored at @key in @settings, subject to
984 	 * application-level validation/mapping.
985 	 *
986 	 * You should use this function when the application needs to perform
987 	 * some processing on the value of the key (for example, parsing).  The
988 	 * @mapping function performs that processing.  If the function
989 	 * indicates that the processing was unsuccessful (due to a parse error,
990 	 * for example) then the mapping is tried again with another value.
991 	 *
992 	 * This allows a robust 'fall back to defaults' behaviour to be
993 	 * implemented somewhat automatically.
994 	 *
995 	 * The first value that is tried is the user's setting for the key.  If
996 	 * the mapping function fails to map this value, other values may be
997 	 * tried in an unspecified order (system or site defaults, translated
998 	 * schema default values, untranslated schema default values, etc).
999 	 *
1000 	 * If the mapping function fails for all possible values, one additional
1001 	 * attempt is made: the mapping function is called with a %NULL value.
1002 	 * If the mapping function still indicates failure at this point then
1003 	 * the application will be aborted.
1004 	 *
1005 	 * The result parameter for the @mapping function is pointed to a
1006 	 * #gpointer which is initially set to %NULL.  The same pointer is given
1007 	 * to each invocation of @mapping.  The final value of that #gpointer is
1008 	 * what is returned by this function.  %NULL is valid; it is returned
1009 	 * just as any other value would be.
1010 	 *
1011 	 * Params:
1012 	 *     key = the key to get the value for
1013 	 *     mapping = the function to map the value in the
1014 	 *         settings database to the value used by the application
1015 	 *     userData = user data for @mapping
1016 	 *
1017 	 * Returns: the result, which may be %NULL
1018 	 */
1019 	public void* getMapped(string key, GSettingsGetMapping mapping, void* userData)
1020 	{
1021 		return g_settings_get_mapped(gSettings, Str.toStringz(key), mapping, userData);
1022 	}
1023 
1024 	/**
1025 	 * Queries the range of a key.
1026 	 *
1027 	 * Deprecated: Use g_settings_schema_key_get_range() instead.
1028 	 *
1029 	 * Params:
1030 	 *     key = the key to query the range of
1031 	 *
1032 	 * Since: 2.28
1033 	 */
1034 	public Variant getRange(string key)
1035 	{
1036 		auto p = g_settings_get_range(gSettings, Str.toStringz(key));
1037 
1038 		if(p is null)
1039 		{
1040 			return null;
1041 		}
1042 
1043 		return new Variant(cast(GVariant*) p, true);
1044 	}
1045 
1046 	/**
1047 	 * Gets the value that is stored at @key in @settings.
1048 	 *
1049 	 * A convenience variant of g_settings_get() for strings.
1050 	 *
1051 	 * It is a programmer error to give a @key that isn't specified as
1052 	 * having a string type in the schema for @settings.
1053 	 *
1054 	 * Params:
1055 	 *     key = the key to get the value for
1056 	 *
1057 	 * Returns: a newly-allocated string
1058 	 *
1059 	 * Since: 2.26
1060 	 */
1061 	public string getString(string key)
1062 	{
1063 		auto retStr = g_settings_get_string(gSettings, Str.toStringz(key));
1064 
1065 		scope(exit) Str.freeString(retStr);
1066 		return Str.toString(retStr);
1067 	}
1068 
1069 	/**
1070 	 * A convenience variant of g_settings_get() for string arrays.
1071 	 *
1072 	 * It is a programmer error to give a @key that isn't specified as
1073 	 * having an array of strings type in the schema for @settings.
1074 	 *
1075 	 * Params:
1076 	 *     key = the key to get the value for
1077 	 *
1078 	 * Returns: a
1079 	 *     newly-allocated, %NULL-terminated array of strings, the value that
1080 	 *     is stored at @key in @settings.
1081 	 *
1082 	 * Since: 2.26
1083 	 */
1084 	public string[] getStrv(string key)
1085 	{
1086 		auto retStr = g_settings_get_strv(gSettings, Str.toStringz(key));
1087 
1088 		scope(exit) Str.freeStringArray(retStr);
1089 		return Str.toStringArray(retStr);
1090 	}
1091 
1092 	/**
1093 	 * Gets the value that is stored at @key in @settings.
1094 	 *
1095 	 * A convenience variant of g_settings_get() for 32-bit unsigned
1096 	 * integers.
1097 	 *
1098 	 * It is a programmer error to give a @key that isn't specified as
1099 	 * having a uint32 type in the schema for @settings.
1100 	 *
1101 	 * Params:
1102 	 *     key = the key to get the value for
1103 	 *
1104 	 * Returns: an unsigned integer
1105 	 *
1106 	 * Since: 2.30
1107 	 */
1108 	public uint getUint(string key)
1109 	{
1110 		return g_settings_get_uint(gSettings, Str.toStringz(key));
1111 	}
1112 
1113 	/**
1114 	 * Gets the value that is stored at @key in @settings.
1115 	 *
1116 	 * A convenience variant of g_settings_get() for 64-bit unsigned
1117 	 * integers.
1118 	 *
1119 	 * It is a programmer error to give a @key that isn't specified as
1120 	 * having a uint64 type in the schema for @settings.
1121 	 *
1122 	 * Params:
1123 	 *     key = the key to get the value for
1124 	 *
1125 	 * Returns: a 64-bit unsigned integer
1126 	 *
1127 	 * Since: 2.50
1128 	 */
1129 	public ulong getUint64(string key)
1130 	{
1131 		return g_settings_get_uint64(gSettings, Str.toStringz(key));
1132 	}
1133 
1134 	/**
1135 	 * Checks the "user value" of a key, if there is one.
1136 	 *
1137 	 * The user value of a key is the last value that was set by the user.
1138 	 *
1139 	 * After calling g_settings_reset() this function should always return
1140 	 * %NULL (assuming something is not wrong with the system
1141 	 * configuration).
1142 	 *
1143 	 * It is possible that g_settings_get_value() will return a different
1144 	 * value than this function.  This can happen in the case that the user
1145 	 * set a value for a key that was subsequently locked down by the system
1146 	 * administrator -- this function will return the user's old value.
1147 	 *
1148 	 * This function may be useful for adding a "reset" option to a UI or
1149 	 * for providing indication that a particular value has been changed.
1150 	 *
1151 	 * It is a programmer error to give a @key that isn't contained in the
1152 	 * schema for @settings.
1153 	 *
1154 	 * Params:
1155 	 *     key = the key to get the user value for
1156 	 *
1157 	 * Returns: the user's value, if set
1158 	 *
1159 	 * Since: 2.40
1160 	 */
1161 	public Variant getUserValue(string key)
1162 	{
1163 		auto p = g_settings_get_user_value(gSettings, Str.toStringz(key));
1164 
1165 		if(p is null)
1166 		{
1167 			return null;
1168 		}
1169 
1170 		return new Variant(cast(GVariant*) p, true);
1171 	}
1172 
1173 	/**
1174 	 * Gets the value that is stored in @settings for @key.
1175 	 *
1176 	 * It is a programmer error to give a @key that isn't contained in the
1177 	 * schema for @settings.
1178 	 *
1179 	 * Params:
1180 	 *     key = the key to get the value for
1181 	 *
1182 	 * Returns: a new #GVariant
1183 	 *
1184 	 * Since: 2.26
1185 	 */
1186 	public Variant getValue(string key)
1187 	{
1188 		auto p = g_settings_get_value(gSettings, Str.toStringz(key));
1189 
1190 		if(p is null)
1191 		{
1192 			return null;
1193 		}
1194 
1195 		return new Variant(cast(GVariant*) p, true);
1196 	}
1197 
1198 	/**
1199 	 * Finds out if a key can be written or not
1200 	 *
1201 	 * Params:
1202 	 *     name = the name of a key
1203 	 *
1204 	 * Returns: %TRUE if the key @name is writable
1205 	 *
1206 	 * Since: 2.26
1207 	 */
1208 	public bool isWritable(string name)
1209 	{
1210 		return g_settings_is_writable(gSettings, Str.toStringz(name)) != 0;
1211 	}
1212 
1213 	/**
1214 	 * Gets the list of children on @settings.
1215 	 *
1216 	 * The list is exactly the list of strings for which it is not an error
1217 	 * to call g_settings_get_child().
1218 	 *
1219 	 * There is little reason to call this function from "normal" code, since
1220 	 * you should already know what children are in your schema. This function
1221 	 * may still be useful there for introspection reasons, however.
1222 	 *
1223 	 * You should free the return value with g_strfreev() when you are done
1224 	 * with it.
1225 	 *
1226 	 * Returns: a list of the children on @settings
1227 	 */
1228 	public string[] listChildren()
1229 	{
1230 		auto retStr = g_settings_list_children(gSettings);
1231 
1232 		scope(exit) Str.freeStringArray(retStr);
1233 		return Str.toStringArray(retStr);
1234 	}
1235 
1236 	/**
1237 	 * Introspects the list of keys on @settings.
1238 	 *
1239 	 * You should probably not be calling this function from "normal" code
1240 	 * (since you should already know what keys are in your schema).  This
1241 	 * function is intended for introspection reasons.
1242 	 *
1243 	 * You should free the return value with g_strfreev() when you are done
1244 	 * with it.
1245 	 *
1246 	 * Returns: a list of the keys on @settings
1247 	 */
1248 	public string[] listKeys()
1249 	{
1250 		auto retStr = g_settings_list_keys(gSettings);
1251 
1252 		scope(exit) Str.freeStringArray(retStr);
1253 		return Str.toStringArray(retStr);
1254 	}
1255 
1256 	/**
1257 	 * Checks if the given @value is of the correct type and within the
1258 	 * permitted range for @key.
1259 	 *
1260 	 * Deprecated: Use g_settings_schema_key_range_check() instead.
1261 	 *
1262 	 * Params:
1263 	 *     key = the key to check
1264 	 *     value = the value to check
1265 	 *
1266 	 * Returns: %TRUE if @value is valid for @key
1267 	 *
1268 	 * Since: 2.28
1269 	 */
1270 	public bool rangeCheck(string key, Variant value)
1271 	{
1272 		return g_settings_range_check(gSettings, Str.toStringz(key), (value is null) ? null : value.getVariantStruct()) != 0;
1273 	}
1274 
1275 	/**
1276 	 * Resets @key to its default value.
1277 	 *
1278 	 * This call resets the key, as much as possible, to its default value.
1279 	 * That might the value specified in the schema or the one set by the
1280 	 * administrator.
1281 	 *
1282 	 * Params:
1283 	 *     key = the name of a key
1284 	 */
1285 	public void reset(string key)
1286 	{
1287 		g_settings_reset(gSettings, Str.toStringz(key));
1288 	}
1289 
1290 	/**
1291 	 * Reverts all non-applied changes to the settings.  This function
1292 	 * does nothing unless @settings is in 'delay-apply' mode; see
1293 	 * g_settings_delay().  In the normal case settings are always applied
1294 	 * immediately.
1295 	 *
1296 	 * Change notifications will be emitted for affected keys.
1297 	 */
1298 	public void revert()
1299 	{
1300 		g_settings_revert(gSettings);
1301 	}
1302 
1303 	/**
1304 	 * Sets @key in @settings to @value.
1305 	 *
1306 	 * A convenience variant of g_settings_set() for booleans.
1307 	 *
1308 	 * It is a programmer error to give a @key that isn't specified as
1309 	 * having a boolean type in the schema for @settings.
1310 	 *
1311 	 * Params:
1312 	 *     key = the name of the key to set
1313 	 *     value = the value to set it to
1314 	 *
1315 	 * Returns: %TRUE if setting the key succeeded,
1316 	 *     %FALSE if the key was not writable
1317 	 *
1318 	 * Since: 2.26
1319 	 */
1320 	public bool setBoolean(string key, bool value)
1321 	{
1322 		return g_settings_set_boolean(gSettings, Str.toStringz(key), value) != 0;
1323 	}
1324 
1325 	/**
1326 	 * Sets @key in @settings to @value.
1327 	 *
1328 	 * A convenience variant of g_settings_set() for doubles.
1329 	 *
1330 	 * It is a programmer error to give a @key that isn't specified as
1331 	 * having a 'double' type in the schema for @settings.
1332 	 *
1333 	 * Params:
1334 	 *     key = the name of the key to set
1335 	 *     value = the value to set it to
1336 	 *
1337 	 * Returns: %TRUE if setting the key succeeded,
1338 	 *     %FALSE if the key was not writable
1339 	 *
1340 	 * Since: 2.26
1341 	 */
1342 	public bool setDouble(string key, double value)
1343 	{
1344 		return g_settings_set_double(gSettings, Str.toStringz(key), value) != 0;
1345 	}
1346 
1347 	/**
1348 	 * Looks up the enumerated type nick for @value and writes it to @key,
1349 	 * within @settings.
1350 	 *
1351 	 * It is a programmer error to give a @key that isn't contained in the
1352 	 * schema for @settings or is not marked as an enumerated type, or for
1353 	 * @value not to be a valid value for the named type.
1354 	 *
1355 	 * After performing the write, accessing @key directly with
1356 	 * g_settings_get_string() will return the 'nick' associated with
1357 	 * @value.
1358 	 *
1359 	 * Params:
1360 	 *     key = a key, within @settings
1361 	 *     value = an enumerated value
1362 	 *
1363 	 * Returns: %TRUE, if the set succeeds
1364 	 */
1365 	public bool setEnum(string key, int value)
1366 	{
1367 		return g_settings_set_enum(gSettings, Str.toStringz(key), value) != 0;
1368 	}
1369 
1370 	/**
1371 	 * Looks up the flags type nicks for the bits specified by @value, puts
1372 	 * them in an array of strings and writes the array to @key, within
1373 	 * @settings.
1374 	 *
1375 	 * It is a programmer error to give a @key that isn't contained in the
1376 	 * schema for @settings or is not marked as a flags type, or for @value
1377 	 * to contain any bits that are not value for the named type.
1378 	 *
1379 	 * After performing the write, accessing @key directly with
1380 	 * g_settings_get_strv() will return an array of 'nicks'; one for each
1381 	 * bit in @value.
1382 	 *
1383 	 * Params:
1384 	 *     key = a key, within @settings
1385 	 *     value = a flags value
1386 	 *
1387 	 * Returns: %TRUE, if the set succeeds
1388 	 */
1389 	public bool setFlags(string key, uint value)
1390 	{
1391 		return g_settings_set_flags(gSettings, Str.toStringz(key), value) != 0;
1392 	}
1393 
1394 	/**
1395 	 * Sets @key in @settings to @value.
1396 	 *
1397 	 * A convenience variant of g_settings_set() for 32-bit integers.
1398 	 *
1399 	 * It is a programmer error to give a @key that isn't specified as
1400 	 * having a int32 type in the schema for @settings.
1401 	 *
1402 	 * Params:
1403 	 *     key = the name of the key to set
1404 	 *     value = the value to set it to
1405 	 *
1406 	 * Returns: %TRUE if setting the key succeeded,
1407 	 *     %FALSE if the key was not writable
1408 	 *
1409 	 * Since: 2.26
1410 	 */
1411 	public bool setInt(string key, int value)
1412 	{
1413 		return g_settings_set_int(gSettings, Str.toStringz(key), value) != 0;
1414 	}
1415 
1416 	/**
1417 	 * Sets @key in @settings to @value.
1418 	 *
1419 	 * A convenience variant of g_settings_set() for 64-bit integers.
1420 	 *
1421 	 * It is a programmer error to give a @key that isn't specified as
1422 	 * having a int64 type in the schema for @settings.
1423 	 *
1424 	 * Params:
1425 	 *     key = the name of the key to set
1426 	 *     value = the value to set it to
1427 	 *
1428 	 * Returns: %TRUE if setting the key succeeded,
1429 	 *     %FALSE if the key was not writable
1430 	 *
1431 	 * Since: 2.50
1432 	 */
1433 	public bool setInt64(string key, long value)
1434 	{
1435 		return g_settings_set_int64(gSettings, Str.toStringz(key), value) != 0;
1436 	}
1437 
1438 	/**
1439 	 * Sets @key in @settings to @value.
1440 	 *
1441 	 * A convenience variant of g_settings_set() for strings.
1442 	 *
1443 	 * It is a programmer error to give a @key that isn't specified as
1444 	 * having a string type in the schema for @settings.
1445 	 *
1446 	 * Params:
1447 	 *     key = the name of the key to set
1448 	 *     value = the value to set it to
1449 	 *
1450 	 * Returns: %TRUE if setting the key succeeded,
1451 	 *     %FALSE if the key was not writable
1452 	 *
1453 	 * Since: 2.26
1454 	 */
1455 	public bool setString(string key, string value)
1456 	{
1457 		return g_settings_set_string(gSettings, Str.toStringz(key), Str.toStringz(value)) != 0;
1458 	}
1459 
1460 	/**
1461 	 * Sets @key in @settings to @value.
1462 	 *
1463 	 * A convenience variant of g_settings_set() for string arrays.  If
1464 	 * @value is %NULL, then @key is set to be the empty array.
1465 	 *
1466 	 * It is a programmer error to give a @key that isn't specified as
1467 	 * having an array of strings type in the schema for @settings.
1468 	 *
1469 	 * Params:
1470 	 *     key = the name of the key to set
1471 	 *     value = the value to set it to, or %NULL
1472 	 *
1473 	 * Returns: %TRUE if setting the key succeeded,
1474 	 *     %FALSE if the key was not writable
1475 	 *
1476 	 * Since: 2.26
1477 	 */
1478 	public bool setStrv(string key, string[] value)
1479 	{
1480 		return g_settings_set_strv(gSettings, Str.toStringz(key), Str.toStringzArray(value)) != 0;
1481 	}
1482 
1483 	/**
1484 	 * Sets @key in @settings to @value.
1485 	 *
1486 	 * A convenience variant of g_settings_set() for 32-bit unsigned
1487 	 * integers.
1488 	 *
1489 	 * It is a programmer error to give a @key that isn't specified as
1490 	 * having a uint32 type in the schema for @settings.
1491 	 *
1492 	 * Params:
1493 	 *     key = the name of the key to set
1494 	 *     value = the value to set it to
1495 	 *
1496 	 * Returns: %TRUE if setting the key succeeded,
1497 	 *     %FALSE if the key was not writable
1498 	 *
1499 	 * Since: 2.30
1500 	 */
1501 	public bool setUint(string key, uint value)
1502 	{
1503 		return g_settings_set_uint(gSettings, Str.toStringz(key), value) != 0;
1504 	}
1505 
1506 	/**
1507 	 * Sets @key in @settings to @value.
1508 	 *
1509 	 * A convenience variant of g_settings_set() for 64-bit unsigned
1510 	 * integers.
1511 	 *
1512 	 * It is a programmer error to give a @key that isn't specified as
1513 	 * having a uint64 type in the schema for @settings.
1514 	 *
1515 	 * Params:
1516 	 *     key = the name of the key to set
1517 	 *     value = the value to set it to
1518 	 *
1519 	 * Returns: %TRUE if setting the key succeeded,
1520 	 *     %FALSE if the key was not writable
1521 	 *
1522 	 * Since: 2.50
1523 	 */
1524 	public bool setUint64(string key, ulong value)
1525 	{
1526 		return g_settings_set_uint64(gSettings, Str.toStringz(key), value) != 0;
1527 	}
1528 
1529 	/**
1530 	 * Sets @key in @settings to @value.
1531 	 *
1532 	 * It is a programmer error to give a @key that isn't contained in the
1533 	 * schema for @settings or for @value to have the incorrect type, per
1534 	 * the schema.
1535 	 *
1536 	 * If @value is floating then this function consumes the reference.
1537 	 *
1538 	 * Params:
1539 	 *     key = the name of the key to set
1540 	 *     value = a #GVariant of the correct type
1541 	 *
1542 	 * Returns: %TRUE if setting the key succeeded,
1543 	 *     %FALSE if the key was not writable
1544 	 *
1545 	 * Since: 2.26
1546 	 */
1547 	public bool setValue(string key, Variant value)
1548 	{
1549 		return g_settings_set_value(gSettings, Str.toStringz(key), (value is null) ? null : value.getVariantStruct()) != 0;
1550 	}
1551 
1552 	/**
1553 	 * The "change-event" signal is emitted once per change event that
1554 	 * affects this settings object.  You should connect to this signal
1555 	 * only if you are interested in viewing groups of changes before they
1556 	 * are split out into multiple emissions of the "changed" signal.
1557 	 * For most use cases it is more appropriate to use the "changed" signal.
1558 	 *
1559 	 * In the event that the change event applies to one or more specified
1560 	 * keys, @keys will be an array of #GQuark of length @n_keys.  In the
1561 	 * event that the change event applies to the #GSettings object as a
1562 	 * whole (ie: potentially every key has been changed) then @keys will
1563 	 * be %NULL and @n_keys will be 0.
1564 	 *
1565 	 * The default handler for this signal invokes the "changed" signal
1566 	 * for each affected key.  If any other connected handler returns
1567 	 * %TRUE then this default functionality will be suppressed.
1568 	 *
1569 	 * Params:
1570 	 *     keys = an array of #GQuarks for the changed keys, or %NULL
1571 	 *     nKeys = the length of the @keys array, or 0
1572 	 *
1573 	 * Returns: %TRUE to stop other handlers from being invoked for the
1574 	 *     event. FALSE to propagate the event further.
1575 	 */
1576 	gulong addOnChange(bool delegate(void*, int, Settings) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1577 	{
1578 		return Signals.connect(this, "change-event", dlg, connectFlags ^ ConnectFlags.SWAPPED);
1579 	}
1580 
1581 	/**
1582 	 * The "changed" signal is emitted when a key has potentially changed.
1583 	 * You should call one of the g_settings_get() calls to check the new
1584 	 * value.
1585 	 *
1586 	 * This signal supports detailed connections.  You can connect to the
1587 	 * detailed signal "changed::x" in order to only receive callbacks
1588 	 * when key "x" changes.
1589 	 *
1590 	 * Note that @settings only emits this signal if you have read @key at
1591 	 * least once while a signal handler was already connected for @key.
1592 	 *
1593 	 * Params:
1594 	 *     key = the name of the key that changed
1595 	 */
1596 	gulong addOnChanged(void delegate(string, Settings) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1597 	{
1598 		return Signals.connect(this, "changed", dlg, connectFlags ^ ConnectFlags.SWAPPED);
1599 	}
1600 
1601 	/**
1602 	 * The "writable-change-event" signal is emitted once per writability
1603 	 * change event that affects this settings object.  You should connect
1604 	 * to this signal if you are interested in viewing groups of changes
1605 	 * before they are split out into multiple emissions of the
1606 	 * "writable-changed" signal.  For most use cases it is more
1607 	 * appropriate to use the "writable-changed" signal.
1608 	 *
1609 	 * In the event that the writability change applies only to a single
1610 	 * key, @key will be set to the #GQuark for that key.  In the event
1611 	 * that the writability change affects the entire settings object,
1612 	 * @key will be 0.
1613 	 *
1614 	 * The default handler for this signal invokes the "writable-changed"
1615 	 * and "changed" signals for each affected key.  This is done because
1616 	 * changes in writability might also imply changes in value (if for
1617 	 * example, a new mandatory setting is introduced).  If any other
1618 	 * connected handler returns %TRUE then this default functionality
1619 	 * will be suppressed.
1620 	 *
1621 	 * Params:
1622 	 *     key = the quark of the key, or 0
1623 	 *
1624 	 * Returns: %TRUE to stop other handlers from being invoked for the
1625 	 *     event. FALSE to propagate the event further.
1626 	 */
1627 	gulong addOnWritableChange(bool delegate(uint, Settings) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1628 	{
1629 		return Signals.connect(this, "writable-change-event", dlg, connectFlags ^ ConnectFlags.SWAPPED);
1630 	}
1631 
1632 	/**
1633 	 * The "writable-changed" signal is emitted when the writability of a
1634 	 * key has potentially changed.  You should call
1635 	 * g_settings_is_writable() in order to determine the new status.
1636 	 *
1637 	 * This signal supports detailed connections.  You can connect to the
1638 	 * detailed signal "writable-changed::x" in order to only receive
1639 	 * callbacks when the writability of "x" changes.
1640 	 *
1641 	 * Params:
1642 	 *     key = the key
1643 	 */
1644 	gulong addOnWritableChanged(void delegate(string, Settings) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1645 	{
1646 		return Signals.connect(this, "writable-changed", dlg, connectFlags ^ ConnectFlags.SWAPPED);
1647 	}
1648 }