tauri-plugin-snap-layout 1.0.0

Snap Layout feature for Windows 11 frameless functionality.
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
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
152
153
154
155
156
157
158
159
160
161
162

use crate::desktop::Snap;
use serde::{Deserialize, Serialize};
use tauri::{
    plugin::{Builder, TauriPlugin},
    Manager, Runtime,
};

pub(crate) mod snap;

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq)]
pub enum SnapCursor {
    Arrow,
    Hand,
}

#[derive(Clone, Serialize, Deserialize)]
pub struct SnapConfig {
    pub button_id: String,
    pub padding_left: i32,
    pub padding_right: i32,
    pub padding_top: i32,
    pub padding_bottom: i32,
    pub padding_all: i32,
    pub display: bool,
    pub debug_color: String,
    pub cursor: SnapCursor,
}

pub struct AreaBuilder {
    config: SnapConfig,
}

#[tauri::command]
fn fallback_update_snap_bounds(
    _x: i32,
    _y: i32,
    _width: i32,
    _height: i32,
    _padding_left: i32,
    _padding_right: i32,
    _padding_top: i32,
    _padding_buttom: i32,
    _padding_all: i32,
) {
}

impl AreaBuilder {
    pub fn new() -> Self {
        Self {
            config: SnapConfig {
                button_id: "".into(),
                padding_left: 0,
                padding_right: 0,
                padding_top: 0,
                padding_bottom: 0,
                padding_all: 0,
                display: false,
                debug_color: "rgba(196, 42, 28, 0.42)".into(),
                cursor: SnapCursor::Arrow,
            },
        }
    }

    pub fn button_id(mut self, id: impl Into<String>) -> Self {
        self.config.button_id = id.into();
        self
    }

    pub fn padding_left(mut self, padding_left: i32) -> Self {
        self.config.padding_left = padding_left;
        self
    }

    pub fn padding_right(mut self, padding_right: i32) -> Self {
        self.config.padding_right = padding_right;
        self
    }

    pub fn padding_top(mut self, padding_top: i32) -> Self {
        self.config.padding_top = padding_top;
        self
    }

    pub fn padding_bottom(mut self, padding_bottom: i32) -> Self {
        self.config.padding_bottom = padding_bottom;
        self
    }

    pub fn padding_all(mut self, padding_all: i32) -> Self {
        self.config.padding_all = padding_all;
        self
    }

    pub fn display(mut self, is_display: bool) -> Self {
        self.config.display = is_display;
        self
    }

    pub fn debug_color(mut self, color: impl Into<String>) -> Self {
        self.config.debug_color = color.into();
        self
    }

    pub fn cursor(mut self, cursor: SnapCursor) -> Self {
        self.config.cursor = cursor;
        self
    }

    pub fn build<R: Runtime>(self) -> TauriPlugin<R> {
        let version = windows_version::OsVersion::current();
        if version.build < 22000 {
            return Builder::new("snap-layout")
                .invoke_handler(tauri::generate_handler![fallback_update_snap_bounds])
                .build();
        }

        let base_script = include_str!("../dist-js/inline-injection.js");

        let injection_script = base_script
            .replace(
                "__SNAP_BUTTON_ID__",
                &format!("\"{}\"", self.config.button_id),
            )
            .replace("__SNAP_DISPLAY__", &self.config.display.to_string())
            .replace(
                "__SNAP_DEBUG_COLOR__",
                &format!("\"{}\"", self.config.debug_color),
            )
            .replace(
                "__SNAP_PADDING_LEFT__",
                &format!("{}", self.config.padding_left),
            )
            .replace(
                "__SNAP_PADDING_RIGHT__",
                &format!("{}", self.config.padding_right),
            )
            .replace(
                "__SNAP_PADDING_TOP__",
                &format!("{}", self.config.padding_top),
            )
            .replace(
                "__SNAP_PADDING_BOTTOM__",
                &format!("{}", self.config.padding_bottom),
            )
            .replace(
                "__SNAP_PADDING_ALL__",
                &format!("{}", self.config.padding_all),
            );

        let plugin_config = self.config.clone();

        Builder::new("snap-layout")
            .setup(move |app, _| {
                app.manage(Snap::new(app.clone()));
                app.manage(plugin_config);
                Ok(())
            })
            .invoke_handler(tauri::generate_handler![snap::update_snap_bounds])
            .js_init_script(injection_script)
            .build()
    }
}