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.Action; 28 private import gio.ActionIF; 29 private import gio.SettingsBackend; 30 private import gio.SettingsSchema; 31 private import glib.ConstructionException; 32 private import glib.Str; 33 private import glib.Variant; 34 private import gobject.ObjectG; 35 private import gobject.Signals; 36 private import gtkc.gio; 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 as 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 * </schema> 164 * </schemalist> 165 * ]| 166 * 167 * An example for ranges, choices and enumerated types: 168 * |[ 169 * <schemalist> 170 * 171 * <enum id="org.gtk.Test.myenum"> 172 * <value nick="first" value="1"/> 173 * <value nick="second" value="2"/> 174 * </enum> 175 * 176 * <flags id="org.gtk.Test.myflags"> 177 * <value nick="flag1" value="1"/> 178 * <value nick="flag2" value="2"/> 179 * <value nick="flag3" value="4"/> 180 * </flags> 181 * 182 * <schema id="org.gtk.Test"> 183 * 184 * <key name="key-with-range" type="i"> 185 * <range min="1" max="100"/> 186 * <default>10</default> 187 * </key> 188 * 189 * <key name="key-with-choices" type="s"> 190 * <choices> 191 * <choice value='Elisabeth'/> 192 * <choice value='Annabeth'/> 193 * <choice value='Joe'/> 194 * </choices> 195 * <aliases> 196 * <alias value='Anna' target='Annabeth'/> 197 * <alias value='Beth' target='Elisabeth'/> 198 * </aliases> 199 * <default>'Joe'</default> 200 * </key> 201 * 202 * <key name='enumerated-key' enum='org.gtk.Test.myenum'> 203 * <default>'first'</default> 204 * </key> 205 * 206 * <key name='flags-key' flags='org.gtk.Test.myflags'> 207 * <default>["flag1","flag2"]</default> 208 * </key> 209 * </schema> 210 * </schemalist> 211 * ]| 212 * 213 * ## Vendor overrides 214 * 215 * Default values are defined in the schemas that get installed by 216 * an application. Sometimes, it is necessary for a vendor or distributor 217 * to adjust these defaults. Since patching the XML source for the schema 218 * is inconvenient and error-prone, 219 * [glib-compile-schemas][glib-compile-schemas] reads so-called vendor 220 * override' files. These are keyfiles in the same directory as the XML 221 * schema sources which can override default values. The schema id serves 222 * as the group name in the key file, and the values are expected in 223 * serialized GVariant form, as in the following example: 224 * |[ 225 * [org.gtk.Example] 226 * key1='string' 227 * key2=1.5 228 * ]| 229 * 230 * glib-compile-schemas expects schema files to have the extension 231 * `.gschema.override`. 232 * 233 * ## Binding 234 * 235 * A very convenient feature of GSettings lets you bind #GObject properties 236 * directly to settings, using g_settings_bind(). Once a GObject property 237 * has been bound to a setting, changes on either side are automatically 238 * propagated to the other side. GSettings handles details like mapping 239 * between GObject and GVariant types, and preventing infinite cycles. 240 * 241 * This makes it very easy to hook up a preferences dialog to the 242 * underlying settings. To make this even more convenient, GSettings 243 * looks for a boolean property with the name "sensitivity" and 244 * automatically binds it to the writability of the bound setting. 245 * If this 'magic' gets in the way, it can be suppressed with the 246 * #G_SETTINGS_BIND_NO_SENSITIVITY flag. 247 * 248 * ## Relocatable schemas # {#gsettings-relocatable} 249 * 250 * A relocatable schema is one with no `path` attribute specified on its 251 * <schema> element. By using g_settings_new_with_path(), a #GSettings object 252 * can be instantiated for a relocatable schema, assigning a path to the 253 * instance. Paths passed to g_settings_new_with_path() will typically be 254 * constructed dynamically from a constant prefix plus some form of instance 255 * identifier; but they must still be valid GSettings paths. Paths could also 256 * be constant and used with a globally installed schema originating from a 257 * dependency library. 258 * 259 * For example, a relocatable schema could be used to store geometry information 260 * for different windows in an application. If the schema ID was 261 * `org.foo.MyApp.Window`, it could be instantiated for paths 262 * `/org/foo/MyApp/main/`, `/org/foo/MyApp/document-1/`, 263 * `/org/foo/MyApp/document-2/`, etc. If any of the paths are well-known 264 * they can be specified as <child> elements in the parent schema, e.g.: 265 * |[ 266 * <schema id="org.foo.MyApp" path="/org/foo/MyApp/"> 267 * <child name="main" schema="org.foo.MyApp.Window"/> 268 * </schema> 269 * ]| 270 * 271 * ## Build system integration # {#gsettings-build-system} 272 * 273 * GSettings comes with autotools integration to simplify compiling and 274 * installing schemas. To add GSettings support to an application, add the 275 * following to your `configure.ac`: 276 * |[ 277 * GLIB_GSETTINGS 278 * ]| 279 * 280 * In the appropriate `Makefile.am`, use the following snippet to compile and 281 * install the named schema: 282 * |[ 283 * gsettings_SCHEMAS = org.foo.MyApp.gschema.xml 284 * EXTRA_DIST = $(gsettings_SCHEMAS) 285 * 286 * @GSETTINGS_RULES@ 287 * ]| 288 * 289 * No changes are needed to the build system to mark a schema XML file for 290 * translation. Assuming it sets the `gettext-domain` attribute, a schema may 291 * be marked for translation by adding it to `POTFILES.in`, assuming gettext 292 * 0.19 is in use (the preferred method for translation): 293 * |[ 294 * data/org.foo.MyApp.gschema.xml 295 * ]| 296 * 297 * Alternatively, if intltool 0.50.1 is in use: 298 * |[ 299 * [type: gettext/gsettings]data/org.foo.MyApp.gschema.xml 300 * ]| 301 * 302 * GSettings will use gettext to look up translations for the <summary> and 303 * <description> elements, and also any <default> elements which have a `l10n` 304 * attribute set. Translations must not be included in the `.gschema.xml` file 305 * by the build system, for example by using intltool XML rules with a 306 * `.gschema.xml.in` template. 307 * 308 * If an enumerated type defined in a C header file is to be used in a GSettings 309 * schema, it can either be defined manually using an <enum> element in the 310 * schema XML, or it can be extracted automatically from the C header. This 311 * approach is preferred, as it ensures the two representations are always 312 * synchronised. To do so, add the following to the relevant `Makefile.am`: 313 * |[ 314 * gsettings_ENUM_NAMESPACE = org.foo.MyApp 315 * gsettings_ENUM_FILES = my-app-enums.h my-app-misc.h 316 * ]| 317 * 318 * `gsettings_ENUM_NAMESPACE` specifies the schema namespace for the enum files, 319 * which are specified in `gsettings_ENUM_FILES`. This will generate a 320 * `org.foo.MyApp.enums.xml` file containing the extracted enums, which will be 321 * automatically included in the schema compilation, install and uninstall 322 * rules. It should not be committed to version control or included in 323 * `EXTRA_DIST`. 324 */ 325 public class Settings : ObjectG 326 { 327 /** the main Gtk struct */ 328 protected GSettings* gSettings; 329 330 /** Get the main Gtk struct */ 331 public GSettings* getSettingsStruct(bool transferOwnership = false) 332 { 333 if (transferOwnership) 334 ownedRef = false; 335 return gSettings; 336 } 337 338 /** the main Gtk struct as a void* */ 339 protected override void* getStruct() 340 { 341 return cast(void*)gSettings; 342 } 343 344 protected override void setStruct(GObject* obj) 345 { 346 gSettings = cast(GSettings*)obj; 347 super.setStruct(obj); 348 } 349 350 /** 351 * Sets our main struct and passes it to the parent class. 352 */ 353 public this (GSettings* gSettings, bool ownedRef = false) 354 { 355 this.gSettings = gSettings; 356 super(cast(GObject*)gSettings, ownedRef); 357 } 358 359 360 /** */ 361 public static GType getType() 362 { 363 return g_settings_get_type(); 364 } 365 366 /** 367 * Creates a new #GSettings object with the schema specified by 368 * @schema_id. 369 * 370 * Signals on the newly created #GSettings object will be dispatched 371 * via the thread-default #GMainContext in effect at the time of the 372 * call to g_settings_new(). The new #GSettings will hold a reference 373 * on the context. See g_main_context_push_thread_default(). 374 * 375 * Params: 376 * schemaId = the id of the schema 377 * 378 * Returns: a new #GSettings object 379 * 380 * Since: 2.26 381 * 382 * Throws: ConstructionException GTK+ fails to create the object. 383 */ 384 public this(string schemaId) 385 { 386 auto p = g_settings_new(Str.toStringz(schemaId)); 387 388 if(p is null) 389 { 390 throw new ConstructionException("null returned by new"); 391 } 392 393 this(cast(GSettings*) p, true); 394 } 395 396 /** 397 * Creates a new #GSettings object with a given schema, backend and 398 * path. 399 * 400 * It should be extremely rare that you ever want to use this function. 401 * It is made available for advanced use-cases (such as plugin systems 402 * that want to provide access to schemas loaded from custom locations, 403 * etc). 404 * 405 * At the most basic level, a #GSettings object is a pure composition of 406 * 4 things: a #GSettingsSchema, a #GSettingsBackend, a path within that 407 * backend, and a #GMainContext to which signals are dispatched. 408 * 409 * This constructor therefore gives you full control over constructing 410 * #GSettings instances. The first 3 parameters are given directly as 411 * @schema, @backend and @path, and the main context is taken from the 412 * thread-default (as per g_settings_new()). 413 * 414 * If @backend is %NULL then the default backend is used. 415 * 416 * If @path is %NULL then the path from the schema is used. It is an 417 * error if @path is %NULL and the schema has no path of its own or if 418 * @path is non-%NULL and not equal to the path that the schema does 419 * have. 420 * 421 * Params: 422 * schema = a #GSettingsSchema 423 * backend = a #GSettingsBackend 424 * path = the path to use 425 * 426 * Returns: a new #GSettings object 427 * 428 * Since: 2.32 429 * 430 * Throws: ConstructionException GTK+ fails to create the object. 431 */ 432 public this(SettingsSchema schema, SettingsBackend backend, string path) 433 { 434 auto p = g_settings_new_full((schema is null) ? null : schema.getSettingsSchemaStruct(), (backend is null) ? null : backend.getSettingsBackendStruct(), Str.toStringz(path)); 435 436 if(p is null) 437 { 438 throw new ConstructionException("null returned by new_full"); 439 } 440 441 this(cast(GSettings*) p, true); 442 } 443 444 /** 445 * Creates a new #GSettings object with the schema specified by 446 * @schema_id and a given #GSettingsBackend. 447 * 448 * Creating a #GSettings object with a different backend allows accessing 449 * settings from a database other than the usual one. For example, it may make 450 * sense to pass a backend corresponding to the "defaults" settings database on 451 * the system to get a settings object that modifies the system default 452 * settings instead of the settings for this user. 453 * 454 * Params: 455 * schemaId = the id of the schema 456 * backend = the #GSettingsBackend to use 457 * 458 * Returns: a new #GSettings object 459 * 460 * Since: 2.26 461 * 462 * Throws: ConstructionException GTK+ fails to create the object. 463 */ 464 public this(string schemaId, SettingsBackend backend) 465 { 466 auto p = g_settings_new_with_backend(Str.toStringz(schemaId), (backend is null) ? null : backend.getSettingsBackendStruct()); 467 468 if(p is null) 469 { 470 throw new ConstructionException("null returned by new_with_backend"); 471 } 472 473 this(cast(GSettings*) p, true); 474 } 475 476 /** 477 * Creates a new #GSettings object with the schema specified by 478 * @schema_id and a given #GSettingsBackend and path. 479 * 480 * This is a mix of g_settings_new_with_backend() and 481 * g_settings_new_with_path(). 482 * 483 * Params: 484 * schemaId = the id of the schema 485 * backend = the #GSettingsBackend to use 486 * path = the path to use 487 * 488 * Returns: a new #GSettings object 489 * 490 * Since: 2.26 491 * 492 * Throws: ConstructionException GTK+ fails to create the object. 493 */ 494 public this(string schemaId, SettingsBackend backend, string path) 495 { 496 auto p = g_settings_new_with_backend_and_path(Str.toStringz(schemaId), (backend is null) ? null : backend.getSettingsBackendStruct(), Str.toStringz(path)); 497 498 if(p is null) 499 { 500 throw new ConstructionException("null returned by new_with_backend_and_path"); 501 } 502 503 this(cast(GSettings*) p, true); 504 } 505 506 /** 507 * Creates a new #GSettings object with the relocatable schema specified 508 * by @schema_id and a given path. 509 * 510 * You only need to do this if you want to directly create a settings 511 * object with a schema that doesn't have a specified path of its own. 512 * That's quite rare. 513 * 514 * It is a programmer error to call this function for a schema that 515 * has an explicitly specified path. 516 * 517 * It is a programmer error if @path is not a valid path. A valid path 518 * begins and ends with '/' and does not contain two consecutive '/' 519 * characters. 520 * 521 * Params: 522 * schemaId = the id of the schema 523 * path = the path to use 524 * 525 * Returns: a new #GSettings object 526 * 527 * Since: 2.26 528 * 529 * Throws: ConstructionException GTK+ fails to create the object. 530 */ 531 public this(string schemaId, string path) 532 { 533 auto p = g_settings_new_with_path(Str.toStringz(schemaId), Str.toStringz(path)); 534 535 if(p is null) 536 { 537 throw new ConstructionException("null returned by new_with_path"); 538 } 539 540 this(cast(GSettings*) p, true); 541 } 542 543 /** 544 * <!-- --> 545 * 546 * Deprecated: Use g_settings_schema_source_list_schemas() instead 547 * 548 * Returns: a list of relocatable 549 * #GSettings schemas that are available. The list must not be 550 * modified or freed. 551 * 552 * Since: 2.28 553 */ 554 public static string[] listRelocatableSchemas() 555 { 556 return Str.toStringArray(g_settings_list_relocatable_schemas()); 557 } 558 559 /** 560 * <!-- --> 561 * 562 * Deprecated: Use g_settings_schema_source_list_schemas() instead. 563 * If you used g_settings_list_schemas() to check for the presence of 564 * a particular schema, use g_settings_schema_source_lookup() instead 565 * of your whole loop. 566 * 567 * Returns: a list of #GSettings 568 * schemas that are available. The list must not be modified or 569 * freed. 570 * 571 * Since: 2.26 572 */ 573 public static string[] listSchemas() 574 { 575 return Str.toStringArray(g_settings_list_schemas()); 576 } 577 578 /** 579 * Ensures that all pending operations for the given are complete for 580 * the default backend. 581 * 582 * Writes made to a #GSettings are handled asynchronously. For this 583 * reason, it is very unlikely that the changes have it to disk by the 584 * time g_settings_set() returns. 585 * 586 * This call will block until all of the writes have made it to the 587 * backend. Since the mainloop is not running, no change notifications 588 * will be dispatched during this call (but some may be queued by the 589 * time the call is done). 590 */ 591 public static void sync() 592 { 593 g_settings_sync(); 594 } 595 596 /** 597 * Removes an existing binding for @property on @object. 598 * 599 * Note that bindings are automatically removed when the 600 * object is finalized, so it is rarely necessary to call this 601 * function. 602 * 603 * Params: 604 * object = the object 605 * property = the property whose binding is removed 606 * 607 * Since: 2.26 608 */ 609 public static void unbind(ObjectG object, string property) 610 { 611 g_settings_unbind((object is null) ? null : object.getObjectGStruct(), Str.toStringz(property)); 612 } 613 614 /** 615 * Applies any changes that have been made to the settings. This 616 * function does nothing unless @settings is in 'delay-apply' mode; 617 * see g_settings_delay(). In the normal case settings are always 618 * applied immediately. 619 */ 620 public void apply() 621 { 622 g_settings_apply(gSettings); 623 } 624 625 /** 626 * Create a binding between the @key in the @settings object 627 * and the property @property of @object. 628 * 629 * The binding uses the default GIO mapping functions to map 630 * between the settings and property values. These functions 631 * handle booleans, numeric types and string types in a 632 * straightforward way. Use g_settings_bind_with_mapping() if 633 * you need a custom mapping, or map between types that are not 634 * supported by the default mapping functions. 635 * 636 * Unless the @flags include %G_SETTINGS_BIND_NO_SENSITIVITY, this 637 * function also establishes a binding between the writability of 638 * @key and the "sensitive" property of @object (if @object has 639 * a boolean property by that name). See g_settings_bind_writable() 640 * for more details about writable bindings. 641 * 642 * Note that the lifecycle of the binding is tied to the object, 643 * and that you can have only one binding per object property. 644 * If you bind the same property twice on the same object, the second 645 * binding overrides the first one. 646 * 647 * Params: 648 * key = the key to bind 649 * object = a #GObject 650 * property = the name of the property to bind 651 * flags = flags for the binding 652 * 653 * Since: 2.26 654 */ 655 public void bind(string key, ObjectG object, string property, GSettingsBindFlags flags) 656 { 657 g_settings_bind(gSettings, Str.toStringz(key), (object is null) ? null : object.getObjectGStruct(), Str.toStringz(property), flags); 658 } 659 660 /** 661 * Create a binding between the @key in the @settings object 662 * and the property @property of @object. 663 * 664 * The binding uses the provided mapping functions to map between 665 * settings and property values. 666 * 667 * Note that the lifecycle of the binding is tied to the object, 668 * and that you can have only one binding per object property. 669 * If you bind the same property twice on the same object, the second 670 * binding overrides the first one. 671 * 672 * Params: 673 * key = the key to bind 674 * object = a #GObject 675 * property = the name of the property to bind 676 * flags = flags for the binding 677 * getMapping = a function that gets called to convert values 678 * from @settings to @object, or %NULL to use the default GIO mapping 679 * setMapping = a function that gets called to convert values 680 * from @object to @settings, or %NULL to use the default GIO mapping 681 * userData = data that gets passed to @get_mapping and @set_mapping 682 * destroy = #GDestroyNotify function for @user_data 683 * 684 * Since: 2.26 685 */ 686 public void bindWithMapping(string key, ObjectG object, string property, GSettingsBindFlags flags, GSettingsBindGetMapping getMapping, GSettingsBindSetMapping setMapping, void* userData, GDestroyNotify destroy) 687 { 688 g_settings_bind_with_mapping(gSettings, Str.toStringz(key), (object is null) ? null : object.getObjectGStruct(), Str.toStringz(property), flags, getMapping, setMapping, userData, destroy); 689 } 690 691 /** 692 * Create a binding between the writability of @key in the 693 * @settings object and the property @property of @object. 694 * The property must be boolean; "sensitive" or "visible" 695 * properties of widgets are the most likely candidates. 696 * 697 * Writable bindings are always uni-directional; changes of the 698 * writability of the setting will be propagated to the object 699 * property, not the other way. 700 * 701 * When the @inverted argument is %TRUE, the binding inverts the 702 * value as it passes from the setting to the object, i.e. @property 703 * will be set to %TRUE if the key is not writable. 704 * 705 * Note that the lifecycle of the binding is tied to the object, 706 * and that you can have only one binding per object property. 707 * If you bind the same property twice on the same object, the second 708 * binding overrides the first one. 709 * 710 * Params: 711 * key = the key to bind 712 * object = a #GObject 713 * property = the name of a boolean property to bind 714 * inverted = whether to 'invert' the value 715 * 716 * Since: 2.26 717 */ 718 public void bindWritable(string key, ObjectG object, string property, bool inverted) 719 { 720 g_settings_bind_writable(gSettings, Str.toStringz(key), (object is null) ? null : object.getObjectGStruct(), Str.toStringz(property), inverted); 721 } 722 723 /** 724 * Creates a #GAction corresponding to a given #GSettings key. 725 * 726 * The action has the same name as the key. 727 * 728 * The value of the key becomes the state of the action and the action 729 * is enabled when the key is writable. Changing the state of the 730 * action results in the key being written to. Changes to the value or 731 * writability of the key cause appropriate change notifications to be 732 * emitted for the action. 733 * 734 * For boolean-valued keys, action activations take no parameter and 735 * result in the toggling of the value. For all other types, 736 * activations take the new value for the key (which must have the 737 * correct type). 738 * 739 * Params: 740 * key = the name of a key in @settings 741 * 742 * Returns: a new #GAction 743 * 744 * Since: 2.32 745 */ 746 public ActionIF createAction(string key) 747 { 748 auto p = g_settings_create_action(gSettings, Str.toStringz(key)); 749 750 if(p is null) 751 { 752 return null; 753 } 754 755 return ObjectG.getDObject!(Action, ActionIF)(cast(GAction*) p, true); 756 } 757 758 /** 759 * Changes the #GSettings object into 'delay-apply' mode. In this 760 * mode, changes to @settings are not immediately propagated to the 761 * backend, but kept locally until g_settings_apply() is called. 762 * 763 * Since: 2.26 764 */ 765 public void delay() 766 { 767 g_settings_delay(gSettings); 768 } 769 770 /** 771 * Gets the value that is stored at @key in @settings. 772 * 773 * A convenience variant of g_settings_get() for booleans. 774 * 775 * It is a programmer error to give a @key that isn't specified as 776 * having a boolean type in the schema for @settings. 777 * 778 * Params: 779 * key = the key to get the value for 780 * 781 * Returns: a boolean 782 * 783 * Since: 2.26 784 */ 785 public bool getBoolean(string key) 786 { 787 return g_settings_get_boolean(gSettings, Str.toStringz(key)) != 0; 788 } 789 790 /** 791 * Creates a child settings object which has a base path of 792 * `base-path/@name`, where `base-path` is the base path of 793 * @settings. 794 * 795 * The schema for the child settings object must have been declared 796 * in the schema of @settings using a <child> element. 797 * 798 * Params: 799 * name = the name of the child schema 800 * 801 * Returns: a 'child' settings object 802 * 803 * Since: 2.26 804 */ 805 public Settings getChild(string name) 806 { 807 auto p = g_settings_get_child(gSettings, Str.toStringz(name)); 808 809 if(p is null) 810 { 811 return null; 812 } 813 814 return ObjectG.getDObject!(Settings)(cast(GSettings*) p, true); 815 } 816 817 /** 818 * Gets the "default value" of a key. 819 * 820 * This is the value that would be read if g_settings_reset() were to be 821 * called on the key. 822 * 823 * Note that this may be a different value than returned by 824 * g_settings_schema_key_get_default_value() if the system administrator 825 * has provided a default value. 826 * 827 * Comparing the return values of g_settings_get_default_value() and 828 * g_settings_get_value() is not sufficient for determining if a value 829 * has been set because the user may have explicitly set the value to 830 * something that happens to be equal to the default. The difference 831 * here is that if the default changes in the future, the user's key 832 * will still be set. 833 * 834 * This function may be useful for adding an indication to a UI of what 835 * the default value was before the user set it. 836 * 837 * It is a programmer error to give a @key that isn't contained in the 838 * schema for @settings. 839 * 840 * Params: 841 * key = the key to get the default value for 842 * 843 * Returns: the default value 844 * 845 * Since: 2.40 846 */ 847 public Variant getDefaultValue(string key) 848 { 849 auto p = g_settings_get_default_value(gSettings, Str.toStringz(key)); 850 851 if(p is null) 852 { 853 return null; 854 } 855 856 return new Variant(cast(GVariant*) p, true); 857 } 858 859 /** 860 * Gets the value that is stored at @key in @settings. 861 * 862 * A convenience variant of g_settings_get() for doubles. 863 * 864 * It is a programmer error to give a @key that isn't specified as 865 * having a 'double' type in the schema for @settings. 866 * 867 * Params: 868 * key = the key to get the value for 869 * 870 * Returns: a double 871 * 872 * Since: 2.26 873 */ 874 public double getDouble(string key) 875 { 876 return g_settings_get_double(gSettings, Str.toStringz(key)); 877 } 878 879 /** 880 * Gets the value that is stored in @settings for @key and converts it 881 * to the enum value that it represents. 882 * 883 * In order to use this function the type of the value must be a string 884 * and it must be marked in the schema file as an enumerated type. 885 * 886 * It is a programmer error to give a @key that isn't contained in the 887 * schema for @settings or is not marked as an enumerated type. 888 * 889 * If the value stored in the configuration database is not a valid 890 * value for the enumerated type then this function will return the 891 * default value. 892 * 893 * Params: 894 * key = the key to get the value for 895 * 896 * Returns: the enum value 897 * 898 * Since: 2.26 899 */ 900 public int getEnum(string key) 901 { 902 return g_settings_get_enum(gSettings, Str.toStringz(key)); 903 } 904 905 /** 906 * Gets the value that is stored in @settings for @key and converts it 907 * to the flags value that it represents. 908 * 909 * In order to use this function the type of the value must be an array 910 * of strings and it must be marked in the schema file as an flags type. 911 * 912 * It is a programmer error to give a @key that isn't contained in the 913 * schema for @settings or is not marked as a flags type. 914 * 915 * If the value stored in the configuration database is not a valid 916 * value for the flags type then this function will return the default 917 * value. 918 * 919 * Params: 920 * key = the key to get the value for 921 * 922 * Returns: the flags value 923 * 924 * Since: 2.26 925 */ 926 public uint getFlags(string key) 927 { 928 return g_settings_get_flags(gSettings, Str.toStringz(key)); 929 } 930 931 /** 932 * Returns whether the #GSettings object has any unapplied 933 * changes. This can only be the case if it is in 'delayed-apply' mode. 934 * 935 * Returns: %TRUE if @settings has unapplied changes 936 * 937 * Since: 2.26 938 */ 939 public bool getHasUnapplied() 940 { 941 return g_settings_get_has_unapplied(gSettings) != 0; 942 } 943 944 /** 945 * Gets the value that is stored at @key in @settings. 946 * 947 * A convenience variant of g_settings_get() for 32-bit integers. 948 * 949 * It is a programmer error to give a @key that isn't specified as 950 * having a int32 type in the schema for @settings. 951 * 952 * Params: 953 * key = the key to get the value for 954 * 955 * Returns: an integer 956 * 957 * Since: 2.26 958 */ 959 public int getInt(string key) 960 { 961 return g_settings_get_int(gSettings, Str.toStringz(key)); 962 } 963 964 /** 965 * Gets the value that is stored at @key in @settings. 966 * 967 * A convenience variant of g_settings_get() for 64-bit integers. 968 * 969 * It is a programmer error to give a @key that isn't specified as 970 * having a int64 type in the schema for @settings. 971 * 972 * Params: 973 * key = the key to get the value for 974 * 975 * Returns: a 64-bit integer 976 * 977 * Since: 2.50 978 */ 979 public long getInt64(string key) 980 { 981 return g_settings_get_int64(gSettings, Str.toStringz(key)); 982 } 983 984 /** 985 * Gets the value that is stored at @key in @settings, subject to 986 * application-level validation/mapping. 987 * 988 * You should use this function when the application needs to perform 989 * some processing on the value of the key (for example, parsing). The 990 * @mapping function performs that processing. If the function 991 * indicates that the processing was unsuccessful (due to a parse error, 992 * for example) then the mapping is tried again with another value. 993 * 994 * This allows a robust 'fall back to defaults' behaviour to be 995 * implemented somewhat automatically. 996 * 997 * The first value that is tried is the user's setting for the key. If 998 * the mapping function fails to map this value, other values may be 999 * tried in an unspecified order (system or site defaults, translated 1000 * schema default values, untranslated schema default values, etc). 1001 * 1002 * If the mapping function fails for all possible values, one additional 1003 * attempt is made: the mapping function is called with a %NULL value. 1004 * If the mapping function still indicates failure at this point then 1005 * the application will be aborted. 1006 * 1007 * The result parameter for the @mapping function is pointed to a 1008 * #gpointer which is initially set to %NULL. The same pointer is given 1009 * to each invocation of @mapping. The final value of that #gpointer is 1010 * what is returned by this function. %NULL is valid; it is returned 1011 * just as any other value would be. 1012 * 1013 * Params: 1014 * key = the key to get the value for 1015 * mapping = the function to map the value in the 1016 * settings database to the value used by the application 1017 * userData = user data for @mapping 1018 * 1019 * Returns: the result, which may be %NULL 1020 */ 1021 public void* getMapped(string key, GSettingsGetMapping mapping, void* userData) 1022 { 1023 return g_settings_get_mapped(gSettings, Str.toStringz(key), mapping, userData); 1024 } 1025 1026 /** 1027 * Queries the range of a key. 1028 * 1029 * Deprecated: Use g_settings_schema_key_get_range() instead. 1030 * 1031 * Params: 1032 * key = the key to query the range of 1033 * 1034 * Since: 2.28 1035 */ 1036 public Variant getRange(string key) 1037 { 1038 auto p = g_settings_get_range(gSettings, Str.toStringz(key)); 1039 1040 if(p is null) 1041 { 1042 return null; 1043 } 1044 1045 return new Variant(cast(GVariant*) p, true); 1046 } 1047 1048 /** 1049 * Gets the value that is stored at @key in @settings. 1050 * 1051 * A convenience variant of g_settings_get() for strings. 1052 * 1053 * It is a programmer error to give a @key that isn't specified as 1054 * having a string type in the schema for @settings. 1055 * 1056 * Params: 1057 * key = the key to get the value for 1058 * 1059 * Returns: a newly-allocated string 1060 * 1061 * Since: 2.26 1062 */ 1063 public string getString(string key) 1064 { 1065 auto retStr = g_settings_get_string(gSettings, Str.toStringz(key)); 1066 1067 scope(exit) Str.freeString(retStr); 1068 return Str.toString(retStr); 1069 } 1070 1071 /** 1072 * A convenience variant of g_settings_get() for string arrays. 1073 * 1074 * It is a programmer error to give a @key that isn't specified as 1075 * having an array of strings type in the schema for @settings. 1076 * 1077 * Params: 1078 * key = the key to get the value for 1079 * 1080 * Returns: a 1081 * newly-allocated, %NULL-terminated array of strings, the value that 1082 * is stored at @key in @settings. 1083 * 1084 * Since: 2.26 1085 */ 1086 public string[] getStrv(string key) 1087 { 1088 auto retStr = g_settings_get_strv(gSettings, Str.toStringz(key)); 1089 1090 scope(exit) Str.freeStringArray(retStr); 1091 return Str.toStringArray(retStr); 1092 } 1093 1094 /** 1095 * Gets the value that is stored at @key in @settings. 1096 * 1097 * A convenience variant of g_settings_get() for 32-bit unsigned 1098 * integers. 1099 * 1100 * It is a programmer error to give a @key that isn't specified as 1101 * having a uint32 type in the schema for @settings. 1102 * 1103 * Params: 1104 * key = the key to get the value for 1105 * 1106 * Returns: an unsigned integer 1107 * 1108 * Since: 2.30 1109 */ 1110 public uint getUint(string key) 1111 { 1112 return g_settings_get_uint(gSettings, Str.toStringz(key)); 1113 } 1114 1115 /** 1116 * Gets the value that is stored at @key in @settings. 1117 * 1118 * A convenience variant of g_settings_get() for 64-bit unsigned 1119 * integers. 1120 * 1121 * It is a programmer error to give a @key that isn't specified as 1122 * having a uint64 type in the schema for @settings. 1123 * 1124 * Params: 1125 * key = the key to get the value for 1126 * 1127 * Returns: a 64-bit unsigned integer 1128 * 1129 * Since: 2.50 1130 */ 1131 public ulong getUint64(string key) 1132 { 1133 return g_settings_get_uint64(gSettings, Str.toStringz(key)); 1134 } 1135 1136 /** 1137 * Checks the "user value" of a key, if there is one. 1138 * 1139 * The user value of a key is the last value that was set by the user. 1140 * 1141 * After calling g_settings_reset() this function should always return 1142 * %NULL (assuming something is not wrong with the system 1143 * configuration). 1144 * 1145 * It is possible that g_settings_get_value() will return a different 1146 * value than this function. This can happen in the case that the user 1147 * set a value for a key that was subsequently locked down by the system 1148 * administrator -- this function will return the user's old value. 1149 * 1150 * This function may be useful for adding a "reset" option to a UI or 1151 * for providing indication that a particular value has been changed. 1152 * 1153 * It is a programmer error to give a @key that isn't contained in the 1154 * schema for @settings. 1155 * 1156 * Params: 1157 * key = the key to get the user value for 1158 * 1159 * Returns: the user's value, if set 1160 * 1161 * Since: 2.40 1162 */ 1163 public Variant getUserValue(string key) 1164 { 1165 auto p = g_settings_get_user_value(gSettings, Str.toStringz(key)); 1166 1167 if(p is null) 1168 { 1169 return null; 1170 } 1171 1172 return new Variant(cast(GVariant*) p, true); 1173 } 1174 1175 /** 1176 * Gets the value that is stored in @settings for @key. 1177 * 1178 * It is a programmer error to give a @key that isn't contained in the 1179 * schema for @settings. 1180 * 1181 * Params: 1182 * key = the key to get the value for 1183 * 1184 * Returns: a new #GVariant 1185 * 1186 * Since: 2.26 1187 */ 1188 public Variant getValue(string key) 1189 { 1190 auto p = g_settings_get_value(gSettings, Str.toStringz(key)); 1191 1192 if(p is null) 1193 { 1194 return null; 1195 } 1196 1197 return new Variant(cast(GVariant*) p, true); 1198 } 1199 1200 /** 1201 * Finds out if a key can be written or not 1202 * 1203 * Params: 1204 * name = the name of a key 1205 * 1206 * Returns: %TRUE if the key @name is writable 1207 * 1208 * Since: 2.26 1209 */ 1210 public bool isWritable(string name) 1211 { 1212 return g_settings_is_writable(gSettings, Str.toStringz(name)) != 0; 1213 } 1214 1215 /** 1216 * Gets the list of children on @settings. 1217 * 1218 * The list is exactly the list of strings for which it is not an error 1219 * to call g_settings_get_child(). 1220 * 1221 * For GSettings objects that are lists, this value can change at any 1222 * time and you should connect to the "children-changed" signal to watch 1223 * for those changes. Note that there is a race condition here: you may 1224 * request a child after listing it only for it to have been destroyed 1225 * in the meantime. For this reason, g_settings_get_child() may return 1226 * %NULL even for a child that was listed by this function. 1227 * 1228 * For GSettings objects that are not lists, you should probably not be 1229 * calling this function from "normal" code (since you should already 1230 * know what children are in your schema). This function may still be 1231 * useful there for introspection reasons, however. 1232 * 1233 * You should free the return value with g_strfreev() when you are done 1234 * with it. 1235 * 1236 * Returns: a list of the children on @settings 1237 */ 1238 public string[] listChildren() 1239 { 1240 auto retStr = g_settings_list_children(gSettings); 1241 1242 scope(exit) Str.freeStringArray(retStr); 1243 return Str.toStringArray(retStr); 1244 } 1245 1246 /** 1247 * Introspects the list of keys on @settings. 1248 * 1249 * You should probably not be calling this function from "normal" code 1250 * (since you should already know what keys are in your schema). This 1251 * function is intended for introspection reasons. 1252 * 1253 * You should free the return value with g_strfreev() when you are done 1254 * with it. 1255 * 1256 * Returns: a list of the keys on @settings 1257 */ 1258 public string[] listKeys() 1259 { 1260 auto retStr = g_settings_list_keys(gSettings); 1261 1262 scope(exit) Str.freeStringArray(retStr); 1263 return Str.toStringArray(retStr); 1264 } 1265 1266 /** 1267 * Checks if the given @value is of the correct type and within the 1268 * permitted range for @key. 1269 * 1270 * Deprecated: Use g_settings_schema_key_range_check() instead. 1271 * 1272 * Params: 1273 * key = the key to check 1274 * value = the value to check 1275 * 1276 * Returns: %TRUE if @value is valid for @key 1277 * 1278 * Since: 2.28 1279 */ 1280 public bool rangeCheck(string key, Variant value) 1281 { 1282 return g_settings_range_check(gSettings, Str.toStringz(key), (value is null) ? null : value.getVariantStruct()) != 0; 1283 } 1284 1285 /** 1286 * Resets @key to its default value. 1287 * 1288 * This call resets the key, as much as possible, to its default value. 1289 * That might the value specified in the schema or the one set by the 1290 * administrator. 1291 * 1292 * Params: 1293 * key = the name of a key 1294 */ 1295 public void reset(string key) 1296 { 1297 g_settings_reset(gSettings, Str.toStringz(key)); 1298 } 1299 1300 /** 1301 * Reverts all non-applied changes to the settings. This function 1302 * does nothing unless @settings is in 'delay-apply' mode; see 1303 * g_settings_delay(). In the normal case settings are always applied 1304 * immediately. 1305 * 1306 * Change notifications will be emitted for affected keys. 1307 */ 1308 public void revert() 1309 { 1310 g_settings_revert(gSettings); 1311 } 1312 1313 /** 1314 * Sets @key in @settings to @value. 1315 * 1316 * A convenience variant of g_settings_set() for booleans. 1317 * 1318 * It is a programmer error to give a @key that isn't specified as 1319 * having a boolean type in the schema for @settings. 1320 * 1321 * Params: 1322 * key = the name of the key to set 1323 * value = the value to set it to 1324 * 1325 * Returns: %TRUE if setting the key succeeded, 1326 * %FALSE if the key was not writable 1327 * 1328 * Since: 2.26 1329 */ 1330 public bool setBoolean(string key, bool value) 1331 { 1332 return g_settings_set_boolean(gSettings, Str.toStringz(key), value) != 0; 1333 } 1334 1335 /** 1336 * Sets @key in @settings to @value. 1337 * 1338 * A convenience variant of g_settings_set() for doubles. 1339 * 1340 * It is a programmer error to give a @key that isn't specified as 1341 * having a 'double' type in the schema for @settings. 1342 * 1343 * Params: 1344 * key = the name of the key to set 1345 * value = the value to set it to 1346 * 1347 * Returns: %TRUE if setting the key succeeded, 1348 * %FALSE if the key was not writable 1349 * 1350 * Since: 2.26 1351 */ 1352 public bool setDouble(string key, double value) 1353 { 1354 return g_settings_set_double(gSettings, Str.toStringz(key), value) != 0; 1355 } 1356 1357 /** 1358 * Looks up the enumerated type nick for @value and writes it to @key, 1359 * within @settings. 1360 * 1361 * It is a programmer error to give a @key that isn't contained in the 1362 * schema for @settings or is not marked as an enumerated type, or for 1363 * @value not to be a valid value for the named type. 1364 * 1365 * After performing the write, accessing @key directly with 1366 * g_settings_get_string() will return the 'nick' associated with 1367 * @value. 1368 * 1369 * Params: 1370 * key = a key, within @settings 1371 * value = an enumerated value 1372 * 1373 * Returns: %TRUE, if the set succeeds 1374 */ 1375 public bool setEnum(string key, int value) 1376 { 1377 return g_settings_set_enum(gSettings, Str.toStringz(key), value) != 0; 1378 } 1379 1380 /** 1381 * Looks up the flags type nicks for the bits specified by @value, puts 1382 * them in an array of strings and writes the array to @key, within 1383 * @settings. 1384 * 1385 * It is a programmer error to give a @key that isn't contained in the 1386 * schema for @settings or is not marked as a flags type, or for @value 1387 * to contain any bits that are not value for the named type. 1388 * 1389 * After performing the write, accessing @key directly with 1390 * g_settings_get_strv() will return an array of 'nicks'; one for each 1391 * bit in @value. 1392 * 1393 * Params: 1394 * key = a key, within @settings 1395 * value = a flags value 1396 * 1397 * Returns: %TRUE, if the set succeeds 1398 */ 1399 public bool setFlags(string key, uint value) 1400 { 1401 return g_settings_set_flags(gSettings, Str.toStringz(key), value) != 0; 1402 } 1403 1404 /** 1405 * Sets @key in @settings to @value. 1406 * 1407 * A convenience variant of g_settings_set() for 32-bit integers. 1408 * 1409 * It is a programmer error to give a @key that isn't specified as 1410 * having a int32 type in the schema for @settings. 1411 * 1412 * Params: 1413 * key = the name of the key to set 1414 * value = the value to set it to 1415 * 1416 * Returns: %TRUE if setting the key succeeded, 1417 * %FALSE if the key was not writable 1418 * 1419 * Since: 2.26 1420 */ 1421 public bool setInt(string key, int value) 1422 { 1423 return g_settings_set_int(gSettings, Str.toStringz(key), value) != 0; 1424 } 1425 1426 /** 1427 * Sets @key in @settings to @value. 1428 * 1429 * A convenience variant of g_settings_set() for 64-bit integers. 1430 * 1431 * It is a programmer error to give a @key that isn't specified as 1432 * having a int64 type in the schema for @settings. 1433 * 1434 * Params: 1435 * key = the name of the key to set 1436 * value = the value to set it to 1437 * 1438 * Returns: %TRUE if setting the key succeeded, 1439 * %FALSE if the key was not writable 1440 * 1441 * Since: 2.50 1442 */ 1443 public bool setInt64(string key, long value) 1444 { 1445 return g_settings_set_int64(gSettings, Str.toStringz(key), value) != 0; 1446 } 1447 1448 /** 1449 * Sets @key in @settings to @value. 1450 * 1451 * A convenience variant of g_settings_set() for strings. 1452 * 1453 * It is a programmer error to give a @key that isn't specified as 1454 * having a string type in the schema for @settings. 1455 * 1456 * Params: 1457 * key = the name of the key to set 1458 * value = the value to set it to 1459 * 1460 * Returns: %TRUE if setting the key succeeded, 1461 * %FALSE if the key was not writable 1462 * 1463 * Since: 2.26 1464 */ 1465 public bool setString(string key, string value) 1466 { 1467 return g_settings_set_string(gSettings, Str.toStringz(key), Str.toStringz(value)) != 0; 1468 } 1469 1470 /** 1471 * Sets @key in @settings to @value. 1472 * 1473 * A convenience variant of g_settings_set() for string arrays. If 1474 * @value is %NULL, then @key is set to be the empty array. 1475 * 1476 * It is a programmer error to give a @key that isn't specified as 1477 * having an array of strings type in the schema for @settings. 1478 * 1479 * Params: 1480 * key = the name of the key to set 1481 * value = the value to set it to, or %NULL 1482 * 1483 * Returns: %TRUE if setting the key succeeded, 1484 * %FALSE if the key was not writable 1485 * 1486 * Since: 2.26 1487 */ 1488 public bool setStrv(string key, string[] value) 1489 { 1490 return g_settings_set_strv(gSettings, Str.toStringz(key), Str.toStringzArray(value)) != 0; 1491 } 1492 1493 /** 1494 * Sets @key in @settings to @value. 1495 * 1496 * A convenience variant of g_settings_set() for 32-bit unsigned 1497 * integers. 1498 * 1499 * It is a programmer error to give a @key that isn't specified as 1500 * having a uint32 type in the schema for @settings. 1501 * 1502 * Params: 1503 * key = the name of the key to set 1504 * value = the value to set it to 1505 * 1506 * Returns: %TRUE if setting the key succeeded, 1507 * %FALSE if the key was not writable 1508 * 1509 * Since: 2.30 1510 */ 1511 public bool setUint(string key, uint value) 1512 { 1513 return g_settings_set_uint(gSettings, Str.toStringz(key), value) != 0; 1514 } 1515 1516 /** 1517 * Sets @key in @settings to @value. 1518 * 1519 * A convenience variant of g_settings_set() for 64-bit unsigned 1520 * integers. 1521 * 1522 * It is a programmer error to give a @key that isn't specified as 1523 * having a uint64 type in the schema for @settings. 1524 * 1525 * Params: 1526 * key = the name of the key to set 1527 * value = the value to set it to 1528 * 1529 * Returns: %TRUE if setting the key succeeded, 1530 * %FALSE if the key was not writable 1531 * 1532 * Since: 2.50 1533 */ 1534 public bool setUint64(string key, ulong value) 1535 { 1536 return g_settings_set_uint64(gSettings, Str.toStringz(key), value) != 0; 1537 } 1538 1539 /** 1540 * Sets @key in @settings to @value. 1541 * 1542 * It is a programmer error to give a @key that isn't contained in the 1543 * schema for @settings or for @value to have the incorrect type, per 1544 * the schema. 1545 * 1546 * If @value is floating then this function consumes the reference. 1547 * 1548 * Params: 1549 * key = the name of the key to set 1550 * value = a #GVariant of the correct type 1551 * 1552 * Returns: %TRUE if setting the key succeeded, 1553 * %FALSE if the key was not writable 1554 * 1555 * Since: 2.26 1556 */ 1557 public bool setValue(string key, Variant value) 1558 { 1559 return g_settings_set_value(gSettings, Str.toStringz(key), (value is null) ? null : value.getVariantStruct()) != 0; 1560 } 1561 1562 protected class OnChangeDelegateWrapper 1563 { 1564 static OnChangeDelegateWrapper[] listeners; 1565 bool delegate(void*, int, Settings) dlg; 1566 gulong handlerId; 1567 1568 this(bool delegate(void*, int, Settings) dlg) 1569 { 1570 this.dlg = dlg; 1571 this.listeners ~= this; 1572 } 1573 1574 void remove(OnChangeDelegateWrapper source) 1575 { 1576 foreach(index, wrapper; listeners) 1577 { 1578 if (wrapper.handlerId == source.handlerId) 1579 { 1580 listeners[index] = null; 1581 listeners = std.algorithm.remove(listeners, index); 1582 break; 1583 } 1584 } 1585 } 1586 } 1587 1588 /** 1589 * The "change-event" signal is emitted once per change event that 1590 * affects this settings object. You should connect to this signal 1591 * only if you are interested in viewing groups of changes before they 1592 * are split out into multiple emissions of the "changed" signal. 1593 * For most use cases it is more appropriate to use the "changed" signal. 1594 * 1595 * In the event that the change event applies to one or more specified 1596 * keys, @keys will be an array of #GQuark of length @n_keys. In the 1597 * event that the change event applies to the #GSettings object as a 1598 * whole (ie: potentially every key has been changed) then @keys will 1599 * be %NULL and @n_keys will be 0. 1600 * 1601 * The default handler for this signal invokes the "changed" signal 1602 * for each affected key. If any other connected handler returns 1603 * %TRUE then this default functionality will be suppressed. 1604 * 1605 * Params: 1606 * keys = an array of #GQuarks for the changed keys, or %NULL 1607 * nKeys = the length of the @keys array, or 0 1608 * 1609 * Returns: %TRUE to stop other handlers from being invoked for the 1610 * event. FALSE to propagate the event further. 1611 */ 1612 gulong addOnChange(bool delegate(void*, int, Settings) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 1613 { 1614 auto wrapper = new OnChangeDelegateWrapper(dlg); 1615 wrapper.handlerId = Signals.connectData( 1616 this, 1617 "change-event", 1618 cast(GCallback)&callBackChange, 1619 cast(void*)wrapper, 1620 cast(GClosureNotify)&callBackChangeDestroy, 1621 connectFlags); 1622 return wrapper.handlerId; 1623 } 1624 1625 extern(C) static int callBackChange(GSettings* settingsStruct, void* keys, int nKeys, OnChangeDelegateWrapper wrapper) 1626 { 1627 return wrapper.dlg(keys, nKeys, wrapper.outer); 1628 } 1629 1630 extern(C) static void callBackChangeDestroy(OnChangeDelegateWrapper wrapper, GClosure* closure) 1631 { 1632 wrapper.remove(wrapper); 1633 } 1634 1635 protected class OnChangedDelegateWrapper 1636 { 1637 static OnChangedDelegateWrapper[] listeners; 1638 void delegate(string, Settings) dlg; 1639 gulong handlerId; 1640 1641 this(void delegate(string, Settings) dlg) 1642 { 1643 this.dlg = dlg; 1644 this.listeners ~= this; 1645 } 1646 1647 void remove(OnChangedDelegateWrapper source) 1648 { 1649 foreach(index, wrapper; listeners) 1650 { 1651 if (wrapper.handlerId == source.handlerId) 1652 { 1653 listeners[index] = null; 1654 listeners = std.algorithm.remove(listeners, index); 1655 break; 1656 } 1657 } 1658 } 1659 } 1660 1661 /** 1662 * The "changed" signal is emitted when a key has potentially changed. 1663 * You should call one of the g_settings_get() calls to check the new 1664 * value. 1665 * 1666 * This signal supports detailed connections. You can connect to the 1667 * detailed signal "changed::x" in order to only receive callbacks 1668 * when key "x" changes. 1669 * 1670 * Note that @settings only emits this signal if you have read @key at 1671 * least once while a signal handler was already connected for @key. 1672 * 1673 * Params: 1674 * key = the name of the key that changed 1675 */ 1676 gulong addOnChanged(void delegate(string, Settings) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 1677 { 1678 auto wrapper = new OnChangedDelegateWrapper(dlg); 1679 wrapper.handlerId = Signals.connectData( 1680 this, 1681 "changed", 1682 cast(GCallback)&callBackChanged, 1683 cast(void*)wrapper, 1684 cast(GClosureNotify)&callBackChangedDestroy, 1685 connectFlags); 1686 return wrapper.handlerId; 1687 } 1688 1689 extern(C) static void callBackChanged(GSettings* settingsStruct, char* key, OnChangedDelegateWrapper wrapper) 1690 { 1691 wrapper.dlg(Str.toString(key), wrapper.outer); 1692 } 1693 1694 extern(C) static void callBackChangedDestroy(OnChangedDelegateWrapper wrapper, GClosure* closure) 1695 { 1696 wrapper.remove(wrapper); 1697 } 1698 1699 protected class OnWritableChangeDelegateWrapper 1700 { 1701 static OnWritableChangeDelegateWrapper[] listeners; 1702 bool delegate(uint, Settings) dlg; 1703 gulong handlerId; 1704 1705 this(bool delegate(uint, Settings) dlg) 1706 { 1707 this.dlg = dlg; 1708 this.listeners ~= this; 1709 } 1710 1711 void remove(OnWritableChangeDelegateWrapper source) 1712 { 1713 foreach(index, wrapper; listeners) 1714 { 1715 if (wrapper.handlerId == source.handlerId) 1716 { 1717 listeners[index] = null; 1718 listeners = std.algorithm.remove(listeners, index); 1719 break; 1720 } 1721 } 1722 } 1723 } 1724 1725 /** 1726 * The "writable-change-event" signal is emitted once per writability 1727 * change event that affects this settings object. You should connect 1728 * to this signal if you are interested in viewing groups of changes 1729 * before they are split out into multiple emissions of the 1730 * "writable-changed" signal. For most use cases it is more 1731 * appropriate to use the "writable-changed" signal. 1732 * 1733 * In the event that the writability change applies only to a single 1734 * key, @key will be set to the #GQuark for that key. In the event 1735 * that the writability change affects the entire settings object, 1736 * @key will be 0. 1737 * 1738 * The default handler for this signal invokes the "writable-changed" 1739 * and "changed" signals for each affected key. This is done because 1740 * changes in writability might also imply changes in value (if for 1741 * example, a new mandatory setting is introduced). If any other 1742 * connected handler returns %TRUE then this default functionality 1743 * will be suppressed. 1744 * 1745 * Params: 1746 * key = the quark of the key, or 0 1747 * 1748 * Returns: %TRUE to stop other handlers from being invoked for the 1749 * event. FALSE to propagate the event further. 1750 */ 1751 gulong addOnWritableChange(bool delegate(uint, Settings) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 1752 { 1753 auto wrapper = new OnWritableChangeDelegateWrapper(dlg); 1754 wrapper.handlerId = Signals.connectData( 1755 this, 1756 "writable-change-event", 1757 cast(GCallback)&callBackWritableChange, 1758 cast(void*)wrapper, 1759 cast(GClosureNotify)&callBackWritableChangeDestroy, 1760 connectFlags); 1761 return wrapper.handlerId; 1762 } 1763 1764 extern(C) static int callBackWritableChange(GSettings* settingsStruct, uint key, OnWritableChangeDelegateWrapper wrapper) 1765 { 1766 return wrapper.dlg(key, wrapper.outer); 1767 } 1768 1769 extern(C) static void callBackWritableChangeDestroy(OnWritableChangeDelegateWrapper wrapper, GClosure* closure) 1770 { 1771 wrapper.remove(wrapper); 1772 } 1773 1774 protected class OnWritableChangedDelegateWrapper 1775 { 1776 static OnWritableChangedDelegateWrapper[] listeners; 1777 void delegate(string, Settings) dlg; 1778 gulong handlerId; 1779 1780 this(void delegate(string, Settings) dlg) 1781 { 1782 this.dlg = dlg; 1783 this.listeners ~= this; 1784 } 1785 1786 void remove(OnWritableChangedDelegateWrapper source) 1787 { 1788 foreach(index, wrapper; listeners) 1789 { 1790 if (wrapper.handlerId == source.handlerId) 1791 { 1792 listeners[index] = null; 1793 listeners = std.algorithm.remove(listeners, index); 1794 break; 1795 } 1796 } 1797 } 1798 } 1799 1800 /** 1801 * The "writable-changed" signal is emitted when the writability of a 1802 * key has potentially changed. You should call 1803 * g_settings_is_writable() in order to determine the new status. 1804 * 1805 * This signal supports detailed connections. You can connect to the 1806 * detailed signal "writable-changed::x" in order to only receive 1807 * callbacks when the writability of "x" changes. 1808 * 1809 * Params: 1810 * key = the key 1811 */ 1812 gulong addOnWritableChanged(void delegate(string, Settings) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 1813 { 1814 auto wrapper = new OnWritableChangedDelegateWrapper(dlg); 1815 wrapper.handlerId = Signals.connectData( 1816 this, 1817 "writable-changed", 1818 cast(GCallback)&callBackWritableChanged, 1819 cast(void*)wrapper, 1820 cast(GClosureNotify)&callBackWritableChangedDestroy, 1821 connectFlags); 1822 return wrapper.handlerId; 1823 } 1824 1825 extern(C) static void callBackWritableChanged(GSettings* settingsStruct, char* key, OnWritableChangedDelegateWrapper wrapper) 1826 { 1827 wrapper.dlg(Str.toString(key), wrapper.outer); 1828 } 1829 1830 extern(C) static void callBackWritableChangedDestroy(OnWritableChangedDelegateWrapper wrapper, GClosure* closure) 1831 { 1832 wrapper.remove(wrapper); 1833 } 1834 }