hyprshell-exec-lib 4.9.5

A modern GTK4-based window switcher and application launcher for Hyprland
Documentation 
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

use anyhow::Context;
use core_lib::Warn;
use hyprland::data::{Client, Monitors, Workspace, Workspaces};
use hyprland::dispatch::{
    Dispatch, DispatchType, WindowIdentifier, WorkspaceIdentifierWithSpecial,
};
use hyprland::prelude::*;
use hyprland::shared::{Address, WorkspaceId};
use tracing::{debug, trace};

pub fn switch_client(address: Address) -> anyhow::Result<()> {
    debug!("execute switch to client: {address}");
    deactivate_special_workspace_if_needed().warn();
    Dispatch::call(DispatchType::FocusWindow(WindowIdentifier::Address(
        address,
    )))?;
    Dispatch::call(DispatchType::BringActiveToTop)?;
    Ok(())
}

pub fn switch_client_by_initial_class(class: &str) -> anyhow::Result<()> {
    debug!("execute switch to client: {class} by initial_class");
    deactivate_special_workspace_if_needed().warn();
    Dispatch::call(DispatchType::FocusWindow(
        WindowIdentifier::ClassRegularExpression(&format!(
            "initialclass:{}",
            class.to_ascii_lowercase()
        )),
    ))?;
    Dispatch::call(DispatchType::BringActiveToTop)?;
    Ok(())
}

pub fn switch_workspace(workspace_id: WorkspaceId) -> anyhow::Result<()> {
    deactivate_special_workspace_if_needed().warn();

    // check if already on workspace (if so, don't switch because it throws an error `Previous workspace doesn't exist`)
    let current_workspace = Workspace::get_active();
    if let Ok(workspace) = current_workspace
        && workspace_id == workspace.id
    {
        trace!("Already on workspace {}", workspace_id);
        return Ok(());
    }

    if workspace_id < 0 {
        switch_special_workspace(workspace_id).with_context(|| {
            format!("Failed to execute switch special workspace with id {workspace_id}")
        })?;
    } else {
        switch_normal_workspace(workspace_id).with_context(|| {
            format!("Failed to execute switch workspace with id {workspace_id}")
        })?;
    }
    Ok(())
}

fn switch_special_workspace(workspace_id: WorkspaceId) -> anyhow::Result<()> {
    let special = Monitors::get()?
        .into_iter()
        .find(|m| m.special_workspace.id == workspace_id);
    if let Some(special) = special {
        trace!("Special workspace already toggled: {special:?}");
        return Ok(());
    }
    let ws = Workspaces::get()?
        .into_iter()
        .find(|w| w.id == workspace_id)
        .context("workspace not found")?;
    Dispatch::call(DispatchType::ToggleSpecialWorkspace(Some(
        ws.name.trim_start_matches("special:").to_string(),
    )))
    .context("failed to execute toggle special workspace")
}

fn switch_normal_workspace(workspace_id: WorkspaceId) -> anyhow::Result<()> {
    debug!("execute switch to workspace {workspace_id}");
    Dispatch::call(DispatchType::Workspace(WorkspaceIdentifierWithSpecial::Id(
        workspace_id,
    )))?;
    Ok(())
}

/// always run when changing client or workspace
///
/// if client on special workspace is opened the workspace is activated
fn deactivate_special_workspace_if_needed() -> anyhow::Result<()> {
    let active_ws = Workspace::get_active()
        .map(|w| w.name)
        .context("active workspace failed")?;
    let active_ws = Client::get_active()
        .context("active client failed")?
        .map_or(active_ws, |a| a.workspace.name);
    trace!("current workspace: {active_ws}");
    if active_ws.starts_with("special:") {
        debug!("current client is on special workspace, deactivating special workspace");
        // current client is on special workspace
        Dispatch::call(DispatchType::ToggleSpecialWorkspace(Some(
            active_ws.trim_start_matches("special:").to_string(),
        )))?;
    }
    Ok(())
}