libharuhishot 0.5.0

impl screencopy for wayland
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

use std::{ops::Sub, sync::OnceLock};

use wayland_client::protocol::wl_output::{self, WlOutput};
use wayland_protocols::{
    ext::foreign_toplevel_list::v1::client::ext_foreign_toplevel_handle_v1::ExtForeignToplevelHandleV1,
    xdg::xdg_output::zv1::client::zxdg_output_v1::ZxdgOutputV1,
};

/// Describe the size
#[derive(Debug, Default, Clone, Copy)]
pub struct Size<T = i32>
where
    T: Default,
{
    pub width: T,
    pub height: T,
}

/// Describe the position
#[derive(Debug, Default, Clone, Copy)]
pub struct Position<T = i32>
where
    T: Default,
{
    pub x: T,
    pub y: T,
}

impl<T> Sub for Position<T>
where
    T: Sub<Output = T> + Default,
{
    type Output = Self;
    fn sub(self, rhs: Self) -> Self::Output {
        Self {
            x: self.x - rhs.x,
            y: self.y - rhs.y,
        }
    }
}

#[derive(Debug, Clone, Copy)]
pub struct Region {
    pub position: Position,
    pub size: Size,
}

/// contain the output and their messages
#[derive(Debug, Clone)]
pub struct WlOutputInfo {
    pub(crate) output: WlOutput,
    pub(crate) size: Size,
    pub(crate) logical_size: Size,
    pub(crate) position: Position,
    pub(crate) name: String,
    pub(crate) description: String,
    pub(crate) xdg_output: OnceLock<ZxdgOutputV1>,
    pub(crate) transform: wl_output::Transform,
    pub(crate) scale: i32,
}

impl WlOutputInfo {
    /// The name of the output or maybe the screen?
    pub fn name(&self) -> &str {
        &self.name
    }

    /// get the description
    pub fn description(&self) -> &str {
        &self.description
    }
    /// get the wl_output
    pub fn wl_output(&self) -> &WlOutput {
        &self.output
    }
    pub(crate) fn new(output: WlOutput) -> Self {
        Self {
            output,
            position: Position::default(),
            size: Size::default(),
            logical_size: Size::default(),
            name: "".to_owned(),
            description: "".to_owned(),
            xdg_output: OnceLock::new(),
            transform: wl_output::Transform::Normal,
            scale: 1,
        }
    }
}

#[derive(Debug, Clone)]
pub struct TopLevel {
    pub(crate) handle: ExtForeignToplevelHandleV1,
    pub(crate) title: String,
}

impl TopLevel {
    pub(crate) fn new(handle: ExtForeignToplevelHandleV1) -> Self {
        Self {
            handle,
            title: "".to_string(),
        }
    }

    pub fn title(&self) -> &str {
        &self.title
    }

    pub fn handle(&self) -> &ExtForeignToplevelHandleV1 {
        &self.handle
    }
}