relvi 0.1.0

A focused application launcher for Wayland
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
149
150
151

mod launcher;
mod scroll;

use std::cell::OnceCell;
use std::rc::Rc;

use gtk::prelude::*;
use gtk::{
    Application, ApplicationWindow, Box as GtkBox, EventControllerKey, GestureClick, Orientation,
    Overlay, PropagationPhase, gdk, glib,
};
use gtk4_layer_shell::{Edge, KeyboardMode, Layer, LayerShell};

use self::launcher::LauncherView;

const VIEW_WIDTH: i32 = 540;

fn configure_layer_surface(window: &ApplicationWindow) {
    if !gtk4_layer_shell::is_supported() {
        return;
    }

    window.init_layer_shell();
    window.set_namespace(Some("relvi"));
    window.set_layer(Layer::Overlay);
    window.set_keyboard_mode(KeyboardMode::Exclusive);
    window.set_exclusive_zone(0);
    for edge in [Edge::Top, Edge::Bottom, Edge::Left, Edge::Right] {
        window.set_anchor(edge, true);
    }
}

/// The long-lived launcher window and its view host.
pub struct Ui {
    window: ApplicationWindow,
    launcher: Rc<LauncherView>,
}

impl Ui {
    pub fn new(application: &Application) -> Self {
        adw::init().unwrap();

        let window = ApplicationWindow::builder()
            .application(application)
            .decorated(false)
            .default_width(720)
            .default_height(520)
            .build();

        let provider = gtk::CssProvider::new();
        provider.load_from_string(include_str!("../../resources/style.css"));
        gtk::style_context_add_provider_for_display(
            &WidgetExt::display(&window),
            &provider,
            gtk::STYLE_PROVIDER_PRIORITY_APPLICATION,
        );

        window.set_title(Some("Relvi"));
        window.set_hide_on_close(true);
        window.add_css_class("relvi-window");
        configure_layer_surface(&window);

        let launcher = LauncherView::new(&window);

        let keys = EventControllerKey::new();
        keys.set_propagation_phase(PropagationPhase::Capture);
        keys.connect_key_pressed(glib::clone!(
            #[weak]
            window,
            #[weak]
            launcher,
            #[upgrade_or]
            glib::Propagation::Proceed,
            move |_, key, _, modifiers| {
                let modifiers = modifiers
                    & (gdk::ModifierType::CONTROL_MASK
                        | gdk::ModifierType::SHIFT_MASK
                        | gdk::ModifierType::ALT_MASK
                        | gdk::ModifierType::SUPER_MASK);

                if key == gdk::Key::Escape && modifiers.is_empty() {
                    if !launcher.cancel_confirmation() {
                        window.set_visible(false);
                    }

                    return glib::Propagation::Stop;
                }

                glib::Propagation::Proceed
            }
        ));
        window.add_controller(keys);

        // The layer surface covers the whole output, so a click that misses
        // the active view lands on this backdrop and dismisses the launcher.
        let backdrop = GtkBox::new(gtk::Orientation::Vertical, 0);
        backdrop.set_hexpand(true);
        backdrop.set_vexpand(true);

        let dismiss = GestureClick::new();
        dismiss.connect_released(glib::clone!(
            #[weak]
            window,
            move |_, _, _, _| window.set_visible(false)
        ));
        backdrop.add_controller(dismiss);

        let overlay = Overlay::new();
        overlay.set_child(Some(&backdrop));
        overlay.add_overlay(launcher.widget());

        let anchor_height = OnceCell::new();
        overlay.connect_get_child_position(move |overlay, child| {
            let width = VIEW_WIDTH.min(overlay.width());
            let height = child.measure(Orientation::Vertical, width).1;
            let full_height = *anchor_height.get_or_init(|| height);
            let top = ((overlay.height() - full_height) / 2).max(0);

            Some(gdk::Rectangle::new(
                (overlay.width() - width) / 2,
                top,
                width,
                height.min(overlay.height() - top),
            ))
        });

        window.set_child(Some(&overlay));

        // Prepare the native surface and renderer while the daemon is hidden
        WidgetExt::realize(&window);

        Self { window, launcher }
    }

    pub fn clear_history(&self) {
        self.launcher.clear_history();
    }

    pub fn toggle(&self) {
        if self.window.is_visible() {
            self.window.set_visible(false);
        } else {
            self.present();
        }
    }

    pub fn present(&self) {
        self.window.present();
        self.launcher.focus();
    }
}