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

use std::fmt::Debug;

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

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

/// A web view.
#[derive(Debug)]
pub struct WebView {
    widget: sys::WebView,
}

impl Failable for WebView {
    type Error = Error;
}

#[inherit_methods(from = "self.widget")]
impl WebView {
    /// The current source URL.
    pub fn source(&self) -> Result<String>;

    /// Set the source URL to a new one.
    pub fn set_source(&mut self, s: impl AsRef<str>) -> Result<()>;

    /// Navigate to a new URL.
    pub fn navigate(&mut self, s: impl AsRef<str>) -> Result<()> {
        self.set_source(s)
    }

    /// Set the HTML content directly.
    pub fn set_html(&mut self, s: impl AsRef<str>) -> Result<()>;

    /// Navigate to HTML content directly.
    pub fn navigate_to_string(&mut self, s: impl AsRef<str>) -> Result<()> {
        self.set_html(s)
    }

    /// Get if can go forward.
    pub fn can_go_forward(&self) -> Result<bool>;

    /// Go forward.
    pub fn go_forward(&mut self) -> Result<()>;

    /// Get if can go back.
    pub fn can_go_back(&self) -> Result<bool>;

    /// Go back.
    pub fn go_back(&mut self) -> Result<()>;

    /// Reload the current page.
    pub fn reload(&mut self) -> Result<()>;

    /// Stop loading the current page.
    pub fn stop(&mut self) -> Result<()>;
}

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

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

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

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

#[inherit_methods(from = "self.widget")]
impl Layoutable for WebView {
    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 [`WebView`].
#[derive(Debug)]
#[non_exhaustive]
pub enum WebViewEvent {
    /// The webview is currently navigating to a new source.
    Navigating,
    /// The webview has been navigated to a new source.
    Navigated,
}

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

impl Component for WebView {
    type Error = Error;
    type Event = WebViewEvent;
    type Init<'a> = BorrowedContainer<'a>;
    type Message = WebViewMessage;

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

    async fn start(&mut self, sender: &ComponentSender<Self>) -> ! {
        let fut_navigated = async {
            loop {
                self.widget.wait_navigated().await;
                sender.output(WebViewEvent::Navigated);
            }
        };
        let fut_navigating = async {
            loop {
                self.widget.wait_navigating().await;
                sender.output(WebViewEvent::Navigating);
            }
        };
        futures_util::future::join(fut_navigated, fut_navigating)
            .await
            .0
    }
}

winio_handle::impl_as_widget!(WebView, widget);