sysd-manager 2.19.4

Application to empower user to manage their <b>systemd units</b> via Graphical User Interface. Not only are you able to make changes to the enablement and running status of each of the units, but you will also be able to view and modify their unit files and check the journal logs.
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

use glib::{WeakRef, subclass::types::ObjectSubclassIsExt};
use gtk::glib::{self};

use crate::widget::creator::UnitCreatorWindow;

glib::wrapper! {

    pub struct LaunchCreatorPage(ObjectSubclass<imp::LaunchCreatorPageImp>)
    @extends adw::NavigationPage,  gtk::Widget,
    @implements gtk::Accessible,  gtk::Buildable,  gtk::ConstraintTarget ;
}

impl LaunchCreatorPage {
    pub fn new(window: WeakRef<UnitCreatorWindow>) -> Self {
        let obj: LaunchCreatorPage = glib::Object::new();
        obj.imp().set_window(window);
        obj
    }
}

mod imp {

    use super::*;
    use crate::{upgrade, widget::creator::UnitCreateType};
    use adw::subclass::prelude::*;
    use gtk::{glib, prelude::*};
    use std::cell::{Cell, OnceCell};

    #[derive(Default, gtk::CompositeTemplate, glib::Properties)]
    #[template(resource = "/io/github/plrigaux/sysd-manager/launch_creator_page.ui")]
    #[properties(wrapper_type = super::LaunchCreatorPage)]
    pub struct LaunchCreatorPageImp {
        #[property(get, set, default)]
        creation_type: Cell<UnitCreateType>,

        #[template_child]
        daemon_reload_switch: TemplateChild<adw::SwitchRow>,
        #[template_child]
        enable_switch: TemplateChild<adw::SwitchRow>,
        #[template_child]
        start_switch: TemplateChild<adw::SwitchRow>,

        pub(super) window: OnceCell<WeakRef<UnitCreatorWindow>>,
        // #[property(get)]
        // pub(super) data: OnceCell<UnitFileData>,
    }

    #[glib::object_subclass]
    impl ObjectSubclass for LaunchCreatorPageImp {
        const NAME: &'static str = "LaunchCreatorPage";
        type Type = LaunchCreatorPage;
        type ParentType = adw::NavigationPage;

        fn class_init(klass: &mut Self::Class) {
            // The layout manager determines how child widgets are laid out.
            klass.bind_template();
            // klass.bind_template_callbacks();
        }

        fn instance_init(obj: &glib::subclass::InitializingObject<Self>) {
            obj.init_template();
        }
    }

    #[glib::derived_properties]
    impl ObjectImpl for LaunchCreatorPageImp {
        fn constructed(&self) {
            self.parent_constructed();

            let daemon_reload_active = self.daemon_reload_switch.is_active();
            self.enable_switch.set_sensitive(daemon_reload_active);
            self.start_switch.set_sensitive(daemon_reload_active);
        }
    }

    impl LaunchCreatorPageImp {
        pub fn set_window(&self, window_weak: WeakRef<UnitCreatorWindow>) {
            let _ = self.window.set(window_weak.clone());

            let window = upgrade!(window_weak);

            const ACTION_CREATOR_DAEMON_RELOAD: &str = "creator.daemon-reload";
            let daemon_reload_entry: gio::ActionEntry<_> = {
                let enable_switch = self.enable_switch.downgrade();
                let start_switch = self.start_switch.downgrade();
                gio::ActionEntry::builder(&ACTION_CREATOR_DAEMON_RELOAD[8..])
                    .activate(move |_, action, _| {
                        let Some(state) = action.state().and_then(|var| var.get::<bool>()) else {
                            return;
                        };
                        let state = !state;
                        action.set_state(&(state).to_variant());

                        if let Some(enable_switch) = enable_switch.upgrade() {
                            enable_switch.set_sensitive(state);
                            enable_switch.set_active(false);
                        }

                        if let Some(start_switch) = start_switch.upgrade() {
                            start_switch.set_sensitive(state);
                            start_switch.set_active(false);
                        }
                    })
                    .parameter_type(Some(glib::VariantTy::BOOLEAN))
                    .state(false.to_variant())
                    .build()
            };

            let action_group = window.action_group();
            action_group.add_action_entries([daemon_reload_entry]);
        }
    }

    impl WidgetImpl for LaunchCreatorPageImp {}

    impl NavigationPageImpl for LaunchCreatorPageImp {}
}