Fully refactored project architecture, imports and etc.

src/view/components/mod.rs

@@ -0,0 +1,3 @@
+pub mod wrapper;
+pub mod switch;
+pub mod tabs;

src/view/components/switch.rs

@@ -0,0 +1,153 @@
+pub mod switch_module {
+
+    use gtk4 as gtk;
+
+    use gtk::{*, prelude::*};
+
+    use glib::{
+        signal::{connect_raw, SignalHandlerId},
+        translate::*,
+    };
+
+    use std::boxed::Box as Box_;
+
+    mod sealed {
+        pub trait Sealed {}
+        impl<T: super::IsA<super::Switch>> Sealed for T {}
+    }
+
+    pub trait SwitchExt: IsA<Switch> + sealed::Sealed + 'static {
+        #[doc(alias = "gtk_switch_get_active")]
+        #[doc(alias = "get_active")]
+        fn is_active(&self) -> bool {
+            unsafe { from_glib(ffi::gtk_switch_get_active(self.as_ref().to_glib_none().0)) }
+        }
+
+        #[doc(alias = "gtk_switch_get_state")]
+        #[doc(alias = "get_state")]
+        fn state(&self) -> bool {
+            unsafe { from_glib(ffi::gtk_switch_get_state(self.as_ref().to_glib_none().0)) }
+        }
+
+        #[doc(alias = "gtk_switch_set_active")]
+        fn set_active(&self, is_active: bool) {
+            unsafe {
+                ffi::gtk_switch_set_active(self.as_ref().to_glib_none().0, is_active.into_glib());
+            }
+        }
+
+        #[doc(alias = "gtk_switch_set_state")]
+        fn set_state(&self, state: bool) {
+            unsafe {
+                ffi::gtk_switch_set_state(self.as_ref().to_glib_none().0, state.into_glib());
+            }
+        }
+
+        #[doc(alias = "activate")]
+        fn connect_activate<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
+            unsafe extern "C" fn activate_trampoline<P: IsA<Switch>, F: Fn(&P) + 'static>(
+                this: *mut ffi::GtkSwitch,
+                f: glib::ffi::gpointer,
+            ) {
+                let f: &F = &*(f as *const F);
+                f(Switch::from_glib_borrow(this).unsafe_cast_ref())
+            }
+            unsafe {
+                let f: Box_<F> = Box_::new(f);
+                connect_raw(
+                    self.as_ptr() as *mut _,
+                    b"activate\0".as_ptr() as *const _,
+                    Some(std::mem::transmute::<_, unsafe extern "C" fn()>(
+                        activate_trampoline::<Self, F> as *const (),
+                    )),
+                    Box_::into_raw(f),
+                )
+            }
+        }
+
+        fn emit_activate(&self) {
+            self.emit_by_name::<()>("activate", &[]);
+        }
+
+        #[doc(alias = "state-set")]
+        fn connect_state_set<F: Fn(&Self, bool) -> glib::Propagation + 'static>(
+            &self,
+            f: F,
+        ) -> SignalHandlerId {
+            unsafe extern "C" fn state_set_trampoline<
+                P: IsA<Switch>,
+                F: Fn(&P, bool) -> glib::Propagation + 'static,
+            >(
+                this: *mut ffi::GtkSwitch,
+                state: glib::ffi::gboolean,
+                f: glib::ffi::gpointer,
+            ) -> glib::ffi::gboolean {
+                let f: &F = &*(f as *const F);
+                f(
+                    Switch::from_glib_borrow(this).unsafe_cast_ref(),
+                    from_glib(state),
+                )
+                    .into_glib()
+            }
+            unsafe {
+                let f: Box_<F> = Box_::new(f);
+                connect_raw(
+                    self.as_ptr() as *mut _,
+                    b"state-set\0".as_ptr() as *const _,
+                    Some(std::mem::transmute::<_, unsafe extern "C" fn()>(
+                        state_set_trampoline::<Self, F> as *const (),
+                    )),
+                    Box_::into_raw(f),
+                )
+            }
+        }
+
+        #[doc(alias = "active")]
+        fn connect_active_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
+            unsafe extern "C" fn notify_active_trampoline<P: IsA<Switch>, F: Fn(&P) + 'static>(
+                this: *mut ffi::GtkSwitch,
+                _param_spec: glib::ffi::gpointer,
+                f: glib::ffi::gpointer,
+            ) {
+                let f: &F = &*(f as *const F);
+                f(Switch::from_glib_borrow(this).unsafe_cast_ref())
+            }
+            unsafe {
+                let f: Box_<F> = Box_::new(f);
+                connect_raw(
+                    self.as_ptr() as *mut _,
+                    b"notify::active\0".as_ptr() as *const _,
+                    Some(std::mem::transmute::<_, unsafe extern "C" fn()>(
+                        notify_active_trampoline::<Self, F> as *const (),
+                    )),
+                    Box_::into_raw(f),
+                )
+            }
+        }
+
+        #[doc(alias = "state")]
+        fn connect_state_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
+            unsafe extern "C" fn notify_state_trampoline<P: IsA<Switch>, F: Fn(&P) + 'static>(
+                this: *mut ffi::GtkSwitch,
+                _param_spec: glib::ffi::gpointer,
+                f: glib::ffi::gpointer,
+            ) {
+                let f: &F = &*(f as *const F);
+                f(Switch::from_glib_borrow(this).unsafe_cast_ref())
+            }
+            unsafe {
+                let f: Box_<F> = Box_::new(f);
+                connect_raw(
+                    self.as_ptr() as *mut _,
+                    b"notify::state\0".as_ptr() as *const _,
+                    Some(std::mem::transmute::<_, unsafe extern "C" fn()>(
+                        notify_state_trampoline::<Self, F> as *const (),
+                    )),
+                    Box_::into_raw(f),
+                )
+            }
+        }
+    }
+
+    impl<O: IsA<Switch>> SwitchExt for O {}
+}

src/view/components/tabs.rs

@@ -0,0 +1,71 @@
+pub mod tabs_module {
+
+    use gtk4 as gtk;
+
+    use gtk::{Notebook, Label, Box};
+
+    pub type TabLabel = Label;
+    pub type TabContent = Box;
+
+    #[derive(Clone)]
+    pub struct TabsBuilder {
+        tabs: Vec<(TabLabel, TabContent)>
+    }
+
+    pub struct Tabs {
+        tabs_wrapper: Notebook
+    }
+
+    impl Tabs {
+        pub fn builder() -> TabsBuilder {
+            TabsBuilder{
+                tabs: Vec::new(),
+            }
+        }
+
+        pub fn get(self) -> Notebook {
+            self.tabs_wrapper
+        }
+
+    }
+
+    impl TabsBuilder {
+
+        fn append_tab_private(&mut self, label: &str, page: TabContent) {
+            let tab_label = Label::new(Some(label));
+            self.tabs.push((tab_label, page));
+        }
+
+        pub fn add_tab(mut self, label: &str, page: TabContent) -> Self {
+            self.append_tab_private(label, page);
+
+            self
+        }
+
+        pub fn add_tabs(mut self, labels: Vec<&str>, pages: Vec<TabContent>) -> Self {
+            for (label, page) in labels.iter().zip(pages) {
+                self.append_tab_private(label, page);
+            }
+
+            self
+        }
+
+        pub fn build(&mut self, group_name: &str) -> Tabs {
+            let tabs_wrapper = Notebook::builder()
+                .group_name(group_name)
+                .build();
+
+            self.tabs
+                .iter()
+                .for_each(|(label, content)| {
+                    tabs_wrapper.append_page(content, Some(label));
+                });
+
+            Tabs {
+                tabs_wrapper
+            }
+        }
+
+    }
+
+}

src/view/components/wrapper.rs

@@ -0,0 +1,23 @@
+pub mod wrapper_module {
+
+    use gtk4 as gtk;
+
+    use gtk::{Orientation, builders::BoxBuilder, Box};
+
+    #[allow(dead_code)]
+    pub struct Wrapper;
+
+    impl Wrapper{
+
+        pub fn row_builder() -> BoxBuilder {
+            Box::builder().orientation(Orientation::Vertical)
+        }
+
+        pub fn col_builder() -> BoxBuilder {
+            Box::builder().orientation(Orientation::Horizontal)
+        }
+
+    }
+
+}
+