pub enum Modifier {
Show 34 variants
Empty,
Padding(f32),
FillMaxWidth,
FillMaxHeight,
Width(f32),
Height(f32),
Size {
width: f32,
height: f32,
},
Background(Paint),
Clickable {
handler_id: u64,
},
PaddingRole(SpaceRole),
PaddingEach {
start: f32,
top: f32,
end: f32,
bottom: f32,
},
Weight(f32),
Shape {
top_start: f32,
top_end: f32,
bottom_end: f32,
bottom_start: f32,
},
ShapeRole(ShapeRole),
Border {
width: f32,
paint: Paint,
},
Elevation(f32),
ObserveSize {
token: u32,
every_dp: bool,
},
Motion(MotionRole),
Material(MaterialRole),
Offset {
x: f32,
y: f32,
},
RequiredSize {
width: f32,
height: f32,
},
BorderEach {
top: f32,
right: f32,
bottom: f32,
left: f32,
top_paint: Paint,
right_paint: Paint,
bottom_paint: Paint,
left_paint: Paint,
},
CornerEach {
top_left: f32,
top_right: f32,
bottom_right: f32,
bottom_left: f32,
},
Shadow {
x: f32,
y: f32,
blur: f32,
spread: f32,
paint: Paint,
},
Clip(bool),
WindowDrag(bool),
Alpha(f32),
Transform {
a: f32,
b: f32,
c: f32,
d: f32,
e: f32,
f: f32,
origin_x: f32,
origin_y: f32,
},
Transform3D {
m: [f32; 16],
origin_x: f32,
origin_y: f32,
backface_hidden: bool,
},
MatchParentSize,
PressFeedback {
scale: f32,
tint_alpha: f32,
},
Semantics {
role: SemanticsRole,
state: u32,
},
CornerCurve {
smoothing: f32,
},
BackgroundBrush {
x: f32,
y: f32,
width: f32,
height: f32,
paint: Paint,
repeat: BackgroundRepeat,
tile_width: f32,
tile_height: f32,
},
}Variants§
Empty
Padding(f32)
FillMaxWidth
FillMaxHeight
Width(f32)
Height(f32)
Size
Background(Paint)
A Paint, not a raw ARGB. Colour has exactly one wire representation.
Clickable
PaddingRole(SpaceRole)
PaddingEach
Weight(f32)
Shape
ShapeRole(ShapeRole)
Border
Elevation(f32)
One dp value. How the shadow is drawn is the design system’s rule: tonal lift plus a shadow, a wide soft shadow, or layered shadow plus a hairline stroke.
ObserveSize
Asks the Renderer to report this node’s measured size, the way it reports the window’s.
The token is the application’s own name for the node. A node id belongs to the Renderer and is never something the Host chose, so a screen that wants to know how wide one of its own containers ended up needs a name it gave itself. The Renderer does not read it.
With every_dp off, a report goes out on the first measurement and then only when
the node’s width or height class changes. With it on, a report also goes out when
the width or height, rounded to the nearest whole dp, changes inside one class, at
most once a frame and carrying the last size. It rides in the second word, which
was always zero before, so a record with it off is the same bytes it always was.
Motion(MotionRole)
Which curve and length this node’s changes run along.
The node says how important the change is, not how long it takes. Appearing, disappearing, a selection moving and a size changing all read this.
Material(MaterialRole)
What this node’s surface is made of.
A role, so that a system which blurs blurs and a system which does not lifts its surface instead. Nothing here claims a particular effect was achieved.
Offset
Where this node sits inside its parent, in dp from the parent’s top left corner.
The position a layout engine on the Host already computed. Left and right are the screen’s, not the reading direction’s: the Host’s coordinates are physical, so a right-to-left page is not mirrored a second time here.
RequiredSize
This node’s size in dp, whatever its parent’s constraints say. The size a layout engine on the Host already computed, which is not open to negotiation.
BorderEach
A border whose four sides each have their own width and paint. A node whose four
sides are the same uses Border.
Fields
CornerEach
A radius in dp for each corner, cut as plain circular arcs. The background, the
border, the shadow and a Clip all follow it. A node with one radius for every
corner uses Shape.
Shadow
One shadow cast by this node’s outline: an offset, a blur radius and a spread in dp,
and its paint, drawn only outside the node as CSS draws box-shadow. Several
shadows are several of these. A modifier list draws in its order, so a later shadow
lies over an earlier one; CSS puts the first of its list on top, so a Host sends
that list last to first.
Clip(bool)
Whether this node’s content is cut to its outline: the CornerEach shape where it
has one, its rectangle otherwise.
WindowDrag(bool)
Marks this node as a window drag region or excludes it from one.
Alpha(f32)
The opacity of this node and everything in it, from 0 to 1, applied once to the whole group rather than to each child.
Transform
Draws this node and everything in it through a 2D affine matrix, the way CSS
transform does, without changing its layout. Pointer input follows the drawn
shape.
The matrix means what CSS matrix(a, b, c, d, e, f) means: a point (x, y) goes to
(a x + c y + e, b x + d y + f), with e and f in dp. The origin is a fraction of
the node’s measured size, (0.5, 0.5) being its centre, so it stays right when the
size is decided on the Renderer’s side. An origin given as a length is folded into
the matrix by the Host, which then sends (0, 0). A matrix with no inverse draws
nothing and takes no input. No value may be NaN or infinite.
Transform3D
Draws this node and everything in it through a 4x4 matrix, the way CSS 3D
transform does, without changing its layout. Pointer input follows the drawn
shape.
m is column-major, in the order of CSS matrix3d(...): element m[4 * column + row]. A point (x, y, z, 1) goes to M * (x, y, z, 1), and the screen position is
the first two results divided by the fourth. Translations are in dp. A perspective
term is already inside the matrix, so the Renderer is never sent one separately. The
origin means what it means for Modifier::Transform and its z is zero.
backface_hidden is CSS backface-visibility: hidden: a node whose back is turned
to the viewer is not drawn and takes no input. A matrix with no inverse draws
nothing. No value may be NaN or infinite.
MatchParentSize
Matches the bounds of a Box parent without contributing to its size.
PressFeedback
Controls the scale and tint of a pressed surface.
Semantics
What this node is to assistive technology: its role, and whether it is checked or
selected. state holds two tri-state fields, SEMANTICS_CHECKED_SHIFT and
SEMANTICS_SELECTED_SHIFT bits up, each 0 for unset, 1 for off and 2 for on. The
accessible name is the AccessibleName property, because a string does not fit in
a modifier’s words. Above those, expanded, disabled and focused are tri-state
fields in the same encoding, SEMANTICS_HIDDEN_BIT leaves the node out of the
accessibility tree, and the two action bits expose a click and a focus action.
CornerCurve
How this node’s rounded corners curve, from 0 to 1. 0 is a plain circular arc; above
it the curve starts further along each side and its curvature changes continuously,
as Figma’s corner smoothing does (0.6 is what iOS looks like). The radius still
comes from Shape, ShapeRole or CornerEach; this changes only the curve, and
a node without a radius is not changed. A value outside 0..=1 is drawn as the nearer
end and NaN as 0, so one bad shape cannot stop the program; see
corner_smoothing.
BackgroundBrush
A brush laid into a rectangle of this node and repeated across it, the way CSS
draws one background-image layer with its background-position,
background-size and background-repeat.
x, y, width and height are the rectangle in dp from the node’s top left
corner, which is one tile: a gradient is measured against it, not against the node.
repeat says which ways the tile repeats and tile_width and tile_height how far
apart the copies are, in dp; a plain CSS repeat sends the rectangle’s own size, and
space or round the step the Host worked out. The layer is cut to the node’s
outline, its corners included. Several layers are several of these, the first
drawn at the bottom, so a Host sends a CSS list last to first. A tile width or
height of zero or less, and any value that is not a finite number, is refused.
Implementations§
Source§impl Modifier
impl Modifier
Sourcepub fn border_sides(widths: [f32; 4], paints: [Paint; 4]) -> Self
pub fn border_sides(widths: [f32; 4], paints: [Paint; 4]) -> Self
A border with a width and a paint for each side, in CSS order: top, right, bottom, left.
Four equal sides are one Border, which is the record every node with an ordinary
border already sends. BorderEach is written only where the sides differ, so a
screen that never mixes them never sends the longer record.
Sourcepub fn corner_radii(radii: [f32; 4]) -> Self
pub fn corner_radii(radii: [f32; 4]) -> Self
A radius for each corner, in CSS order: top left, top right, bottom right, bottom left.
One radius for every corner is one Shape, the record an ordinary rounded node
already sends. CornerEach is written only where the corners differ.