Struct Ui 

pub struct Ui { /* private fields */ }

Proof that the current thread is set up for glasskit windows.

Create it once, on the thread that shows the windows, and give it to EventLoop::new, ChoicePopup::new, and Dialog::new. Each of them keeps a copy, so the setup stays while any window exists. Ui is not Send: windows must stay on the thread that made them, and the compiler enforces it.

Ui::new does this setup for the process and the thread:

• It makes the process aware of the DPI of each monitor (per-monitor v2), unless the application manifest or an earlier call has set the DPI awareness.
• It starts the Windows Runtime on the thread (single-threaded apartment).
• It loads the standard common controls.
• It creates the dispatcher queue that the popup animations need.

Implementations

impl Ui

pub fn new() -> Result<Self>

Set up the current thread, or get the setup that exists on it.

Examples found in repository

examples/gallery.rs (line 46)

fn main() -> glasskit::Result<()> {
    let kind = std::env::args().nth(1).unwrap_or_default();
    let Some(prompt) = prompt(&kind) else {
        println!("kinds: {}", KINDS.join(", "));
        return Ok(());
    };
    let ui = Ui::new()?;
    let mut first = ChoicePopup::new(&ui, Placement::default())?;
    if kind == "stack" {
        first.show(&Prompt::new("A first question?", ["Yes", "No"]))?;
    }
    let mut popup = ChoicePopup::new(&ui, Placement::default())?;
    println!("{:?}", popup.ask(&prompt)?.response);
    Ok(())
}

examples/quiz.rs (line 22)

fn main() -> glasskit::Result<()> {
    let ui = Ui::new()?;
    let mut events = EventLoop::new(&ui)?;
    let size = Icon::tray_size();
    let icon = Icon::from_argb(size, vec![0xFF2E_86DE; (size * size) as usize])?;
    let mut tray = Tray::new(&events, "Quiz", &icon)?;
    tray.set_menu(&[
        MenuItem::command(Command::AskNow, "Ask now"),
        MenuItem::Separator,
        MenuItem::Quit("Quit".into()),
    ]);
    let mut popup = ChoicePopup::new(&ui, Placement::default())?;
    let mut next = SystemTime::now() + Duration::from_secs(60);
    loop {
        match events.next(Some(next))? {
            Event::Quit => return Ok(()),
            Event::Deadline | Event::Command(Command::AskNow) => {
                next = SystemTime::now() + Duration::from_secs(60);
                if !popup.is_showing() {
                    let prompt = Prompt::new("What is 2 + 2?", ["3", "4", "5"])
                        .marks(|clicked| answer_marks(clicked, 1))
                        .auto_dismiss(Some(Duration::from_secs(30)));
                    popup.show(&prompt)?;
                }
            }
            Event::Popup(id) if id == popup.id() => {
                if let Some(reply) = popup.take_reply() {
                    println!("{:?}", reply.response);
                }
            }
            _ => {}
        }
    }
}

examples/dialog.rs (line 13)

fn main() -> glasskit::Result<()> {
    let ui = Ui::new()?;
    let (width, height) = (420, 186);
    let mut d = Dialog::new(&ui, "Profile", width, height)?;
    let mut rows = Column::new(Bounds::new(0, 0, width, height).inset(16), 10);

    let field = |row: Bounds| row.columns([Size::Fixed(110), Size::Fill(1)], 8);
    let [label, control] = field(rows.next(26));
    d.add_label("Name", label)?;
    let name = d.add_edit(EditStyle::default(), control)?;
    let [label, control] = field(rows.next(26));
    d.add_label("Language", label)?;
    let language = d.add_drop_down(control)?;
    d.set_items(language, &["English", "Cantonese", "Japanese"]);
    d.set_selected(language, Some(0));
    let news = d.add_check("Send me news", rows.next(26))?;

    let [_, save, cancel] = rows
        .next(30)
        .columns([Size::Fill(1), Size::Fixed(96), Size::Fixed(96)], 8);
    let save = d.add_button("Save", save)?;
    let cancel = d.add_button("Cancel", cancel)?;

    d.run(|d, event| match event {
        Event::Clicked(id) if id == save => {
            println!(
                "{} / {:?} / news: {}",
                d.text(name),
                d.selected(language),
                d.checked(news)
            );
            Flow::Close
        }
        Event::Submit => Flow::Continue,
        Event::Clicked(id) if id == cancel => Flow::Close,
        Event::Close => Flow::Close,
        _ => Flow::Continue,
    })?;
    Ok(())
}

examples/kanban.rs (line 24)

fn main() -> glasskit::Result<()> {
    let ui = Ui::new()?;
    let mut events: EventLoop<()> = EventLoop::new(&ui)?;
    let mut window = Window::new(&ui, "Kanban", 820.0, 520.0)?;
    window.set_min_size(560.0, 360.0);

    let mut board = Board::new(&mut window, &["To do", "Doing", "Done"]);
    for (lane, title, body) in CARDS {
        board.add_card(&mut window, lane, CardData::new(title, body));
    }
    let pinned = CardData {
        pinned: true,
        ..CardData::new("Ask for the budget", "")
    };
    board.add_card(&mut window, 1, pinned);

    let title = window.add(Text::new("Board").style(TextStyle::Title));
    let gap = window.add(Spacer::fill());
    let archived = window.add(Button::new("Show archived"));
    let top = window.add(Row::new().child(title).child(gap).child(archived));
    let root = window.add(
        Column::new()
            .padding(Insets::all(16.0))
            .gap(12.0)
            .child(top)
            .child(board.widget()),
    );
    window.set_root(root);
    window.show();

    loop {
        match events.next(None)? {
            Event::Window(id) if id == window.id() => {
                while let Some(event) = window.next_event() {
                    match event {
                        WindowEvent::CloseRequested => return Ok(()),
                        WindowEvent::Clicked(id) if id == archived => {
                            let show = !board.show_archived();
                            board.set_show_archived(&mut window, show);
                            let label = if show {
                                "Hide archived"
                            } else {
                                "Show archived"
                            };
                            window.set_text(archived, label);
                        }
                        event => {
                            if let Some(change) = board.handle(&ui, &mut window, &event)? {
                                println!("{}", describe(&board, &change));
                            }
                        }
                    }
                }
            }
            Event::Quit => return Ok(()),
            _ => {}
        }
    }
}

examples/sidebar.rs (line 23)

fn main() -> glasskit::Result<()> {
    let ui = Ui::new()?;
    let mut events: EventLoop<()> = EventLoop::new(&ui)?;
    let mut window = Window::new(&ui, "Side bar", 560.0, 360.0)?;
    window.set_min_size(360.0, 260.0);

    let items = PAGES.map(|(name, icon)| window.add(NavItem::new(name).icon(icon)));
    let pages = PAGES.map(|(name, _)| {
        let title = window.add(Text::new(name).style(TextStyle::Title));
        window.add(Column::new().padding(Insets::all(16.0)).child(title))
    });
    let gap = window.add(Spacer::fill());
    let mode = match std::env::args().nth(1).as_deref() {
        Some("icons") => SideMode::Icons,
        Some("collapsed") => SideMode::Collapsed,
        _ => SideMode::Expanded,
    };
    let side = window.add(
        SideBar::new()
            .title("glasskit")
            .expanded_width(180.0)
            .mode(mode)
            .gap(4.0)
            .child(items[0])
            .child(items[1])
            .child(gap)
            .child(items[2]),
    );
    let stack = window.add(Stack::new().width(Length::Fill(1.0)).children(pages));
    let root = window.add(
        Row::new()
            .padding(Insets::all(8.0))
            .gap(8.0)
            .align(Align::Stretch)
            .child(side)
            .child(stack),
    );
    window.set_root(root);
    let show = |window: &mut Window, shown: usize| {
        for (i, (item, page)) in items.into_iter().zip(pages).enumerate() {
            window.set_selected(item, i == shown);
            window.set_visible(page, i == shown);
        }
    };
    show(&mut window, 0);
    window.show();

    loop {
        match events.next(None)? {
            Event::Window(id) if id == window.id() => {
                while let Some(event) = window.next_event() {
                    match event {
                        WindowEvent::Clicked(id) => {
                            if let Some(shown) = items.iter().position(|&item| id == item) {
                                show(&mut window, shown);
                            }
                        }
                        WindowEvent::SideModeChanged(id) if id == side => {
                            println!("{:?}", window.side_mode(side));
                        }
                        WindowEvent::CloseRequested => return Ok(()),
                        _ => {}
                    }
                }
            }
            Event::Quit => return Ok(()),
            _ => {}
        }
    }
}

examples/window.rs (line 16)

fn main() -> glasskit::Result<()> {
    let ui = Ui::new()?;
    let mut events: EventLoop<()> = EventLoop::new(&ui)?;
    let mut window = Window::new(&ui, "glasskit", 420.0, 330.0)?;
    window.set_min_size(320.0, 290.0);
    match std::env::args().nth(1).as_deref() {
        Some("glass") => window.set_material(Material::Glass),
        Some("solid") => window.set_material(Material::Solid),
        _ => {}
    }

    let title = window.add(Text::new("Settings").style(TextStyle::Title));
    let note = window.add(Text::new(
        "Widgets lay out in rows and columns, and the window follows the display scale.",
    ));
    let count = window.add(Text::new("Count: 0").style(TextStyle::BodyStrong));
    let add = window.add(Button::new("Add one"));
    let counter = window.add(Row::new().gap(12.0).child(count).child(add));
    let card = window.add(Card::new().child(counter));
    let name = window.add(TextBox::new().placeholder("Your name").max_length(40));
    let spacer = window.add(Spacer::fill());
    let cancel = window.add(Button::new("Cancel"));
    let ok = window.add(Button::new("OK").accent());
    let buttons = window.add(Row::new().gap(8.0).child(spacer).child(cancel).child(ok));
    let gap = window.add(Spacer::fill());
    let root = window.add(
        Column::new()
            .padding(Insets::all(24.0))
            .gap(12.0)
            .child(title)
            .child(note)
            .child(card)
            .child(name)
            .child(gap)
            .child(buttons),
    );
    window.set_root(root);
    window.show();

    let mut n = 0;
    loop {
        match events.next(None)? {
            Event::Window(id) if id == window.id() => {
                while let Some(event) = window.next_event() {
                    match event {
                        WindowEvent::Clicked(b) if b == add => {
                            n += 1;
                            window.set_text(count, &format!("Count: {n}"));
                            println!("count {n}");
                        }
                        WindowEvent::Clicked(b) if b == ok => {
                            println!("ok {}", window.text(name));
                            return Ok(());
                        }
                        WindowEvent::Submitted(b) if b == name => {
                            println!("ok {}", window.text(name));
                            return Ok(());
                        }
                        WindowEvent::Clicked(b) if b == cancel => return Ok(()),
                        WindowEvent::Key(k) if k.is_plain(Key::ESCAPE) => {
                            println!("escape");
                            return Ok(());
                        }
                        WindowEvent::CloseRequested => return Ok(()),
                        _ => {}
                    }
                }
            }
            Event::Quit => return Ok(()),
            _ => {}
        }
    }
}

Trait Implementations

impl Clone for Ui

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.