1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

use gio_sys;
use glib::object::IsA;
use glib::translate::*;
use std::fmt;

glib_wrapper! {
    /// The `SettingsBackend` interface defines a generic interface for
    /// non-strictly-typed data that is stored in a hierarchy. To implement
    /// an alternative storage backend for `Settings`, you need to implement
    /// the `SettingsBackend` 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 `SettingsBackend` functions accept or return a `glib::Tree`.
    /// These trees always have strings as keys and `glib::Variant` as values.
    /// `g_settings_backend_create_tree` is a convenience function to create
    /// suitable trees.
    ///
    /// The `SettingsBackend` 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`.
    ///
    /// # Implements
    ///
    /// [`SettingsBackendExt`](trait.SettingsBackendExt.html), [`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html)
    pub struct SettingsBackend(Object<gio_sys::GSettingsBackend, gio_sys::GSettingsBackendClass, SettingsBackendClass>);

    match fn {
        get_type => || gio_sys::g_settings_backend_get_type(),
    }
}

impl SettingsBackend {
    //pub fn flatten_tree(tree: /*Ignored*/&glib::Tree) -> (GString, Vec<GString>, Vec<glib::Variant>) {
    //    unsafe { TODO: call gio_sys:g_settings_backend_flatten_tree() }
    //}

    /// Returns the default `SettingsBackend`. 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 `SettingsBackend`
    pub fn get_default() -> Option<SettingsBackend> {
        unsafe { from_glib_full(gio_sys::g_settings_backend_get_default()) }
    }
}

pub const NONE_SETTINGS_BACKEND: Option<&SettingsBackend> = None;

/// Trait containing all `SettingsBackend` methods.
///
/// # Implementors
///
/// [`SettingsBackend`](struct.SettingsBackend.html)
pub trait SettingsBackendExt: 'static {
    //fn changed(&self, key: &str, origin_tag: /*Unimplemented*/Option<Fundamental: Pointer>);

    //fn changed_tree(&self, tree: /*Ignored*/&glib::Tree, origin_tag: /*Unimplemented*/Option<Fundamental: Pointer>);

    //fn keys_changed(&self, path: &str, items: &[&str], origin_tag: /*Unimplemented*/Option<Fundamental: Pointer>);

    //fn path_changed(&self, path: &str, origin_tag: /*Unimplemented*/Option<Fundamental: Pointer>);

    /// 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.
    /// ## `path`
    /// the name of the path
    fn path_writable_changed(&self, path: &str);

    /// 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.
    /// ## `key`
    /// the name of the key
    fn writable_changed(&self, key: &str);
}

impl<O: IsA<SettingsBackend>> SettingsBackendExt for O {
    //fn changed(&self, key: &str, origin_tag: /*Unimplemented*/Option<Fundamental: Pointer>) {
    //    unsafe { TODO: call gio_sys:g_settings_backend_changed() }
    //}

    //fn changed_tree(&self, tree: /*Ignored*/&glib::Tree, origin_tag: /*Unimplemented*/Option<Fundamental: Pointer>) {
    //    unsafe { TODO: call gio_sys:g_settings_backend_changed_tree() }
    //}

    //fn keys_changed(&self, path: &str, items: &[&str], origin_tag: /*Unimplemented*/Option<Fundamental: Pointer>) {
    //    unsafe { TODO: call gio_sys:g_settings_backend_keys_changed() }
    //}

    //fn path_changed(&self, path: &str, origin_tag: /*Unimplemented*/Option<Fundamental: Pointer>) {
    //    unsafe { TODO: call gio_sys:g_settings_backend_path_changed() }
    //}

    fn path_writable_changed(&self, path: &str) {
        unsafe {
            gio_sys::g_settings_backend_path_writable_changed(
                self.as_ref().to_glib_none().0,
                path.to_glib_none().0,
            );
        }
    }

    fn writable_changed(&self, key: &str) {
        unsafe {
            gio_sys::g_settings_backend_writable_changed(
                self.as_ref().to_glib_none().0,
                key.to_glib_none().0,
            );
        }
    }
}

impl fmt::Display for SettingsBackend {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "SettingsBackend")
    }
}