Struct UiSystem 

pub struct UiSystem<'text, Display, Root, ViewId, Message, const N: usize>
where
    Display: DisplayPort,
    Root: UiView<'text, ViewId, Message, N>,
{ /* private fields */ }

Owns the root view, display, theme, localization, and registration state.

Implementations

impl<'text, Display, Root, ViewId, Message, const N: usize> UiSystem<'text, Display, Root, ViewId, Message, N>

where Display: DisplayPort, Root: UiView<'text, ViewId, Message, N>,

pub fn new( display: Display, root: Root, theme: FsTheme, i18n: I18n<'text>, ) -> Self

Creates a fully configured UI system and runs the root configure pass.

Examples found in repository

examples/uikit_root.rs (lines 208-213)

fn main() {
    let bounds = Rectangle::new(Point::zero(), Size::new(320, 240));
    let mut system = UiSystem::new(
        NullDisplay::new(bounds),
        RootView::new(),
        FsTheme::default(),
        I18n::new("en", "en", &[]),
    );

    let redraw = system.update(16).redraw;
    let _ = system.draw_redraw(redraw);
    let _ = system.handle_touch(TouchEvent::new(Point::new(24, 24), TouchPhase::Start, 1));
    let _ = system.handle_touch(TouchEvent::new(Point::new(24, 24), TouchPhase::End, 2));
    let _ = system.draw();
    let _ = system.registration();
    let _ = ViewRedraw::Full;
}

src/runtime.rs (line 95)

pub fn run_ui_system<'text, Display, Root, ViewId, Message, Driver, Presenter, const N: usize>(
    display: Display,
    root: Root,
    theme: FsTheme,
    i18n: I18n<'text>,
    mut driver: Driver,
    mut presenter: Presenter,
) -> Result<(), UiRuntimeError<Driver::Error, Presenter::Error>>
where
    Display: DisplayPort,
    Root: UiView<'text, ViewId, Message, N>,
    Driver: UiRuntimeDriver,
    Presenter: UiRuntimePresenter<'text, Display, Root, ViewId, Message, N>,
{
    let mut system = UiSystem::new(display, root, theme, i18n);
    let mut pending = presenter.idle_pending();
    let mut last_tick_ms = driver.now_ms();
    let mut last_present_ms = last_tick_ms;

    loop {
        let poll_delay_ms = if driver.needs_active_poll() {
            driver.active_poll_ms()
        } else {
            driver.idle_poll_ms()
        };
        driver.delay_ms(poll_delay_ms);

        let now_ms = driver.now_ms();
        let dt_ms = now_ms.saturating_sub(last_tick_ms).max(1);
        last_tick_ms = now_ms;

        let update_pending = presenter.pending_for_event(system.update(dt_ms));
        pending = presenter.merge_pending(pending, update_pending);

        if let Some(touch) = driver.poll_touch(now_ms).map_err(UiRuntimeError::Driver)? {
            let touch_pending = presenter.pending_for_event(system.handle_touch(touch));
            pending = presenter.merge_pending(pending, touch_pending);
        }

        let since_present_ms = now_ms.saturating_sub(last_present_ms);
        if presenter.should_present(pending, since_present_ms, &system) {
            presenter
                .present(pending, &mut system)
                .map_err(UiRuntimeError::Present)?;
            presenter.did_present(pending, &system);
            pending = presenter.idle_pending();
            last_present_ms = driver.now_ms();
        }
    }
}

pub fn configure_root(&mut self)

Re-runs the root configuration against the current display bounds.

Examples found in repository

src/system.rs (line 39)

    pub fn new(display: Display, root: Root, theme: FsTheme, i18n: I18n<'text>) -> Self {
        let registration = ViewRegistration::new(display.bounds());
        let mut system = Self {
            display,
            root,
            theme,
            i18n,
            registration,
            marker: PhantomData,
        };
        system.configure_root();
        system
    }

pub const fn root(&self) -> &Root

Returns the root view.

pub fn root_mut(&mut self) -> &mut Root

Returns the root view mutably.

pub const fn registration(&self) -> &ViewRegistration<'text, ViewId, N>

Returns the current root registration.

Examples found in repository

examples/uikit_root.rs (line 220)

fn main() {
    let bounds = Rectangle::new(Point::zero(), Size::new(320, 240));
    let mut system = UiSystem::new(
        NullDisplay::new(bounds),
        RootView::new(),
        FsTheme::default(),
        I18n::new("en", "en", &[]),
    );

    let redraw = system.update(16).redraw;
    let _ = system.draw_redraw(redraw);
    let _ = system.handle_touch(TouchEvent::new(Point::new(24, 24), TouchPhase::Start, 1));
    let _ = system.handle_touch(TouchEvent::new(Point::new(24, 24), TouchPhase::End, 2));
    let _ = system.draw();
    let _ = system.registration();
    let _ = ViewRedraw::Full;
}

pub fn registration_mut(&mut self) -> &mut ViewRegistration<'text, ViewId, N>

Returns the current root registration mutably.

pub const fn theme(&self) -> &FsTheme

Returns the active theme.

pub fn theme_mut(&mut self) -> &mut FsTheme

Returns the active theme mutably.

pub const fn i18n(&self) -> &I18n<'text>

Returns the active localization tables.

pub fn i18n_mut(&mut self) -> &mut I18n<'text>

Returns the active localization tables mutably.

pub const fn display(&self) -> &Display

Returns the display port.

pub fn display_mut(&mut self) -> &mut Display

Returns the display port mutably.

pub fn with_display_and_root<R>( &mut self, apply: impl FnOnce(&mut Display, &Root) -> R, ) -> R

Borrows the display mutably and the root immutably for one closure.

pub fn with_display_and_root_mut<R>( &mut self, apply: impl FnOnce(&mut Display, &mut Root) -> R, ) -> R

Borrows the display and root mutably for one closure.

pub fn update(&mut self, dt_ms: u32) -> ViewEvent<Message>

Runs one logical update tick on the root view.

Examples found in repository

examples/uikit_root.rs (line 215)

fn main() {
    let bounds = Rectangle::new(Point::zero(), Size::new(320, 240));
    let mut system = UiSystem::new(
        NullDisplay::new(bounds),
        RootView::new(),
        FsTheme::default(),
        I18n::new("en", "en", &[]),
    );

    let redraw = system.update(16).redraw;
    let _ = system.draw_redraw(redraw);
    let _ = system.handle_touch(TouchEvent::new(Point::new(24, 24), TouchPhase::Start, 1));
    let _ = system.handle_touch(TouchEvent::new(Point::new(24, 24), TouchPhase::End, 2));
    let _ = system.draw();
    let _ = system.registration();
    let _ = ViewRedraw::Full;
}

src/runtime.rs (line 112)

pub fn run_ui_system<'text, Display, Root, ViewId, Message, Driver, Presenter, const N: usize>(
    display: Display,
    root: Root,
    theme: FsTheme,
    i18n: I18n<'text>,
    mut driver: Driver,
    mut presenter: Presenter,
) -> Result<(), UiRuntimeError<Driver::Error, Presenter::Error>>
where
    Display: DisplayPort,
    Root: UiView<'text, ViewId, Message, N>,
    Driver: UiRuntimeDriver,
    Presenter: UiRuntimePresenter<'text, Display, Root, ViewId, Message, N>,
{
    let mut system = UiSystem::new(display, root, theme, i18n);
    let mut pending = presenter.idle_pending();
    let mut last_tick_ms = driver.now_ms();
    let mut last_present_ms = last_tick_ms;

    loop {
        let poll_delay_ms = if driver.needs_active_poll() {
            driver.active_poll_ms()
        } else {
            driver.idle_poll_ms()
        };
        driver.delay_ms(poll_delay_ms);

        let now_ms = driver.now_ms();
        let dt_ms = now_ms.saturating_sub(last_tick_ms).max(1);
        last_tick_ms = now_ms;

        let update_pending = presenter.pending_for_event(system.update(dt_ms));
        pending = presenter.merge_pending(pending, update_pending);

        if let Some(touch) = driver.poll_touch(now_ms).map_err(UiRuntimeError::Driver)? {
            let touch_pending = presenter.pending_for_event(system.handle_touch(touch));
            pending = presenter.merge_pending(pending, touch_pending);
        }

        let since_present_ms = now_ms.saturating_sub(last_present_ms);
        if presenter.should_present(pending, since_present_ms, &system) {
            presenter
                .present(pending, &mut system)
                .map_err(UiRuntimeError::Present)?;
            presenter.did_present(pending, &system);
            pending = presenter.idle_pending();
            last_present_ms = driver.now_ms();
        }
    }
}

pub fn handle_touch(&mut self, touch: TouchEvent) -> ViewEvent<Message>

Routes one touch event into the root view.

Examples found in repository

examples/uikit_root.rs (line 217)

fn main() {
    let bounds = Rectangle::new(Point::zero(), Size::new(320, 240));
    let mut system = UiSystem::new(
        NullDisplay::new(bounds),
        RootView::new(),
        FsTheme::default(),
        I18n::new("en", "en", &[]),
    );

    let redraw = system.update(16).redraw;
    let _ = system.draw_redraw(redraw);
    let _ = system.handle_touch(TouchEvent::new(Point::new(24, 24), TouchPhase::Start, 1));
    let _ = system.handle_touch(TouchEvent::new(Point::new(24, 24), TouchPhase::End, 2));
    let _ = system.draw();
    let _ = system.registration();
    let _ = ViewRedraw::Full;
}

src/runtime.rs (line 116)

pub fn run_ui_system<'text, Display, Root, ViewId, Message, Driver, Presenter, const N: usize>(
    display: Display,
    root: Root,
    theme: FsTheme,
    i18n: I18n<'text>,
    mut driver: Driver,
    mut presenter: Presenter,
) -> Result<(), UiRuntimeError<Driver::Error, Presenter::Error>>
where
    Display: DisplayPort,
    Root: UiView<'text, ViewId, Message, N>,
    Driver: UiRuntimeDriver,
    Presenter: UiRuntimePresenter<'text, Display, Root, ViewId, Message, N>,
{
    let mut system = UiSystem::new(display, root, theme, i18n);
    let mut pending = presenter.idle_pending();
    let mut last_tick_ms = driver.now_ms();
    let mut last_present_ms = last_tick_ms;

    loop {
        let poll_delay_ms = if driver.needs_active_poll() {
            driver.active_poll_ms()
        } else {
            driver.idle_poll_ms()
        };
        driver.delay_ms(poll_delay_ms);

        let now_ms = driver.now_ms();
        let dt_ms = now_ms.saturating_sub(last_tick_ms).max(1);
        last_tick_ms = now_ms;

        let update_pending = presenter.pending_for_event(system.update(dt_ms));
        pending = presenter.merge_pending(pending, update_pending);

        if let Some(touch) = driver.poll_touch(now_ms).map_err(UiRuntimeError::Driver)? {
            let touch_pending = presenter.pending_for_event(system.handle_touch(touch));
            pending = presenter.merge_pending(pending, touch_pending);
        }

        let since_present_ms = now_ms.saturating_sub(last_present_ms);
        if presenter.should_present(pending, since_present_ms, &system) {
            presenter
                .present(pending, &mut system)
                .map_err(UiRuntimeError::Present)?;
            presenter.did_present(pending, &system);
            pending = presenter.idle_pending();
            last_present_ms = driver.now_ms();
        }
    }
}

pub fn draw(&mut self) -> Result<(), Display::Error>

Draws a full frame through the display port.

Examples found in repository

examples/uikit_root.rs (line 219)

fn main() {
    let bounds = Rectangle::new(Point::zero(), Size::new(320, 240));
    let mut system = UiSystem::new(
        NullDisplay::new(bounds),
        RootView::new(),
        FsTheme::default(),
        I18n::new("en", "en", &[]),
    );

    let redraw = system.update(16).redraw;
    let _ = system.draw_redraw(redraw);
    let _ = system.handle_touch(TouchEvent::new(Point::new(24, 24), TouchPhase::Start, 1));
    let _ = system.handle_touch(TouchEvent::new(Point::new(24, 24), TouchPhase::End, 2));
    let _ = system.draw();
    let _ = system.registration();
    let _ = ViewRedraw::Full;
}

src/system.rs (line 150)

    pub fn draw_redraw(&mut self, redraw: ViewRedraw) -> Result<(), Display::Error> {
        match redraw {
            ViewRedraw::None => Ok(()),
            ViewRedraw::Full => self.draw(),
            ViewRedraw::Dirty(area) => {
                let env = ViewEnvironment {
                    theme: &self.theme,
                    i18n: &self.i18n,
                };
                self.display.draw_dirty(area, |canvas| {
                    self.root.draw(canvas, &self.registration, &env);
                })
            }
        }
    }

pub fn draw_redraw(&mut self, redraw: ViewRedraw) -> Result<(), Display::Error>

Draws only what the supplied redraw request requires.

Examples found in repository

examples/runtime_shell.rs (line 120)

    fn present(
        &mut self,
        pending: Self::Pending,
        system: &mut UiSystem<'static, support::NullDisplay, RootView, RootId, (), 1>,
    ) -> Result<(), Self::Error> {
        let _ = system.draw_redraw(pending);
        Ok(())
    }

examples/uikit_root.rs (line 216)

fn main() {
    let bounds = Rectangle::new(Point::zero(), Size::new(320, 240));
    let mut system = UiSystem::new(
        NullDisplay::new(bounds),
        RootView::new(),
        FsTheme::default(),
        I18n::new("en", "en", &[]),
    );

    let redraw = system.update(16).redraw;
    let _ = system.draw_redraw(redraw);
    let _ = system.handle_touch(TouchEvent::new(Point::new(24, 24), TouchPhase::Start, 1));
    let _ = system.handle_touch(TouchEvent::new(Point::new(24, 24), TouchPhase::End, 2));
    let _ = system.draw();
    let _ = system.registration();
    let _ = ViewRedraw::Full;
}