winio-ui-winui 0.3.0

WinUI backend for winio.
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

use inherit_methods_macro::inherit_methods;
use windows::core::Interface;
use winio_handle::{AsContainer, AsRawContainer, RawContainer};
use winio_primitive::{Point, Rect, Size};
use winui3::Microsoft::UI::Xaml::{
    Controls as MUXC, FrameworkElement, HorizontalAlignment, VerticalAlignment,
};

use crate::{Widget, ui::Convertible};

#[derive(Debug)]
pub struct ScrollView {
    handle: Widget,
    view: MUXC::ScrollViewer,
    canvas: MUXC::Canvas,
}

#[inherit_methods(from = "self.handle")]
impl ScrollView {
    pub fn new(parent: impl AsContainer) -> Self {
        let view = MUXC::ScrollViewer::new().unwrap();
        let canvas = MUXC::Canvas::new().unwrap();
        canvas
            .SetHorizontalAlignment(HorizontalAlignment::Left)
            .unwrap();
        canvas.SetVerticalAlignment(VerticalAlignment::Top).unwrap();
        view.SetContent(&canvas).unwrap();
        view.SetHorizontalScrollBarVisibility(MUXC::ScrollBarVisibility::Auto)
            .unwrap();
        view.SetVerticalScrollBarVisibility(MUXC::ScrollBarVisibility::Auto)
            .unwrap();
        Self {
            handle: Widget::new(parent, view.cast().unwrap()),
            view,
            canvas,
        }
    }

    pub fn is_visible(&self) -> bool;

    pub fn set_visible(&mut self, v: bool);

    pub fn is_enabled(&self) -> bool;

    pub fn set_enabled(&mut self, v: bool);

    pub fn loc(&self) -> Point;

    pub fn set_loc(&mut self, p: Point);

    pub fn size(&self) -> Size;

    pub fn set_size(&mut self, v: Size) {
        self.handle.set_size(v);
        let rect = self
            .canvas
            .Children()
            .unwrap()
            .into_iter()
            .map(|c| {
                let c = c.cast::<FrameworkElement>().unwrap();
                let left = MUXC::Canvas::GetLeft(&c).unwrap();
                let top = MUXC::Canvas::GetTop(&c).unwrap();
                let size = Size::from_native(c.DesiredSize().unwrap());
                Rect::new(Point::new(left, top), size)
            })
            .reduce(|a, b| a.union(&b))
            .unwrap_or_default();
        self.canvas.SetWidth(rect.max_x()).unwrap();
        self.canvas.SetHeight(rect.max_y()).unwrap();
    }

    pub fn hscroll(&self) -> bool {
        self.view.HorizontalScrollBarVisibility().unwrap() != MUXC::ScrollBarVisibility::Disabled
    }

    pub fn set_hscroll(&mut self, v: bool) {
        self.view
            .SetHorizontalScrollBarVisibility(if v {
                MUXC::ScrollBarVisibility::Auto
            } else {
                MUXC::ScrollBarVisibility::Disabled
            })
            .unwrap();
    }

    pub fn vscroll(&self) -> bool {
        self.view.VerticalScrollBarVisibility().unwrap() != MUXC::ScrollBarVisibility::Disabled
    }

    pub fn set_vscroll(&mut self, v: bool) {
        self.view
            .SetVerticalScrollBarVisibility(if v {
                MUXC::ScrollBarVisibility::Auto
            } else {
                MUXC::ScrollBarVisibility::Disabled
            })
            .unwrap();
    }

    pub async fn start(&self) -> ! {
        std::future::pending().await
    }
}

winio_handle::impl_as_widget!(ScrollView, handle);

impl AsRawContainer for ScrollView {
    fn as_raw_container(&self) -> RawContainer {
        RawContainer::WinUI(self.canvas.clone())
    }
}

winio_handle::impl_as_container!(ScrollView);