Struct Window 

pub struct Window { /* private fields */ }

Available on crate feature winio only.

A simple window.

Implementations

impl Window

pub fn text(&self) -> String

The title.

pub fn set_text(&mut self, s: impl AsRef<str>)

Set the title.

Examples found in repository

examples/test/widgets.rs (line 70)

    fn init(mut init: Self::Init<'_>, sender: &ComponentSender<Self>) -> Self {
        // let mut window = Child::<Window>::init(init);
        let mut window = init.window(sender);
        window.set_text("Widgets example");
        window.set_size(Size::new(800.0, 600.0));
        init! {
            canvas: Canvas = (&window),
            ulabel: Label = (&window) => {
                text: "Username:",
                halign: HAlign::Right,
            },
            plabel: Label = (&window) => {
                text: "Password:",
                halign: HAlign::Right,
            },
            uentry: Edit = (&window) => {
                text: "AAA",
            },
            pentry: Edit = (&window) => {
                text: "123456",
                password: true,
            },
            pcheck: CheckBox = (&window) => {
                text: "Show",
                checked: false,
            },
            combo: ComboBox = (&window),
            list: ObservableVec<String> = (()) => {
                // https://www.zhihu.com/question/23600507/answer/140640887
                items: [
                    "烫烫烫",
                    "昍昍昍",
                    "ﾌﾌﾌﾌﾌﾌ",
                    "쳌쳌쳌"
                ],
            },
            r1: RadioButton = (&window) => {
                text: "屯屯屯",
                checked: true,
            },
            r2: RadioButton = (&window) => {
                text: "锟斤拷",
            },
            r3: RadioButton = (&window) => {
                text: "╠╠╠"
            },
            push_button: Button = (&window) => {
                text: "Push",
            },
            pop_button: Button = (&window) => {
                text: "Pop",
            },
            show_button: Button = (&window) => {
                text: "Show",
            },
            progress: Progress = (&window) => {
                indeterminate: true,
            },
            mltext: TextBox = (&window) => {
            },
        }
        HANDLER.with_app(|a| mltext.set_text(&a.config().s));

        window.show();

        Self {
            window,
            ulabel,
            plabel,
            uentry,
            pentry,
            pcheck,
            canvas,
            combo,
            list,
            index: None,
            r1,
            r2,
            r3,
            rindex: 0,
            push_button,
            pop_button,
            show_button,
            progress,
            mltext,
        }
    }

pub fn client_size(&self) -> Size2D<f64, LogicalSpace>

The inner client size.

Examples found in repository

examples/options/options.rs (line 136)

    fn render(&mut self, _sender: &ComponentSender<Self>) {
        self.window.render();

        let csize = self.window.client_size();

        let m = Margin::new(5., 0., 5., 0.);
        let m_l = Margin::new(0., 5., 0., 0.);

        let mut form = layout! {
            Grid::from_str("auto,1*", "auto,auto").unwrap(),
            self.e_label => { column: 0, row: 0, margin: m_l, valign: VAlign::Center },
            self.e => { column: 1, row: 0, margin: m },
            self.s_label => { column: 0, row: 1, margin: m_l, valign: VAlign::Center },
            self.s => { column: 1, row: 1, margin: m },
        };

        let mut grid = layout! {
            Grid::from_str("auto,1*", "auto,auto,auto,1*").unwrap(),
            self.enabled => { column: 0, row: 0, margin: m },
            self.b => { column: 0, row: 1, margin: m },
            form => { column: 0, row: 2, margin: m },
        };
        grid.set_size(csize);
    }

examples/test/widgets.rs (line 258)

    fn render(&mut self, _sender: &ComponentSender<Self>) {
        let csize = self.window.client_size();
        {
            let mut cred_panel = layout! {
                Grid::from_str("auto,1*,auto", "1*,auto,auto,1*").unwrap(),
                self.ulabel => { column: 0, row: 1, valign: VAlign::Center },
                self.uentry => { column: 1, row: 1, margin: Margin::new_all_same(4.0) },
                self.plabel => { column: 0, row: 2, valign: VAlign::Center },
                self.pentry => { column: 1, row: 2, margin: Margin::new_all_same(4.0) },
                self.pcheck => { column: 2, row: 2 },
            };

            let mut rgroup_panel = layout! {
                Grid::from_str("auto", "1*,auto,auto,auto,1*").unwrap(),
                self.r1 => { row: 1 },
                self.r2 => { row: 2 },
                self.r3 => { row: 3 },
            };

            let mut buttons_panel = layout! {
                StackPanel::new(Orient::Vertical),
                self.push_button => { margin: Margin::new_all_same(4.0) },
                self.pop_button  => { margin: Margin::new_all_same(4.0) },
                self.show_button => { margin: Margin::new_all_same(4.0) },
            };

            let mut root_panel = layout! {
                Grid::from_str("1*,1*,1*", "1*,auto,1*").unwrap(),
                cred_panel    => { column: 1, row: 0 },
                rgroup_panel  => { column: 2, row: 0, halign: HAlign::Center },
                self.canvas   => { column: 0, row: 1, row_span: 2 },
                self.combo    => { column: 1, row: 1, halign: HAlign::Center },
                self.progress => { column: 2, row: 1 },
                self.mltext   => { column: 1, row: 2, margin: Margin::new_all_same(8.0) },
                buttons_panel => { column: 2, row: 2 },
            };

            root_panel.set_size(csize);
        }

        let size = self.canvas.size();
        let is_dark = ColorTheme::current() == ColorTheme::Dark;
        let back_color = if is_dark {
            Color::new(255, 255, 255, 255)
        } else {
            Color::new(0, 0, 0, 255)
        };
        let brush = SolidColorBrush::new(back_color);
        let pen = BrushPen::new(&brush, 1.0);
        let mut ctx = self.canvas.context();
        let cx = size.width / 2.0;
        let cy = size.height / 2.0;
        let r = cx.min(cy) - 2.0;
        ctx.draw_pie(
            &pen,
            Rect::new(Point::new(cx - r, cy - r), Size::new(r * 2.0, r * 2.0)),
            std::f64::consts::PI,
            std::f64::consts::PI * 2.0,
        );

        let brush2 = LinearGradientBrush::new(
            [
                GradientStop::new(Color::new(0x87, 0xCE, 0xEB, 0xFF), 0.0),
                GradientStop::new(back_color, 1.0),
            ],
            RelativePoint::zero(),
            RelativePoint::new(0.0, 1.0),
        );
        let pen2 = BrushPen::new(&brush2, 1.0);
        ctx.draw_round_rect(
            &pen2,
            Rect::new(
                Point::new(cx - r - 1.0, cy - r - 1.0),
                Size::new(r * 2.0 + 2.0, r * 1.618 + 2.0),
            ),
            Size::new(r / 10.0, r / 10.0),
        );
        let mut path = ctx.create_path_builder(Point::new(cx + r + 1.0 - r / 10.0, cy));
        path.add_arc(
            Point::new(cx, cy + r * 0.618 + 1.0),
            Size::new(r + 1.0 - r / 10.0, r * 0.382 / 2.0),
            0.0,
            std::f64::consts::PI,
            true,
        );
        path.add_line(Point::new(cx - r - 1.0 + r / 10.0, cy));
        let path = path.build(false);
        ctx.draw_path(&pen, &path);
        let brush3 = RadialGradientBrush::new(
            [
                GradientStop::new(Color::new(0xF5, 0xF5, 0xF5, 0xFF), 0.0),
                GradientStop::new(
                    Color::accent().unwrap_or(Color::new(0xFF, 0xC0, 0xCB, 0xFF)),
                    1.0,
                ),
            ],
            RelativePoint::new(0.5, 0.5),
            RelativePoint::new(0.2, 0.5),
            RelativeSize::new(0.5, 0.5),
        );
        let font = DrawingFontBuilder::new()
            .family("Arial")
            .size(r / 5.0)
            .halign(HAlign::Center)
            .valign(VAlign::Bottom)
            .build();
        ctx.draw_str(&brush3, font, Point::new(cx, cy), "Hello world!");
    }

pub fn set_icon_by_id(&mut self, id: u16)

Set window icon by resource ID.

pub fn style(&self) -> u32

Get window style.

pub fn set_style(&mut self, s: u32)

Set window style.

pub fn ex_style(&self) -> u32

Get window extended style.

pub fn set_ex_style(&mut self, s: u32)

Set window extended style.

Trait Implementations

impl AsRawWindow for Window

fn as_raw_window(&self) -> RawWindow

Get the raw window handle.

impl AsWindow for Window

fn as_window(&self) -> BorrowedWindow<'_>

Get the window handle.

impl Component for Window

type Event = WindowEvent

The output event type to the parent.

type Init<'a> = MaybeBorrowedWindow<'a>

Initial parameter type.

type Message = ()

The input message type to update.

fn init( init: <Window as Component>::Init<'_>, _sender: &ComponentSender<Window>, ) -> Window

Create the initial component.

async fn start(&mut self, sender: &ComponentSender<Window>) -> !

Start the event listening.

async fn update( &mut self, _message: <Window as Component>::Message, _sender: &ComponentSender<Window>, ) -> bool

Respond to the message.

fn render(&mut self, _sender: &ComponentSender<Window>)

Render the widgets.

impl Debug for Window

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Layoutable for Window

fn loc(&self) -> Point2D<f64, LogicalSpace>

The left top location.

fn set_loc(&mut self, p: Point2D<f64, LogicalSpace>)

Move the location.

fn size(&self) -> Size2D<f64, LogicalSpace>

The size.

fn set_size(&mut self, v: Size2D<f64, LogicalSpace>)

Resize.

fn rect(&self) -> Rect<f64, LogicalSpace>

The bounding rectangle.

fn set_rect(&mut self, r: Rect<f64, LogicalSpace>)

Set the location and size.

fn preferred_size(&self) -> Size2D<f64, LogicalSpace>

The preferred size.

fn min_size(&self) -> Size2D<f64, LogicalSpace>

Min acceptable size.

impl Visible for Window

fn is_visible(&self) -> bool

If the widget is visible.

fn set_visible(&mut self, v: bool)

Set the visibility.

fn show(&mut self)

Show the widget.

fn hide(&mut self)

Hide the widget.