feather-ui 0.4.0

Feather UI library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2025 Fundament Research Institute <https://fundament.institute>

use crate::{DAbsRect, DPoint, DRect, ZERO_DRECT};
use std::rc::Rc;

#[macro_export]
macro_rules! gen_from_to_dyn {
    ($idx:ident) => {
        impl<'a, T: $idx + 'static> From<&'a T> for &'a (dyn $idx + 'static) {
            fn from(value: &'a T) -> Self {
                return value;
            }
        }
    };
}

pub trait Empty {}

impl Empty for () {}
impl RLimits for () {}
impl Margin for () {}
impl Order for () {}
impl crate::layout::fixed::Child for () {}
impl crate::layout::list::Child for () {}

impl<T: Empty> Empty for Rc<T> {}

impl Empty for DRect {}

gen_from_to_dyn!(Empty);

impl crate::layout::Desc for dyn Empty {
    type Props = dyn Empty;
    type Child = dyn Empty;
    type Children = ();

    fn stage<'a>(
        _: &Self::Props,
        mut outer_area: crate::PxRect,
        outer_limits: crate::PxLimits,
        _: &Self::Children,
        id: std::sync::Weak<crate::SourceID>,
        renderable: Option<Rc<dyn crate::render::Renderable>>,
        window: &mut crate::component::window::WindowState,
    ) -> Box<dyn super::Staged + 'a> {
        outer_area = super::nuetralize_unsized(outer_area);
        outer_area = super::limit_area(outer_area, outer_limits);

        Box::new(crate::layout::Concrete::new(
            renderable,
            outer_area,
            crate::rtree::Node::new(
                outer_area.to_untyped(),
                None,
                Default::default(),
                id,
                window,
            ),
            Default::default(),
        ))
    }
}

pub trait Obstacles {
    fn obstacles(&self) -> &[DAbsRect];
}

pub trait ZIndex {
    fn zindex(&self) -> i32 {
        0
    }
}

impl ZIndex for DRect {}

// Padding is used so an element's actual area can be larger than the area it
// draws children inside (like text).
pub trait Padding {
    fn padding(&self) -> &DAbsRect {
        &crate::ZERO_DABSRECT
    }
}

impl Padding for DRect {}

// Relative to parent's area, but only ever used to determine spacing between
// child elements.
pub trait Margin {
    fn margin(&self) -> &DRect {
        &ZERO_DRECT
    }
}

// Relative to child's assigned area (outer area)
pub trait Area {
    fn area(&self) -> &DRect;
}

impl Area for DRect {
    fn area(&self) -> &DRect {
        self
    }
}

gen_from_to_dyn!(Area);

// Relative to child's evaluated area (inner area)
pub trait Anchor {
    fn anchor(&self) -> &DPoint {
        &crate::ZERO_DPOINT
    }
}

impl Anchor for DRect {}

pub trait Limits {
    fn limits(&self) -> &crate::DLimits {
        &crate::DEFAULT_DLIMITS
    }
}

// Relative to parent's area
pub trait RLimits {
    fn rlimits(&self) -> &crate::RelLimits {
        &crate::DEFAULT_RLIMITS
    }
}

pub trait Order {
    fn order(&self) -> i64 {
        0
    }
}

pub trait Direction {
    fn direction(&self) -> crate::RowDirection {
        crate::RowDirection::LeftToRight
    }
}

impl Limits for DRect {}
impl RLimits for DRect {}

pub trait TextEdit {
    fn textedit(&self) -> &crate::text::EditView;
}