Struct ElementRef 

pub struct ElementRef<T> { /* private fields */ }

Implementations

impl<T> ElementRef<T>

pub fn new() -> ElementRef<T>

Create a new empty ElementRef

pub fn with_dirty_flag(dirty_flag: Arc<AtomicBool>) -> ElementRef<T>

Create an ElementRef with a shared dirty flag

This is used internally to share the same dirty flag across multiple refs, allowing the windowed app to check for changes.

pub fn dirty_flag(&self) -> Arc<AtomicBool>

Get the dirty flag handle (for sharing with other refs)

pub fn take_dirty(&self) -> bool

Check if the element was modified and clear the flag

Returns true if the element was modified since the last check.

pub fn is_dirty(&self) -> bool

Check if the element was modified (without clearing)

pub fn mark_dirty(&self)

Mark the element as dirty (needs rebuild)

pub fn is_bound(&self) -> bool

Check if an element is bound to this reference

pub fn storage(&self) -> Arc<Mutex<Option<T>>>

Get the internal storage handle for shared access

This is used by .bind() implementations to share storage between the bound element wrapper and this ref.

pub fn set(&self, elem: T)

Set the element in storage (used by bind implementations)

pub fn with<F, R>(&self, f: F) -> Option<R>

where F: FnOnce(&T) -> R,

Access the bound element immutably with a callback

Returns Some(result) if an element is bound, None otherwise.

Example

let state = button_ref.with(|btn| *btn.state());

pub fn with_mut<F, R>(&self, f: F) -> Option<R>

where F: FnOnce(&mut T) -> R,

Access the bound element mutably with a callback

Returns Some(result) if an element is bound, None otherwise. This is the primary way to call methods on the bound element.

Example

// Dispatch state changes
button_ref.with_mut(|btn| {
    btn.dispatch_state(ButtonState::Pressed);
});

// Modify element styling
div_ref.with_mut(|div| {
    *div = div.swap().bg(Color::RED).rounded(8.0);
});

Note: This automatically marks the element as dirty after the callback, triggering a UI rebuild.

pub fn get(&self) -> Option<T>

where T: Clone,

Get a clone of the bound element, if any

pub fn replace(&self, new_elem: T) -> Option<T>

Replace the bound element with a new one, returning the old value

Note: This automatically marks the element as dirty, triggering a UI rebuild.

pub fn take(&self) -> Option<T>

Take the bound element out of the reference, leaving None

pub fn borrow(&self) -> ElementRefGuard<'_, T>

Borrow the bound element immutably

Returns a guard that dereferences to &T. Panics if not bound. For fallible access, use with() instead.

Example

let state = button_ref.borrow().state();

Panics

Panics if no element is bound to this reference.

pub fn borrow_mut(&self) -> ElementRefGuardMut<'_, T>

Borrow the bound element mutably

Returns a guard that dereferences to &mut T. Panics if not bound. When the guard is dropped, the element is automatically marked dirty, triggering a UI rebuild.

For fallible access, use with_mut() instead.

Example

// This automatically triggers a rebuild when the guard is dropped
button_ref.borrow_mut().dispatch_state(ButtonState::Hovered);

Panics

Panics if no element is bound to this reference.

pub fn get_layout_bounds(&self) -> Option<ElementBounds>

Get the computed layout bounds for this element

Returns None if layout hasn’t been computed yet or if the element is not part of the layout tree.

Example

if let Some(bounds) = input_ref.get_layout_bounds() {
    println!("Width: {}, Height: {}", bounds.width, bounds.height);
}

pub fn set_layout_bounds(&self, bounds: ElementBounds)

Set the computed layout bounds for this element

This is called internally after layout is computed to store the element’s position and dimensions.

pub fn clear_layout_bounds(&self)

Clear the stored layout bounds

Called when the element is removed from the layout tree or when layout needs to be recomputed.

pub fn layout_bounds_storage(&self) -> Arc<Mutex<Option<ElementBounds>>>

Get the layout bounds storage handle for sharing

This allows other parts of the system to update the layout bounds when layout is computed.

Trait Implementations

impl<T> Clone for ElementRef<T>

fn clone(&self) -> ElementRef<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Default for ElementRef<T>

fn default() -> ElementRef<T>

Returns the “default value” for a type.