Different desktops use different methods. Unfortunately, it depends wholly on where the touchpad driver looks in your session. For example, Puppy Linux with JWM uses flsynclient, KDE uses (what at least used to be) Synaptiks. Really, it depends on which desktop you use. Generally speaking, it is best to leave it to whatever environment you use. If you use something like KDE and GNOME side-by-side, you may need to modify the X11 config files directly, because their individual settings don't interact. However, if you use GNOME or Xfce etc. almost exclusively, use the settings from that desktop.
The reason is simply convenience. If you edit X's configuration or use a third-party tool, when GNOME tries to shut off the touchpad, say for typing, it may be overridden by the environment. Extensions that manage touchpad will probably not work. Even if they do work, their settings are likely to be unreliable because when they do some automatic change, they will take over. On next reboot the system will have control because that's the way you have it set up.
The only case where another client is necessary is if you really need more settings than the environment you use offers.
Note that LightDM has its own user, and so you can log in using Su to change the settings. I believe that the lightdm user has a gnome control center as well and can set settings for touchpad that way, but I have no way of telling for sure.
You can copy and compile your Gsettings Schemas to a user-writable directory:
$ cp com.companyname.appname ~/schemas/
$ glib-compile-schemas ~/schemas/
The tricky bit is to configure the application to use that particular directory. There are two ways to do this:
With the GSETTINGS_SCHEMA_DIR environment variable:
$ GSETTINGS_SCHEMA_DIR=~/schemas/ ./example.py
Or using GSettingsSchemaSource and GSettingSchema objects:
If you have access to the source code of your program, you can modify it to load compiled schemas from any directory. Here's how would do it in Python, although you could do this in any programming language with GObject introspection:
schema_source = Gio.SettingsSchemaSource.new_from_directory(
os.path.expanduser("~/schemas"),
Gio.SettingsSchemaSource.get_default(),
False,
)
schema = schema_source.lookup('com.companyname.appname', False)
settings = Gio.Settings.new_full(schema, None, None)
settings.set_boolean('mybool', True)
References:
Best Answer
It is not possible to do this with
gsettings, as the option simply does not exist. There is extensive documentation ongsettingsand the internals of the program at the official Gnome site.However, there is an interesting project at github called
gsettings-infothat does exactly what you ask. It is a script that queries information about either schemas and/or keys from the gschema information and returns the same data about them that is displayed when you usedconf-editor.You'll requiere Git and git xsltproc (library that it uses to read the gschema information)
Obtain the program with:
Now you can run the script
You can either run it from the home folder (and occasionally update it by going to the folder and using
git pull), or install to the system or place it in your~/binfolder so it is available by just enteringgsettings-info.If you are running it from the downloaded folder, entering
./gsettings-info helpwill give all the options, as does the README and the information at the Github page.You can find much information on both the schemas and keys. Here is an example of how to find data about certain keys. This assumes it is run from the downloaded folder, and so
./is needed to run the script.To find out details about the particular keys of the chosen schema, enter:
which returns:
To show defaults and information for a particular key, use:
which returns:
This seems to be exactly what your are looking for, and is about the only way to show this information on the command-line instead of in
dconf-editor.