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

// 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 crate::Initable;
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::{boxed::Box as Box_, fmt, mem::transmute};

glib::wrapper! {
    /// [`DebugController`][crate::DebugController] is an interface to expose control of debugging features and
    /// debug output.
    ///
    /// It is implemented on Linux using [`DebugControllerDBus`][crate::DebugControllerDBus], which exposes a D-Bus
    /// interface to allow authenticated peers to control debug features in this
    /// process.
    ///
    /// Whether debug output is enabled is exposed as
    /// [`debug-enabled`][struct@crate::DebugController#debug-enabled]. This controls `g_log_set_debug_enabled()` by
    /// default. Application code may connect to the [`notify`][struct@crate::glib::Object#notify] signal for it
    /// to control other parts of its debug infrastructure as necessary.
    ///
    /// If your application or service is using the default GLib log writer function,
    /// creating one of the built-in implementations of [`DebugController`][crate::DebugController] should be
    /// all that’s needed to dynamically enable or disable debug output.
    ///
    /// ## Properties
    ///
    ///
    /// #### `debug-enabled`
    ///  [`true`] if debug output should be exposed (for example by forwarding it to
    /// the journal), [`false`] otherwise.
    ///
    /// Readable | Writeable
    ///
    /// # Implements
    ///
    /// [`DebugControllerExt`][trait@crate::prelude::DebugControllerExt], [`InitableExt`][trait@crate::prelude::InitableExt]
    #[doc(alias = "GDebugController")]
    pub struct DebugController(Interface<ffi::GDebugController, ffi::GDebugControllerInterface>) @requires Initable;

    match fn {
        type_ => || ffi::g_debug_controller_get_type(),
    }
}

impl DebugController {
    pub const NONE: Option<&'static DebugController> = None;
}

/// Trait containing all [`struct@DebugController`] methods.
///
/// # Implementors
///
/// [`DebugControllerDBus`][struct@crate::DebugControllerDBus], [`DebugController`][struct@crate::DebugController]
pub trait DebugControllerExt: 'static {
    /// Get the value of [`debug-enabled`][struct@crate::DebugController#debug-enabled].
    ///
    /// # Returns
    ///
    /// [`true`] if debug output should be exposed, [`false`] otherwise
    #[doc(alias = "g_debug_controller_get_debug_enabled")]
    #[doc(alias = "get_debug_enabled")]
    fn is_debug_enabled(&self) -> bool;

    /// Set the value of [`debug-enabled`][struct@crate::DebugController#debug-enabled].
    /// ## `debug_enabled`
    /// [`true`] if debug output should be exposed, [`false`] otherwise
    #[doc(alias = "g_debug_controller_set_debug_enabled")]
    fn set_debug_enabled(&self, debug_enabled: bool);

    #[cfg(any(feature = "v2_72", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_72")))]
    #[doc(alias = "debug-enabled")]
    fn connect_debug_enabled_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
}

impl<O: IsA<DebugController>> DebugControllerExt for O {
    fn is_debug_enabled(&self) -> bool {
        unsafe {
            from_glib(ffi::g_debug_controller_get_debug_enabled(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn set_debug_enabled(&self, debug_enabled: bool) {
        unsafe {
            ffi::g_debug_controller_set_debug_enabled(
                self.as_ref().to_glib_none().0,
                debug_enabled.into_glib(),
            );
        }
    }

    #[cfg(any(feature = "v2_72", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_72")))]
    fn connect_debug_enabled_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_debug_enabled_trampoline<
            P: IsA<DebugController>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GDebugController,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(DebugController::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::debug-enabled\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_debug_enabled_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl fmt::Display for DebugController {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str("DebugController")
    }
}