Struct ScopeID 

pub struct ScopeID<'a> { /* private fields */ }

Represents a scope with a particular ID assigned to it. Used to generate new IDs for anything created inside this scope, with this scope’s ID as parents, or to generate a new ScopeID with this scope as its parent. Includes ScopeID::iter and ScopeID::cond to make it easier to generate stable IDs across control flow boundaries. It can be used in conjunction with gen_id to generate child IDs with source and line numbers.

Examples

use feather_ui::layout::fixed;
use feather_ui::component::{shape, region::Region};
use feather_ui::{ScopeID, gen_id, DRect, DAbsPoint, color::sRGB, FILL_DRECT, children };

fn foobar(mut id: ScopeID<'_>) {

let rect = shape::round_rect::<DRect>(
    gen_id!(id),
    FILL_DRECT,
    0.0,
    0.0,
    wide::f32x4::splat(10.0),
    sRGB::new(0.2, 0.7, 0.4, 1.0),
    sRGB::transparent(),
    DAbsPoint::zero(),
);

let region = Region::<DRect>::new(
    id.create(),
    FILL_DRECT,
    children![fixed::Prop, rect],
);
}

Implementations

impl<'a> ScopeID<'a>

pub fn id(&mut self) -> &Arc<SourceID>

Gets the underlying ID for this scope. This is sometimes useful when creating custom scopes that belong to a specific component.

pub fn create(&mut self) -> Arc<SourceID>

Creates a new unique SourceID using an internal counter with this scope as it’s parent.

Examples

use feather_ui::component::shape;
use feather_ui::{ScopeID, DRect, DAbsPoint, color::sRGB, FILL_DRECT };

fn foobar(mut id: ScopeID<'_>) {
let rect = shape::round_rect::<DRect>(
    id.create(),
    FILL_DRECT,
    0.0,
    0.0,
    wide::f32x4::splat(10.0),
    sRGB::new(0.2, 0.7, 0.4, 1.0),
    sRGB::transparent(),
    DAbsPoint::zero(),
);
}

pub fn scope(&mut self) -> ScopeID<'_>

Creates a new scoped ID with this scope as it’s parent that can then be passed into a function.

pub fn child(&mut self, id: DataID) -> Arc<SourceID>

Creates a new unique SourceID using the provided DataID, which bypasses the internal counter. This can be used to either manually create a new SourceID from a custom DataID by the user, or by calling gen_id, which calls this function internally.

pub fn iter<U: IntoIterator>( &mut self, other: U, ) -> ScopeIterID<'_, U::IntoIter>

Wraps another iterator and returns a pair of both a unique ID and the result of the iterator. Required for outline functions that use a for loop when iterating through data.

Examples

use feather_ui::component::shape;
use feather_ui::{ScopeID, DRect, DAbsPoint, color::sRGB, FILL_DRECT };

fn foobar(count: usize, mut scope: ScopeID<'_>) {
for (i, id) in scope.iter(0..count) {
    let _ = shape::round_rect::<DRect>(
        id,
        FILL_DRECT,
        i as f32,
        0.0,
        wide::f32x4::splat(4.0),
        sRGB::transparent(),
        sRGB::transparent(),
        DAbsPoint::zero(),
    );
}
}

pub fn cond<R>( &mut self, condition: bool, tvalue: impl FnOnce(ScopeID<'_>) -> R, fvalue: impl FnOnce(ScopeID<'_>) -> R, ) -> R

Wraps the true and false branches of a condition, ensuring the IDs for both are maintained separately regardless of which branch is picked.

Examples

use feather_ui::component::{shape, ComponentWrap, text::Text};
use feather_ui::{ScopeID, DRect, DAbsPoint, color::sRGB, FILL_DRECT };
fn foobar(cond: bool, mut scope: ScopeID<'_>) {
let _ = scope.cond::<Box<dyn ComponentWrap<dyn feather_ui::layout::base::Empty>>>(
    cond,
    |mut id: ScopeID<'_>| Box::new(shape::round_rect::<DRect>(
        id.create(),
        FILL_DRECT,
        0.0,
        0.0,
        wide::f32x4::splat(4.0),
        sRGB::transparent(),
        sRGB::transparent(),
        DAbsPoint::zero(),
    )),
    |mut id: ScopeID<'_>| {
        Box::new(Text::<DRect> {
            id: id.create(),
            props: FILL_DRECT.into(),
            text: "Foobar".to_string(),
            font_size: 40.0,
            line_height: 56.0,
            ..Default::default()
        })
    });
}

Trait Implementations

impl<AppData: Clone + FromLua + IntoLua> FnPersist2<&AppData, ScopeID<'static>, HashMap<Arc<SourceID>, Option<Window>>> for LuaPersist<AppData>

fn init(&self) -> Self::Store

fn call( &mut self, _: Self::Store, appdata: &AppData, id: ScopeID<'static>, ) -> (Self::Store, HashMap<Arc<SourceID>, Option<Window>>)