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

mod catalog;
mod cli;
mod history;
mod store;
mod system;
mod ui;

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

use clap::{CommandFactory, Parser};
use gtk::prelude::*;
use gtk::{Application, gio, glib};

use crate::cli::{Cli, Command};

const APP_ID: &str = "dev.so1ve.Relvi";

fn main() -> glib::ExitCode {
    // handle help, version and completion without launching a full application
    if let Some(Command::Completions { shell }) = Cli::parse().command {
        clap_complete::generate(shell, &mut Cli::command(), "relvi", &mut std::io::stdout());

        return glib::ExitCode::SUCCESS;
    }

    let application = Application::builder()
        .application_id(APP_ID)
        .flags(gio::ApplicationFlags::HANDLES_COMMAND_LINE)
        .build();

    let ui = Rc::new(OnceCell::<ui::Ui>::new());
    let hold = OnceCell::new();

    application.connect_activate(glib::clone!(
        #[weak]
        ui,
        move |application| {
            ui.get_or_init(|| ui::Ui::new(application)).present();
        }
    ));

    application.connect_command_line(glib::clone!(
        #[weak]
        ui,
        #[upgrade_or]
        glib::ExitCode::FAILURE,
        move |application, command_line| {
            let arguments = command_line.arguments();
            let Ok(cli) = Cli::try_parse_from(arguments) else {
                return glib::ExitCode::from(2);
            };

            match cli.command {
                None => application.activate(),
                Some(Command::Toggle) => {
                    ui.get_or_init(|| ui::Ui::new(application)).toggle();
                }
                Some(Command::Daemon) => {
                    ui.get_or_init(|| ui::Ui::new(application));
                    hold.get_or_init(|| application.hold());
                }
                Some(Command::Quit) => application.quit(),
                Some(Command::ClearHistory) => {
                    if let Some(instance) = ui.get() {
                        instance.clear_history();
                    } else {
                        history::History::load().clear();
                    }
                }
                // Completion output belongs to the invoking process.
                Some(Command::Completions { .. }) => return glib::ExitCode::from(2),
            }

            glib::ExitCode::SUCCESS
        }
    ));

    application.run()
}