winio-ui-android 0.2.0-beta.2

Android 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

use winio_handle::{AsToolBarItem, BorrowedMenuContainer, BorrowedToolBarItem};

use crate::{
    Image, Result,
    menu::{LeafItem, LeafKind},
    tool_bar::ToolBar,
    vm_exec,
};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum ItemKind {
    Button,
    CheckBox,
    RadioButton,
}

#[derive(Debug)]
pub(crate) struct ToolBarItem {
    item: LeafItem,
    kind: ItemKind,
}

impl ToolBarItem {
    pub(crate) fn new(parent: &ToolBar, kind: ItemKind) -> Result<Self> {
        vm_exec(|env| {
            let leaf_kind = match kind {
                ItemKind::Button => LeafKind::Plain,
                ItemKind::CheckBox | ItemKind::RadioButton => LeafKind::Check,
            };
            let item = LeafItem::new(
                env,
                unsafe { BorrowedMenuContainer::android(parent.menu()) },
                leaf_kind,
            )?;
            item.set_show_as_action(env)?;
            Ok(Self { item, kind })
        })
    }

    pub(crate) fn is_enabled(&self) -> Result<bool> {
        vm_exec(|env| self.item.is_enabled(env))
    }

    pub(crate) fn set_enabled(&self, enabled: bool) -> Result<()> {
        vm_exec(|env| self.item.set_enabled(env, enabled))
    }

    pub(crate) fn text(&self) -> Result<String> {
        vm_exec(|env| self.item.text(env))
    }

    pub(crate) fn set_text(&self, s: impl AsRef<str>) -> Result<()> {
        vm_exec(|env| self.item.set_text(env, s))
    }

    pub(crate) fn set_icon(&self, icon: Option<&Image>) -> Result<()> {
        vm_exec(|env| self.item.set_icon(env, icon))
    }

    pub(crate) fn is_checked(&self) -> Result<bool> {
        vm_exec(|env| self.item.is_checked(env))
    }

    pub(crate) fn set_checked(&self, checked: bool) -> Result<()> {
        vm_exec(|env| self.item.set_checked(env, checked))
    }

    pub(crate) async fn wait_click(&self) {
        self.item.wait_click().await;
        match self.kind {
            ItemKind::Button => {}
            ItemKind::CheckBox => {
                let _ = vm_exec(|env| self.item.toggle_checked(env));
            }
            ItemKind::RadioButton => {
                // A radio button must stay checked when it is clicked again;
                // the radio group updates the other items afterwards.
                let _ = vm_exec(|env| self.item.set_checked(env, true));
            }
        }
    }
}

impl AsToolBarItem for ToolBarItem {
    fn as_tool_bar_item(&self) -> BorrowedToolBarItem<'_> {
        // SAFETY: the menu item is valid for the lifetime of `self`.
        unsafe { BorrowedToolBarItem::android(self.item.item()) }
    }
}