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
140
141
142
143
144
145
146
147
148

// 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::Box;
use crate::Buildable;
use crate::Container;
use crate::Orientable;
use crate::Stack;
use crate::Widget;
use glib::object::Cast;
use glib::object::IsA;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use std::boxed::Box as Box_;
use std::fmt;
use std::mem::transmute;

glib::wrapper! {
    /// The GtkStackSwitcher widget acts as a controller for a
    /// [`Stack`][crate::Stack]; it shows a row of buttons to switch between
    /// the various pages of the associated stack widget.
    ///
    /// All the content for the buttons comes from the child properties
    /// of the [`Stack`][crate::Stack]; the button visibility in a [`StackSwitcher`][crate::StackSwitcher]
    /// widget is controlled by the visibility of the child in the
    /// [`Stack`][crate::Stack].
    ///
    /// It is possible to associate multiple [`StackSwitcher`][crate::StackSwitcher] widgets
    /// with the same [`Stack`][crate::Stack] widget.
    ///
    /// The GtkStackSwitcher widget was added in 3.10.
    ///
    /// # CSS nodes
    ///
    /// GtkStackSwitcher has a single CSS node named stackswitcher and
    /// style class .stack-switcher.
    ///
    /// When circumstances require it, GtkStackSwitcher adds the
    /// .needs-attention style class to the widgets representing the
    /// stack pages.
    ///
    /// # Implements
    ///
    /// [`StackSwitcherExt`][trait@crate::prelude::StackSwitcherExt], [`BoxExt`][trait@crate::prelude::BoxExt], [`ContainerExt`][trait@crate::prelude::ContainerExt], [`WidgetExt`][trait@crate::prelude::WidgetExt], [`trait@glib::ObjectExt`], [`BuildableExt`][trait@crate::prelude::BuildableExt], [`OrientableExt`][trait@crate::prelude::OrientableExt], [`StackSwitcherExtManual`][trait@crate::prelude::StackSwitcherExtManual], [`ContainerExtManual`][trait@crate::prelude::ContainerExtManual], [`WidgetExtManual`][trait@crate::prelude::WidgetExtManual], [`BuildableExtManual`][trait@crate::prelude::BuildableExtManual]
    #[doc(alias = "GtkStackSwitcher")]
    pub struct StackSwitcher(Object<ffi::GtkStackSwitcher, ffi::GtkStackSwitcherClass>) @extends Box, Container, Widget, @implements Buildable, Orientable;

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

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

    /// Create a new [`StackSwitcher`][crate::StackSwitcher].
    ///
    /// # Returns
    ///
    /// a new [`StackSwitcher`][crate::StackSwitcher].
    #[doc(alias = "gtk_stack_switcher_new")]
    pub fn new() -> StackSwitcher {
        assert_initialized_main_thread!();
        unsafe { Widget::from_glib_none(ffi::gtk_stack_switcher_new()).unsafe_cast() }
    }
}

impl Default for StackSwitcher {
    fn default() -> Self {
        Self::new()
    }
}

/// Trait containing all [`struct@StackSwitcher`] methods.
///
/// # Implementors
///
/// [`StackSwitcher`][struct@crate::StackSwitcher]
pub trait StackSwitcherExt: 'static {
    /// Retrieves the stack.
    /// See [`set_stack()`][Self::set_stack()].
    ///
    /// # Returns
    ///
    /// the stack, or [`None`] if
    ///  none has been set explicitly.
    #[doc(alias = "gtk_stack_switcher_get_stack")]
    #[doc(alias = "get_stack")]
    fn stack(&self) -> Option<Stack>;

    /// Sets the stack to control.
    /// ## `stack`
    /// a [`Stack`][crate::Stack]
    #[doc(alias = "gtk_stack_switcher_set_stack")]
    fn set_stack(&self, stack: Option<&impl IsA<Stack>>);

    #[doc(alias = "stack")]
    fn connect_stack_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
}

impl<O: IsA<StackSwitcher>> StackSwitcherExt for O {
    fn stack(&self) -> Option<Stack> {
        unsafe {
            from_glib_none(ffi::gtk_stack_switcher_get_stack(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn set_stack(&self, stack: Option<&impl IsA<Stack>>) {
        unsafe {
            ffi::gtk_stack_switcher_set_stack(
                self.as_ref().to_glib_none().0,
                stack.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    fn connect_stack_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_stack_trampoline<P: IsA<StackSwitcher>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkStackSwitcher,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(StackSwitcher::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::stack\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_stack_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

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