Struct WindowView 

pub struct WindowView<State> { /* private fields */ }

A view representing a window.

Implementations

impl<State> WindowView<State>

pub fn with_options( self, f: impl FnOnce(WindowOptions<State>) -> WindowOptions<State>, ) -> Self

Modify window options in-place.

Examples found in repository

examples/transparent_window.rs (lines 45-48)

fn app_logic(state: &mut AppState) -> impl Iterator<Item = WindowView<AppState>> + use<> {
    let base_color = Color::new([0., 0., 0., state.alpha]);

    let root_view = flex_col((
        FlexSpacer::Flex(1.),
        flex_row((
            text_button("-", |state: &mut AppState| {
                state.alpha = (state.alpha - 0.25).max(0.);
            }),
            text_button("+", |state: &mut AppState| {
                state.alpha = (state.alpha + 0.25).min(1.);
            }),
        ))
        .gap(10.px()),
        FlexSpacer::Flex(1.),
    ))
    .padding(20.);

    std::iter::once(
        xilem::window(state.window_id, "Transparency Demo", root_view)
            .with_base_color(base_color)
            .with_options(|o| {
                o.with_transparent(true)
                    .on_close(|state: &mut AppState| state.is_running = false)
            }),
    )
}

examples/multiple_windows.rs (line 69)

fn app_logic(state: &mut State) -> impl Iterator<Item = WindowView<State>> + use<> {
    std::iter::once(
        window(
            state.main_window_id,
            "Multiple windows",
            flex_col((
                label(format!(
                    "{:#?}",
                    state
                        .counters
                        .values()
                        .map(|counter| (&counter.name, counter.value))
                        .collect::<BTreeMap<_, _>>()
                )),
                text_input(
                    state.new_counter_name.clone(),
                    |state: &mut State, new_name| {
                        state.new_counter_name = new_name;
                    },
                ),
                text_button("Add".to_string(), |state: &mut State| {
                    if state
                        .counters
                        .values()
                        .any(|counter| counter.name == state.new_counter_name)
                    {
                        // TODO: show error if name already exists
                        return;
                    }
                    let name = std::mem::take(&mut state.new_counter_name);
                    state
                        .counters
                        .insert(WindowId::next(), Counter { name, value: 0 });
                }),
            )),
        )
        .with_options(|o| o.on_close(|state: &mut State| state.running = false)),
    )
    .chain(
        state
            .counters
            .iter()
            .map(|(window_id, Counter { name, value })| {
                let window_id = *window_id;
                window(
                    window_id,
                    name,
                    flex_col((
                        label(format!("count: {value}")),
                        text_button("+".to_string(), move |state: &mut State| {
                            state.counters.get_mut(&window_id).unwrap().value += 1;
                        }),
                        text_button("-".to_string(), move |state: &mut State| {
                            state.counters.get_mut(&window_id).unwrap().value -= 1;
                        }),
                    )),
                )
                .with_options(|o| {
                    o.on_close(move |state: &mut State| {
                        state.counters.remove(&window_id);
                    })
                })
            }),
    )
    .collect::<Vec<_>>()
    .into_iter()
}

pub fn with_base_color(self, color: Color) -> Self

Set base color of the window.

Examples found in repository

examples/transparent_window.rs (line 44)

fn app_logic(state: &mut AppState) -> impl Iterator<Item = WindowView<AppState>> + use<> {
    let base_color = Color::new([0., 0., 0., state.alpha]);

    let root_view = flex_col((
        FlexSpacer::Flex(1.),
        flex_row((
            text_button("-", |state: &mut AppState| {
                state.alpha = (state.alpha - 0.25).max(0.);
            }),
            text_button("+", |state: &mut AppState| {
                state.alpha = (state.alpha + 0.25).min(1.);
            }),
        ))
        .gap(10.px()),
        FlexSpacer::Flex(1.),
    ))
    .padding(20.);

    std::iter::once(
        xilem::window(state.window_id, "Transparency Demo", root_view)
            .with_base_color(base_color)
            .with_options(|o| {
                o.with_transparent(true)
                    .on_close(|state: &mut AppState| state.is_running = false)
            }),
    )
}

Trait Implementations

impl<State> View<State, (), ViewCtx> for WindowView<State>

where State: 'static,

type Element = PodWindow

The element type which this view operates on.

type ViewState = AnyViewState

State that is used over the lifetime of the retained representation of the view.

fn build( &self, ctx: &mut ViewCtx, app_state: &mut State, ) -> (Self::Element, Self::ViewState)

Create the corresponding Element value.

fn rebuild( &self, prev: &Self, root_widget_view_state: &mut Self::ViewState, ctx: &mut ViewCtx, window: Mut<'_, Self::Element>, app_state: &mut State, )

Update element based on the difference between self and prev.

fn teardown( &self, view_state: &mut Self::ViewState, ctx: &mut ViewCtx, window: Mut<'_, Self::Element>, )

Handle element being removed from the tree.

fn message( &self, view_state: &mut Self::ViewState, message: &mut MessageContext, window: Mut<'_, Self::Element>, app_state: &mut State, ) -> MessageResult<()>

Route message to id_path, if that is still a valid path.

impl<State> ViewMarker for WindowView<State>

where State: 'static,