GSettings

<?xml version="1.0" encoding="UTF-8"?>
<schemalist>
    <schema path="/org/myapp/" id="org.myapp">
        <key name="boolkey" type="b">
            <default>true</default>
            <summary>A boolean configuration key.</summary>
            <description>...</description>
        </key>
        <key name="strkey" type="s">
            <default>"string"</default>
            <summary>A string configuration key.</summary>
            <description>...</description>
        </key>
        <key name="intkey" type="i">
            <default>25</default>
            <range min="0" max="100" />
            <summary>A integer configuration key.</summary>
            <description>...</description>
        </key>
        <key name="choicekey" type="s">
            <choices>
                <choice value="choice 1"/>
                <choice value="choice 2"/>
            </choices>
            <default>"choice 1"</default>
            <summary>A choice configuration key.</summary>
        </key>
    </schema>
</schemalist>

• myapp
  • data
    • schema
      • org.myapp.gschema.xml

from gi.repository import Gio
import os

def get_settings(schema_name, schema_dir = None):
    '''
    Charger un objet de configuration Gio.Settings.
    
    La méthode cherche d'abord si la configuration demandée est chargé globalement.
    Si ce n'est pas le cas, elle tentera de charger un schéma 'local', présent
    dans le répertoire 'schema_dir'.
    
    @param schema_name: Nom du schéma.
    @param schema_dir: répertoire du schéma.
    @return: Gio.Settings ou None
    '''
    schemas = Gio.Settings.list_schemas()
    
    if schema_name in schemas:
        return Gio.Settings.new(schema_name)
    
    if schema_dir is not None and os.path.isdir(schema_dir):
        schema_source = Gio.SettingsSchemaSource.new_from_directory(
            schema_dir, 
            Gio.SettingsSchemaSource.get_default(), 
            False
        )
        schema = schema_source.lookup(schema_name, False)
        
        if schema is not None:
            return Gio.Settings.new_full(schema, None, None)
    
    return None

const Gio = imports.gi.Gio;
/**
 *  Charger un objet de configuration Gio.Settings.
 *  
 *  La méthode cherche d'abord si la configuration demandée est chargé globalement.
 *  Si ce n'est pas le cas, elle tentera de charger un schéma 'local', présent
 *  dans le répertoire 'schema_dir'.
 *  
 *  @param {String} schema_name Nom du schéma.
 *  @param {String} [schema_dir] Répertoire local du schéma.
 *  @return {Gio.Settings|null}
 */
const get_settings = function (schema_name, schema_dir) {
    let schemas = Gio.Settings.list_schemas(),
        schema_source,
        schema;
    
    if (schema_name in schemas) {
        return new Gio.Settings({ settings_schema: schemas[schema_name] });
    }
    
    if (schema_dir) {
        let dir = Gio.File.new_for_path(schema_dir);
        if (!dir.query_exists(null)) {
            return null;
        }
    }
    schema_source = Gio.SettingsSchemaSource.new_from_directory(
        schema_dir,
        Gio.SettingsSchemaSource.get_default(),
        false
    );
    schema = schema_source.lookup(schema_name, false);
    
    if (schema) {
        return new Gio.Settings({ settings_schema: schema });
    }
    
    return null;
}

settings = get_settings('org.myapp', '/path/to/myapp/data/schema')

# Lecture de valeurs
strvalue = settings.get_string('strkey')
boolvalue = settings.get_boolean('boolkey')
intvalue = settings.get_int('intkey')

# Nouvelles valeurs
settings.set_string('strkey', 'new string')
settings.set_boolean('boolkey', False)
settings.set_int('intkey', 10)

var settings = get_settings('org.myapp', '/path/to/myapp/data/schema');

// Lecture de valeurs
var strvalue = settings.get_string('strkey');
var boolvalue = settings.get_boolean('boolkey');
var intvalue = settings.get_int('intkey');

// Nouvelles valeurs
settings.set_string('strkey', 'new string');
settings.set_boolean('boolkey', false);
settings.set_int('intkey', 10);

def on_settings_changed(settings, key, data = None):
    print key + ' has changed'

def on_strkey_changed(settings, key, data = None):
    print 'strkey has changed'

settings = get_settings('org.myapp', '/path/to/myapp/data/schema')
settings.connect('changed', on_settings_changed)
settings.connect('changed::strkey', on_strkey_changed)

var on_settings_changed = function (settings, key, data) {
    print(key + ' has changed');
};

var on_strkey_changed = function (settings, key, data) {
    print('strkey has changed');
};

var settings = get_settings('org.myapp', '/path/to/myapp/data/schema');
settings.connect('changed', on_settings_changed);
settings.connect('changed::strkey', on_strkey_changed);

The schemas are compiled in a database, that will only contain the default values and potential constraints about the values for a key. So if an application wants to access the description of a key (which is the exception, not the usual case), it will have to parse the XML files for this.

• myapp
  • commongjs
    • settings.js
    • utils.js
  • commonpy
    • settings.py
    • utils.py
  • data
    • schema
      • gschema.compiled
      • org.myapp.gschema.xml
    • ui
      • config.glade
  • myapp.js
  • myapp.py

• gedit-plugin
  • cfgplugin
    • common
      • settings.py
    • data
      • schema
        • gschemas.compiled
        • org.gnome.gedit.plugins.cfgplugin.gschema.xml
      • ui
        • config.glade
    • __init__.py
  • cfgplugin.plugin

# -*- coding: utf-8 -*-

import os
from gi.repository import GObject, Gtk, Gedit, PeasGtk, Gio
from common.settings import Settings

cdir        = os.path.dirname(__file__)
schema_dir  = os.path.join(cdir, 'data', 'schema')
schema_id   = 'org.gnome.gedit.plugins.cfgplugin'
schema_path = os.path.join(schema_dir, schema_id + '.gschema.xml')
ui_path     = os.path.join(cdir, 'data', 'ui', 'config.glade')
ui_ids      = ['config', 'intkey_adj']
cfg_prefs   = ['strkey', 'boolkey', 'intkey', 'choicekey']

# Gio.Settings
sets = Settings.get(schema_id, schema_dir)

class CfgPlugin(GObject.Object, Gedit.WindowActivatable, PeasGtk.Configurable):
    
    __gtype_name__ = 'CfgPlugin'
    
    window = GObject.property(type=Gedit.Window)
    
    def __init__(self):
        GObject.Object.__init__(self)
    
    def do_create_configure_widget(self):
        gui = Settings.Gui(sets, {
            'uipath'    : ui_path,
            'schemapath': schema_path,
            'ids'       : ui_ids,
            'prefs'     : cfg_prefs
        })
        return gui.get_widget()
        
    def do_activate(self):
        pass

    def do_deactivate(self):
        pass

    def do_update_state(self):
        pass