winio 0.11.0

Single-threaded async GUI runtime based on compio.
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

use inherit_methods_macro::inherit_methods;
use winio_elm::{Component, ComponentSender};
use winio_handle::BorrowedContainer;
use winio_primitive::{Enable, Failable, Layoutable, Point, Size, TextWidget, Visible};

use crate::{
    sys,
    sys::{Error, Result},
};

/// A tabbed view that contains many [`TabViewItem`]s.
#[derive(Debug)]
pub struct TabView {
    widget: sys::TabView,
}

impl Failable for TabView {
    type Error = Error;
}

#[inherit_methods(from = "self.widget")]
impl TabView {
    /// The selection index.
    pub fn selection(&self) -> Result<Option<usize>>;

    /// Set the selection.
    pub fn set_selection(&mut self, i: usize) -> Result<()>;

    /// Insert a new tab item.
    pub fn insert(&mut self, i: usize, item: &TabViewItem) -> Result<()> {
        self.widget.insert(i, &item.widget)
    }

    /// Push a new tab item to the end.
    pub fn push(&mut self, item: &TabViewItem) -> Result<()> {
        self.insert(self.len()?, item)
    }

    /// Remove a tab by index.
    pub fn remove(&mut self, i: usize) -> Result<()>;

    /// The length of the tabs.
    pub fn len(&self) -> Result<usize>;

    /// If the tab collection is empty.
    pub fn is_empty(&self) -> Result<bool>;

    /// Clear the tabs.
    pub fn clear(&mut self) -> Result<()>;
}

#[inherit_methods(from = "self.widget")]
impl Visible for TabView {
    fn is_visible(&self) -> Result<bool>;

    fn set_visible(&mut self, v: bool) -> Result<()>;
}

#[inherit_methods(from = "self.widget")]
impl Enable for TabView {
    fn is_enabled(&self) -> Result<bool>;

    fn set_enabled(&mut self, v: bool) -> Result<()>;
}

#[inherit_methods(from = "self.widget")]
impl Layoutable for TabView {
    fn loc(&self) -> Result<Point>;

    fn set_loc(&mut self, p: Point) -> Result<()>;

    fn size(&self) -> Result<Size>;

    fn set_size(&mut self, v: Size) -> Result<()>;
}

/// Events of [`TabView`].
#[derive(Debug)]
#[non_exhaustive]
pub enum TabViewEvent {
    /// The selection changed.
    Select,
}

/// Messages of [`TabView`].
#[derive(Debug)]
#[non_exhaustive]
pub enum TabViewMessage {}

impl Component for TabView {
    type Error = Error;
    type Event = TabViewEvent;
    type Init<'a> = BorrowedContainer<'a>;
    type Message = TabViewMessage;

    async fn init(init: Self::Init<'_>, _sender: &ComponentSender<Self>) -> Result<Self> {
        let widget = sys::TabView::new(init)?;
        Ok(Self { widget })
    }

    async fn start(&mut self, sender: &ComponentSender<Self>) -> ! {
        loop {
            self.widget.wait_select().await;
            sender.output(TabViewEvent::Select);
        }
    }
}

winio_handle::impl_as_widget!(TabView, widget);

/// A tab item of [`TabView`].
#[derive(Debug)]
pub struct TabViewItem {
    widget: sys::TabViewItem,
}

impl Failable for TabViewItem {
    type Error = Error;
}

#[inherit_methods(from = "self.widget")]
impl TextWidget for TabViewItem {
    fn text(&self) -> Result<String>;

    fn set_text(&mut self, s: impl AsRef<str>) -> Result<()>;
}

#[inherit_methods(from = "self.widget")]
impl TabViewItem {
    /// Get the available size of the tab.
    pub fn size(&self) -> Result<Size>;
}

/// Events of [`TabViewItem`].
#[derive(Debug)]
#[non_exhaustive]
pub enum TabViewItemEvent {}

/// Messages of [`TabViewItem`].
#[derive(Debug)]
#[non_exhaustive]
pub enum TabViewItemMessage {}

impl Component for TabViewItem {
    type Error = Error;
    type Event = TabViewItemEvent;
    type Init<'a> = ();
    type Message = TabViewItemMessage;

    async fn init(_init: Self::Init<'_>, _sender: &ComponentSender<Self>) -> Result<Self> {
        let widget = sys::TabViewItem::new()?;
        Ok(Self { widget })
    }
}

winio_handle::impl_as_container!(TabViewItem, widget);