Module data_context

Data context service and properties.

The data property can be set on a widget to any type that can be used in variables (VarValue). The DATA service can then be used on the widget or descendant widgets to retrieve the data and to set validation annotations about the data.

The example below demonstrates a simple MVVM implementation using the data context to share the view-model instance with all widgets in the view. The example also uses the data annotations API to show data validation errors.

mod view {
    use crate::view_model::*;
    use zng::{data_context, prelude::*, window::WindowRoot};

    pub fn window() -> WindowRoot {
        Window! {
            // set data context for entire window, using `var` to be read-write.
            data = var(ViewModel::new(crate::model::connect()));

            // bind title from data context.
            title = DATA.req::<ViewModel>().map(|vm| vm.title());
            child = content();
        }
    }

    fn content() -> impl UiNode {
        // `req` panics if context is not set to the same type.
        let vm = DATA.req::<ViewModel>();
        Container! {
            child = TextInput! {
                txt = vm.map_ref_bidi(|vm| vm.new_item(), |vm| vm.new_item_mut());

                // FieldStyle shows data errors.
                style_fn = style_fn!(|_| zng::text_input::FieldStyle!());
                data_context::data_error = vm.map_ref(|vm| vm.new_item_error());
            };
            child_bottom = Button! {
                child = Text!("Submit");
                widget::enabled = vm.map(|vm| !vm.new_item().is_empty());
                on_click = hn!(|_| vm.modify(|vm| vm.to_mut().submit()).unwrap());
            }, 5;
            padding = 5;
        }
    }
}

mod view_model {
    use crate::model::Model;
    use zng::text::*;

    #[derive(Clone, Debug, PartialEq)]
    pub struct ViewModel {
        model: Model,
        new_item: Txt,
        new_item_error: Txt,
    }
    impl ViewModel {
        pub fn new(model: Model) -> Self {
            Self {
                model,
                new_item: Txt::from(""),
                new_item_error: Txt::from(""),
            }
        }

        pub fn title(&self) -> Txt {
            formatx!("App - {} entries", self.model.read().len())
        }

        pub fn new_item(&self) -> &Txt {
            &self.new_item
        }
        pub fn new_item_mut(&mut self) -> &mut Txt {
            self.new_item_error = Txt::from("");
            &mut self.new_item
        }

        pub fn new_item_error(&self) -> &Txt {
            &self.new_item_error
        }

        pub fn submit(&mut self) {
            match self.new_item.parse::<u32>() {
                Ok(item) => {
                    self.model.write().push(item);
                    self.new_item_mut().clear();
                }
                Err(e) => self.new_item_error = e.to_txt(),
            }
        }
    }
}

mod model {
    use zng::{task::parking_lot::RwLock, var::ArcEq};

    pub type Model = ArcEq<RwLock<Vec<u32>>>;

    pub fn connect() -> ArcEq<RwLock<Vec<u32>>> {
        ArcEq::new(RwLock::new(vec![]))
    }
}

Note that vars clone the value when modify is requested, so the view-model should probably use shared references to the model data, overall this cloning has no noticeable impact as it only happens once per user interaction in the worst case.

Full API

See zng_wgt_data for the full API.

Structs

DATA

Data context and validation.

DataNote

Represents an annotation set in a data context.

DataNoteHandle

Handle for a DataNote in a context.

DataNoteLevel

Classifies the kind of information conveyed by a DataNote.

DataNotes

Represents the data notes set in a context.

Traits

DataNoteValue

Represents a DataNote value.

Functions

data

P Data context.

data_error

P Insert a data ERROR note in the context.

data_error_color

P Set the data note ERROR color.

data_info

P Insert a data INFO note in the context.

data_info_color

P Set the data note INFO color.

data_note

P Insert a data note in the context.

data_warn

P Insert a data WARN note in the context.

data_warn_color

P Set the data note WARN color.

extend_data_note_colors

P Extend the data note level colors, the colors extend the parent colors, only entries of the same level are replaced.

get_data_error

P Get all ERROR data notes set on the context.

get_data_error_txt

P Write all ERROR data notes set on the context to a text.

get_data_info

P Get all INFO data notes set on the context.

get_data_info_txt

P Write all INFO data notes set on the context to a text.

get_data_notes

P Get all data notes set on the context.

get_data_notes_top

P Gets all the notes of highest data level set on the context.

get_data_warn

P Get all WARN data notes set on the context.

get_data_warn_txt

P Write all WARN data notes set on the context to a text.

has_data_error

P Gets if any ERROR data notes are set on the context.

has_data_info

P Gets if any INFO data notes are set on the context.

has_data_notes

P Gets if any data notes are set on the context.

has_data_warn

P Gets if any WARN data notes are set on the context.

replace_data_note_colors

P Sets the data note level colors, the parent colors are fully replaced.

with_data_note_color

Node that inserts a data note color in DATA_NOTE_COLORS_VAR.