wlroots 0.4.0

Wayland compositor framework
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

use std::marker::PhantomData;

use libc::{int32_t, uint32_t};
use wlroots_sys::{wlr_xwayland_surface_hints, wlr_xwayland_surface_size_hints};

use xwayland;

/// Hints provided by the XWayland client to aid in compositing.
pub struct Hints<'surface> {
    hints: *mut wlr_xwayland_surface_hints,
    phantom: PhantomData<&'surface xwayland::surface::Surface>
}

/// Hints provided by the XWayland client to aid in compositing specifically
/// for placement.
pub struct SizeHints<'surface> {
    hints: *mut wlr_xwayland_surface_size_hints,
    phantom: PhantomData<&'surface xwayland::surface::Surface>
}

impl<'surface> Hints<'surface> {
    pub(crate) unsafe fn from_ptr(hints: *mut wlr_xwayland_surface_hints) -> Self {
        Hints { hints,
                               phantom: PhantomData }
    }

    pub fn flags(&self) -> uint32_t {
        unsafe { (*self.hints).flags }
    }

    pub fn input(&self) -> uint32_t {
        unsafe { (*self.hints).input }
    }

    pub fn initial_state(&self) -> int32_t {
        unsafe { (*self.hints).initial_state }
    }

    pub unsafe fn icon_pixmap(&self) -> u32 {
        (*self.hints).icon_pixmap
    }

    pub unsafe fn icon_window(&self) -> u32 {
        (*self.hints).icon_window
    }

    /// Get the coordinates of the icon.
    ///
    /// Return format is (x, y).
    pub fn icon_coords(&self) -> (int32_t, int32_t) {
        unsafe { ((*self.hints).icon_x, (*self.hints).icon_y) }
    }

    pub unsafe fn icon_mask(&self) -> u32 {
        (*self.hints).icon_mask
    }

    pub unsafe fn window_group(&self) -> u32 {
        (*self.hints).window_group
    }
}

impl<'surface> SizeHints<'surface> {
    pub(crate) unsafe fn from_ptr(hints: *mut wlr_xwayland_surface_size_hints) -> Self {
        SizeHints { hints,
                                   phantom: PhantomData }
    }

    /// Get the flags associated with the surface size.
    pub fn flags(&self) -> uint32_t {
        unsafe { (*self.hints).flags }
    }

    /// Get the coordinates of the surface.
    ///
    /// Return format is (x, y).
    pub fn coords(&self) -> (int32_t, int32_t) {
        unsafe { ((*self.hints).x, (*self.hints).y) }
    }

    /// Get the dimensions of the surface.
    ///
    /// Return format is (width, height).
    pub fn dimensions(&self) -> (int32_t, int32_t) {
        unsafe { ((*self.hints).width, (*self.hints).height) }
    }

    /// Get the minimal allowed dimensions of the surface.
    ///
    /// Return format is (width, height).
    pub fn min_dimensions(&self) -> (int32_t, int32_t) {
        unsafe { ((*self.hints).min_width, (*self.hints).min_height) }
    }

    /// Get the maximal allowed dimensions of the surface.
    ///
    /// Return format is (width, height).
    pub fn max_dimensions(&self) -> (int32_t, int32_t) {
        unsafe { ((*self.hints).max_width, (*self.hints).max_height) }
    }

    /// TODO What is this
    ///
    /// Return format is (width, height).
    pub fn inc_dimensions(&self) -> (int32_t, int32_t) {
        unsafe { ((*self.hints).width_inc, (*self.hints).height_inc) }
    }

    /// TODO What is this
    ///
    /// Return format is (width, height).
    pub fn base_dimensions(&self) -> (int32_t, int32_t) {
        unsafe { ((*self.hints).base_width, (*self.hints).base_height) }
    }

    pub fn min_aspect_num(&self) -> int32_t {
        unsafe { (*self.hints).min_aspect_num }
    }

    pub fn min_aspect_den(&self) -> int32_t {
        unsafe { (*self.hints).min_aspect_den }
    }

    pub fn max_aspect_num(&self) -> int32_t {
        unsafe { (*self.hints).max_aspect_num }
    }

    pub fn max_aspect_den(&self) -> int32_t {
        unsafe { (*self.hints).max_aspect_den }
    }

    pub fn win_gravity(&self) -> uint32_t {
        unsafe { (*self.hints).win_gravity }
    }
}