Package ch.bailu.gtk.gio

Class SettingsBackend

java.lang.Object
ch.bailu.gtk.type.Type
ch.bailu.gtk.type.Pointer
ch.bailu.gtk.gobject.Object
ch.bailu.gtk.gio.SettingsBackend
All Implemented Interfaces:
PointerInterface
public class SettingsBackend extends Object
The #GSettingsBackend interface defines a generic interface for
non-strictly-typed data that is stored in a hierarchy. To implement
an alternative storage backend for #GSettings, you need to implement
the #GSettingsBackend interface and then make it implement the
extension point %G_SETTINGS_BACKEND_EXTENSION_POINT_NAME.

The interface defines methods for reading and writing values, a
method for determining if writing of certain values will fail
(lockdown) and a change notification mechanism.

The semantics of the interface are very precisely defined and
implementations must carefully adhere to the expectations of
callers that are documented on each of the interface methods.

Some of the #GSettingsBackend functions accept or return a #GTree.
These trees always have strings as keys and #GVariant as values.
g_settings_backend_create_tree() is a convenience function to create
suitable trees.

The #GSettingsBackend API is exported to allow third-party
implementations, but does not carry the same stability guarantees
as the public GIO API. For this reason, you have to define the
C preprocessor symbol %G_SETTINGS_ENABLE_BACKEND before including
`gio/gsettingsbackend.h`.

https://docs.gtk.org/gio/class.SettingsBackend.html

  • Constructor Details

  • Method Details

    • getClassHandler

      public static ClassHandler getClassHandler()

    • changed

      public void changed(@Nonnull Str key, @Nullable Pointer origin_tag)
      Signals that a single key has possibly changed. Backend
      implementations should call this if a key has possibly changed its
      value.

      @key must be a valid key (ie starting with a slash, not containing
      '//', and not ending with a slash).

      The implementation must call this function during any call to
      g_settings_backend_write(), before the call returns (except in the
      case that no keys are actually changed and it cares to detect this
      fact). It may not rely on the existence of a mainloop for
      dispatching the signal later.

      The implementation may call this function at any other time it likes
      in response to other events (such as changes occurring outside of the
      program). These calls may originate from a mainloop or may originate
      in response to any other action (including from calls to
      g_settings_backend_write()).

      In the case that this call is in response to a call to
      g_settings_backend_write() then @origin_tag must be set to the same
      value that was passed to that call.
      Parameters:
      key - the name of the key
      origin_tag - the origin tag

    • changed

      public void changed(String key, @Nullable Pointer origin_tag)
      Signals that a single key has possibly changed. Backend
      implementations should call this if a key has possibly changed its
      value.

      @key must be a valid key (ie starting with a slash, not containing
      '//', and not ending with a slash).

      The implementation must call this function during any call to
      g_settings_backend_write(), before the call returns (except in the
      case that no keys are actually changed and it cares to detect this
      fact). It may not rely on the existence of a mainloop for
      dispatching the signal later.

      The implementation may call this function at any other time it likes
      in response to other events (such as changes occurring outside of the
      program). These calls may originate from a mainloop or may originate
      in response to any other action (including from calls to
      g_settings_backend_write()).

      In the case that this call is in response to a call to
      g_settings_backend_write() then @origin_tag must be set to the same
      value that was passed to that call.
      Parameters:
      key - the name of the key
      origin_tag - the origin tag

    • changedTree

      public void changedTree(@Nonnull Tree tree, @Nullable Pointer origin_tag)
      This call is a convenience wrapper. It gets the list of changes from
      @tree, computes the longest common prefix and calls
      g_settings_backend_changed().
      Parameters:
      tree - a #GTree containing the changes
      origin_tag - the origin tag

    • pathChanged

      public void pathChanged(@Nonnull Str path, @Nullable Pointer origin_tag)
      Signals that all keys below a given path may have possibly changed.
      Backend implementations should call this if an entire path of keys
      have possibly changed their values.

      @path must be a valid path (ie starting and ending with a slash and
      not containing '//').

      The meaning of this signal is that any of the key which has a name
      starting with @path may have changed.

      The same rules for when notifications must occur apply as per
      g_settings_backend_changed(). This call might be an appropriate
      reasponse to a 'reset' call but implementations are also free to
      explicitly list the keys that were affected by that call if they can
      easily do so.

      For efficiency reasons, the implementation should strive for @path to
      be as long as possible (ie: the longest common prefix of all of the
      keys that were changed) but this is not strictly required. As an
      example, if this function is called with the path of "/" then every
      single key in the application will be notified of a possible change.
      Parameters:
      path - the path containing the changes
      origin_tag - the origin tag

    • pathChanged

      public void pathChanged(String path, @Nullable Pointer origin_tag)
      Signals that all keys below a given path may have possibly changed.
      Backend implementations should call this if an entire path of keys
      have possibly changed their values.

      @path must be a valid path (ie starting and ending with a slash and
      not containing '//').

      The meaning of this signal is that any of the key which has a name
      starting with @path may have changed.

      The same rules for when notifications must occur apply as per
      g_settings_backend_changed(). This call might be an appropriate
      reasponse to a 'reset' call but implementations are also free to
      explicitly list the keys that were affected by that call if they can
      easily do so.

      For efficiency reasons, the implementation should strive for @path to
      be as long as possible (ie: the longest common prefix of all of the
      keys that were changed) but this is not strictly required. As an
      example, if this function is called with the path of "/" then every
      single key in the application will be notified of a possible change.
      Parameters:
      path - the path containing the changes
      origin_tag - the origin tag

    • pathWritableChanged

      public void pathWritableChanged(@Nonnull Str path)
      Signals that the writability of all keys below a given path may have
      changed.

      Since GSettings performs no locking operations for itself, this call
      will always be made in response to external events.
      Parameters:
      path - the name of the path

    • pathWritableChanged

      public void pathWritableChanged(String path)
      Signals that the writability of all keys below a given path may have
      changed.

      Since GSettings performs no locking operations for itself, this call
      will always be made in response to external events.
      Parameters:
      path - the name of the path

    • writableChanged

      public void writableChanged(@Nonnull Str key)
      Signals that the writability of a single key has possibly changed.

      Since GSettings performs no locking operations for itself, this call
      will always be made in response to external events.
      Parameters:
      key - the name of the key

    • writableChanged

      public void writableChanged(String key)
      Signals that the writability of a single key has possibly changed.

      Since GSettings performs no locking operations for itself, this call
      will always be made in response to external events.
      Parameters:
      key - the name of the key

    • getDefault

      public static SettingsBackend getDefault()
      Returns the default #GSettingsBackend. It is possible to override
      the default by setting the `GSETTINGS_BACKEND` environment variable
      to the name of a settings backend.

      The user gets a reference to the backend.
      Returns:
      the default #GSettingsBackend, which will be a dummy (memory) settings backend if no other settings backend is available.

    • getTypeID

      public static long getTypeID()

    • getParentTypeID

      public static long getParentTypeID()

    • getTypeSize

      public static TypeSystem.TypeSize getTypeSize()

    • getParentTypeSize

      public static TypeSystem.TypeSize getParentTypeSize()

    • getInstanceSize

      public static int getInstanceSize()