Struct DynamicUi

pub struct DynamicUi<T: DynamicUiWrapper> {
    ui_list: RefCell<Vec<PluginData<T>>>,
    event_queue: RefCell<VecDeque<Box<dyn FnOnce(&Rc<T>)>>>,
    delay_events: Cell<bool>,
    should_destroy: Cell<bool>,
    event_handlers: RefCell<Vec<EventHandlerData>>,
    prevent_recursive_events: Cell<bool>,
    self_wrapper_ty: PhantomData<T>,
}

Stores many [nwg::PartialUi] type. Usually behind an Rc pointer stored inside DynamicUiRef.

Fields

ui_list: RefCell<Vec<PluginData<T>>>

Can be mutably borrowed when rebuilding. The type id indicates which plugin owns the parent control.

Lock pattern

For write locks:

1. Check if Self::delay_events is set and if so don’t acquire a lock.
2. Create a DelayEventsGuard that sets the Self::delay_events field to true (and then to false when dropped)
3. Acquiring the std::cell::RefMut guard.
4. Don’t call into plugin hooks while holding the guard.

For read locks:

These should be okay everywhere except in functions that use DelayEventsGuard.

event_queue: RefCell<VecDeque<Box<dyn FnOnce(&Rc<T>)>>>

Used to store events that should be handled after rebuilding some plugins.

delay_events: Cell<bool>

Used to delay events while rebuilding. We take mutable references to plugins while rebuilding so this prevents issues where events are handled recursively while building new UI elements.

should_destroy: Cell<bool>

true if the UI should be destroyed.

event_handlers: RefCell<Vec<EventHandlerData>>

Event handlers that are bound to plugin windows.

Raw event handlers can fail to be registered in which case we ignore the error (this only happens if raw event handler was registered previously with the same id for the same window).

prevent_recursive_events: Cell<bool>

Prevent recursive event handling.

self_wrapper_ty: PhantomData<T>

Implementations

impl<T> DynamicUi<T>

where T: DynamicUiWrapper,

pub fn new(ui_list: Vec<Box<T::Hooks>>) -> Self

pub fn set_prevent_recursive_events(&self, value: bool)

pub fn with_paused_events<R>(&self, f: impl FnOnce() -> R) -> R

Run some code while delaying other event handlers.

pub fn get_ui<U: DynamicUiHooks<T>>(&self) -> Option<Ref<'_, U>>

Get a reference to a ui item managed by this dynamic ui.

Warning: the returned ui item might not have been built.

pub fn with_all_ui<R>( &self, f: impl FnOnce(&mut dyn Iterator<Item = &T::Hooks>) -> R, ) -> R

pub fn for_each_ui(&self, f: impl FnMut(&T::Hooks))

pub fn maybe_preform_action<R>( wrapper: &Rc<T>, action: impl FnOnce(&Rc<T>) -> R, ) -> Option<R>

Preforms an action and rebuilds the UI if needed. The action will be skipped if the UI is currently being rebuilt.

pub fn preform_action<R>( wrapper: &Rc<T>, action: impl FnOnce(&Rc<T>, bool) -> R + 'static, ) -> Option<R>

Preforms an action and then rebuilds the UI if needed. The action will be queued if UI is currently being rebuilt.

The action will be called with the wrapper and a bool that is true if the action was delayed.

pub fn preform_action_adv<S>( wrapper: &Rc<T>, state: S, delay_action: impl FnOnce(S) -> Option<Box<dyn FnOnce(&Rc<T>) + 'static>>, preform_action: impl FnOnce(S), )

fn preform_action_and_maybe_rebuild( wrapper: &Rc<T>, action: Option<&mut dyn FnMut(&Rc<T>)>, )

fn initial_build(wrapper: &Rc<T>) -> Result<(), NwgError>

fn all_handles(wrapper: &Rc<T>) -> Vec<(TypeId, bool, ControlHandle)>

fn process_events_for_plugin_and_children( wrapper: &Rc<T>, plugin_id: TypeId, f: impl FnMut(&PluginData<T>), )

fn process_event( wrapper: &Rc<T>, evt: Event, evt_data: &EventData, handle: ControlHandle, window: ControlHandle, plugin_id: TypeId, )

fn process_raw_event( wrapper: &Rc<T>, hwnd: isize, msg: u32, w: usize, l: isize, window: ControlHandle, plugin_id: TypeId, ) -> Option<isize>

fn unbind_specific_event_handlers( wrapper: &Rc<T>, window_handles: &[&ControlHandle], )

fn unbind_event_handlers(wrapper: &Rc<T>)

fn bind_event_handlers(wrapper: &Rc<T>)

fn destroy_ui(wrapper: &Rc<T>)

To make sure that everything is freed without issues, the default handler must be unbound.

Trait Implementations

impl<T> Debug for DynamicUi<T>

where T: DynamicUiWrapper,

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

Formats the value using the given formatter.

impl<T: DynamicUiWrapper> Default for DynamicUi<T>

fn default() -> Self

Returns the “default value” for a type.