Struct DomainPoint 

pub struct DomainPoint<T> {
    pub id: Arc<SourceID>,
    /* private fields */
}

Fields

id: Arc<SourceID>

Implementations

impl<T: Prop + 'static> DomainPoint<T>

pub fn new(id: Arc<SourceID>, props: T) -> Self

Examples found in repository

examples/graph-rs.rs (line 75)

    fn call(
        &mut self,
        mut store: Self::Store,
        args: GraphState,
        mut scope: ScopeID<'_>,
    ) -> (Self::Store, im::HashMap<Arc<SourceID>, Option<Window>>) {
        if store.0 != args {
            let mut children: im::Vector<Option<Box<ChildOf<dyn fixed::Prop>>>> = im::Vector::new();
            let domain: Arc<CrossReferenceDomain> = Default::default();

            let mut node_ids: Vec<Arc<SourceID>> = Vec::new();

            for (i, id) in scope.iter(0..args.nodes.len()) {
                let node = args.nodes[i];
                const BASE: sRGB = sRGB::new(0.2, 0.7, 0.4, 1.0);

                let point = DomainPoint::new(id, domain.clone());
                node_ids.push(point.id.clone());

                let circle = Shape::<DRect, { ShapeKind::Circle as u8 }>::new(
                    gen_id!(point.id),
                    FILL_DRECT,
                    0.0,
                    0.0,
                    [0.0, 20.0],
                    if args.selected == Some(i) {
                        sRGB::new(0.7, 1.0, 0.8, 1.0)
                    } else {
                        BASE
                    },
                    BASE,
                    DAbsPoint::zero(),
                );

                let bag = Region::<MinimalArea>::new(
                    gen_id!(point.id),
                    MinimalArea {
                        area: AbsRect::new(
                            node.x - NODE_RADIUS,
                            node.y - NODE_RADIUS,
                            node.x + NODE_RADIUS,
                            node.y + NODE_RADIUS,
                        )
                        .into(),
                    },
                    feather_ui::children![fixed::Prop, point, circle],
                );

                children.push_back(Some(Box::new(bag)));
            }

            for ((a, b), id) in scope.iter(&args.edges) {
                let line = DomainLine::<()> {
                    id,
                    fill: sRGB::white(),
                    domain: domain.clone(),
                    start: node_ids[*a].clone(),
                    end: node_ids[*b].clone(),
                    props: ().into(),
                };

                children.push_back(Some(Box::new(line)));
            }

            let subregion = Region::new(
                gen_id!(scope),
                MinimalArea {
                    area: AbsRect::new(
                        args.offset.x,
                        args.offset.y,
                        args.offset.x + 10000.0,
                        args.offset.y + 10000.0,
                    )
                    .into(),
                },
                children,
            );

            let mousearea: MouseArea<MinimalArea> = MouseArea::new(
                gen_id!(scope),
                MinimalArea { area: FILL_DRECT },
                Some(4.0),
                [
                    Some(Slot(feather_ui::APP_SOURCE_ID.into(), 0)),
                    Some(Slot(feather_ui::APP_SOURCE_ID.into(), 0)),
                    Some(Slot(feather_ui::APP_SOURCE_ID.into(), 0)),
                    None,
                    None,
                    None,
                ],
            );

            let region = Region::new(
                gen_id!(scope),
                MinimalArea { area: FILL_DRECT },
                feather_ui::children![fixed::Prop, subregion, mousearea],
            );

            let window = Window::new(
                gen_id!(scope),
                feather_ui::winit::window::Window::default_attributes()
                    .with_title(env!("CARGO_CRATE_NAME"))
                    .with_resizable(true),
                Box::new(region),
            );

            store.1 = im::HashMap::new();
            store.1.insert(window.id.clone(), Some(window));
            store.0 = args.clone();
        }
        let windows = store.1.clone();
        (store, windows)
    }

Trait Implementations

impl<T> Clone for DomainPoint<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Prop + 'static> Component for DomainPoint<T>

where for<'a> &'a T: Into<&'a (dyn Prop + 'static)>,

type Props = T

fn layout( &self, _: &mut StateManager, _: &Driver, _: &Arc<SourceID>, ) -> Box<dyn Layout<T>>

impl<T> StateMachineChild for DomainPoint<T>

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

fn init( &self, driver: &Weak<Driver>, ) -> Result<Box<dyn StateMachineWrapper>, Error>

fn apply_children( &self, _: &mut dyn FnMut(&dyn StateMachineChild) -> Result<()>, ) -> Result<()>