GSettings : écran de configuration

Comment automatiser la création d'un écran de configuration d'une application en se basant sur un schéma GSettings.

Présentation

Nous allons illustrer l'utilisation de GSettings avec l'écriture d'un écran de configuration de 2 applications écrites avec 2 languages de programmation différents : une extension gnome-shell écrite en javascript et un plugin Gedit écrit en python.

Liaison entre composant graphique et clé GSettings

La liaison entre un composant graphique et une clé GSettings se fait par l'intermédiaire de la méthode bind d'un objet GSettings :

method
void bind ( key , object , property , flag )
param
String key Nom de la clé du schéma
param
Object object Composant graphique lié à la clé.
param
String property Propriété de l'objet liée à la clé.
param
GSettingsBindingFlags flag Flag

L'objet en question sera un composant graphique GTK adpaté au type de la clé, par exemple :

  • Gtk.Entry pour une chaîne de caractères.
  • Gtk.SpinButton pour une entier.
  • Gtk.Switch pour un booléen.

On pourra aussi gérer certains cas particuliers : une clé String ayant une liste de choix pourra être liée à une Gtk.ComboBoxText.

Le module settings

J'ai créé un module settings en javascript et en python à la fois pour faciliter l'utilisation de schémas Gsettings en « embarqué » dans une application mais aussi pour automatiser la création d'une interface graphique de configuration basée sur les clés d'un schéma Gsettings.

method
Gio.Settings get ( schema_name [ , schema_dir ] )
Description
Récupérer un objet GSettings.
param
String schema_name Nom du chemin
param
String schema_dir Chemin local éventuel - optional
return
Gio.Settings

La méthode get reprend purement et simplement le code de la méthode get_settings vue dans l'article expliquant comment utiliser un schéma GSettings.

method
Object get_details ( schema_path , schema_name )
Description
Parser le fichier xml décrivant le schéma GSettings pour récupérer les informations concernant les clés
param
String schema_path Chemin du fichier GSettings.
param
String schema_name Identifiant du schéma.
return
Object

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.

GSettings Hackfest: Day 1

Les schémas GSettings sont utilisés sous forme compilée et cette compilation ne stocke que les valeurs des clés, pas les autres informations qui pourraient être utiles lors de la création d'un écran de configuration, comme le résumé ou la description des clés. Pour récupérer toutes les informations des clés, il faut donc lire le fichier xml du schéma, ce que la méthode get_details fait.

class
Gui ( settings , cfg )
Description
Classe de génération d'interface graphique pour un fichier de configuration.
param
Gio.Settings settings Objet
param
Object cfg Objet de configuration.
  • String ui_path Chemin du fichier Glade construisant l'interface graphique.
  • String[] ids Liste des identifiants des composants graphiques à lier.

Décrire l'utilisation de Gui.

Utilisation dans une application

On peut utiliser le module settings dans une application GTK : nous allons en créé une un peu particulière

  • 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
organisation de l'application GTK.

Capture d'écran

Ecran de l'application construit à partir d'un fichier Glade.

Capture d'écran

Ecran de l'application construit automatiquement.

Cas des extensions gnome-shell

La configuration des extensions gnome-shell se fait par l'intermédiaire d'un fichier prefs.js. Celui-ci doit contenir une méthode buildPrefsWidget qui retourne le contenu qui sera placé dans la fenêtre de configuration.

  • gnome-shell-extension
    • common
      • settings.js
    • data
      • schema
        • gschemas.compiled
        • org.gnome.shell.extensions.cfgext.gschema.xml
      • ui
        • config.glade
    • extension.js
    • metadata.json
    • prefs.js
Contenu d'une extension gnome-shell.
Contenu indisponible.
Contenu du fichier prefs.js.

Capture d'écran

Ecran de configuration d'une extension gnome-shell.

Cas des plugins Gedit

Gedit permet la définition de l'écran de configuration d'un plugin si celui-ci implémente l'interface PeasGtk.Configurable. La méthode do_create_configure_widget doit alors retourner le contenu qui sera placé dans la fenêtre de configuration.

  • gedit-plugin
    • cfgplugin
      • common
        • settings.py
      • data
        • schema
          • gschemas.compiled
          • org.gnome.gedit.plugins.cfgplugin.gschema.xml
        • ui
          • config.glade
      • __init__.py
    • cfgplugin.plugin
Contenu d'un plugin Gedit.
# -*- 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
Contenu du fichier prefs.js.

Capture d'écran

Ecran de configuration d'un plugin Gedit.

Ressources et références

GIO Reference Manual. Gnome Dev Center. GSettings

GIO Reference Manual. Gnome Dev Center. Running GIO applications

BASTIAN, Waldo ; LORTIE, Ryan ; POETTERING, Lennart. XDG Base Directory Specification. freedesktop.org

GConf Reference Manual. Gnome Dev Center

CARRICK, Micah. Using GSettings with Python/PyGObject. micahcarrick.com,

Extensions. Gnome Live, . Extension Preferences