mod button;
#[cfg(feature = "canvas")]
mod canvas;
mod checkbox;
mod column;
mod drag_container;
mod draggable;
mod drop_zone;
#[cfg(feature = "form")]
mod form;
#[cfg(all(feature = "raster", feature = "wgpu"))]
mod gpu_viewport;
mod grid;
#[cfg(feature = "raster")]
mod image;
#[cfg(feature = "router")]
mod link;
#[cfg(feature = "markdown")]
mod markdown;
#[cfg(feature = "router")]
mod outlet;
mod popup;
mod rect;
pub(crate) mod pager;
pub(crate) mod refresh;
#[cfg(feature = "router")]
mod router_component;
mod row;
mod scroll;
mod select;
pub(crate) mod sheet;
mod slider;
mod slot;
mod spacer;
mod stack;
#[cfg(feature = "router")]
pub(crate) mod stack_outlet;
#[cfg(feature = "markdown")]
pub(crate) mod styled_text;
#[cfg(feature = "canvas")]
mod svg;
pub(crate) mod swipe_row;
#[cfg(feature = "router")]
pub(crate) mod tabs;
pub(crate) mod text;
mod text_input;
mod text_input_controller;
mod text_input_tokens;
#[cfg(feature = "raster")]
mod video;
mod virtualized_list;
mod window_chrome;
mod window_controls;
pub(crate) mod zoom;
pub use button::Button;
#[cfg(feature = "canvas")]
pub use canvas::Canvas;
#[allow(deprecated)]
pub use checkbox::Checkbox;
pub use column::Column;
pub use drag_container::{DragBounds, DragContainer, DragContainerProps};
pub use draggable::{DragMovement, DragOverridePolicy, Draggable, DraggableProps, DropMissBehavior};
pub use drop_zone::{DropZone, DropZoneProps};
#[cfg(feature = "form")]
pub(crate) use form::FormContext;
#[cfg(feature = "form")]
pub use form::{
Control, ControlOptions, ControlState, ErrorVisibility, Form, FormCheckboxInput, FormCheckboxInputProps,
FormControlField, FormData, FormErrors, FormField, FormFieldProps, FormHandle, FormOptions, FormPrimaryButton,
FormPrimaryButtonProps, FormProps, FormRangeSliderInput, FormRangeSliderInputProps, FormSecondaryButton,
FormSecondaryButtonProps, FormSliderInput, FormSliderInputProps, FormTextInput, FormTextInputProps, FormValue,
FormValues, ResolvedControl, ValidationResult, validators,
};
#[cfg(all(feature = "raster", feature = "wgpu"))]
pub use gpu_viewport::GpuViewport;
pub use grid::Grid;
#[cfg(feature = "raster")]
#[allow(deprecated)]
pub use image::Image;
#[cfg(feature = "router")]
pub use link::Link;
#[cfg(feature = "markdown")]
pub use markdown::{Markdown, MarkdownLink, MarkdownLinkPresentation, MarkdownList, MarkdownProps, MarkdownRun};
#[cfg(feature = "router")]
pub use outlet::Outlet;
pub use pager::Pager;
pub use popup::{Popover, Popup};
pub use rect::Rect;
#[allow(deprecated)]
pub use refresh::ActivityIndicator;
pub use refresh::{ActivityIndicatorProps, PullToRefresh, PullToRefreshPart, PullToRefreshProps, PullToRefreshStyle};
#[cfg(feature = "router")]
pub use router_component::{Router, RouterProps};
pub use row::Row;
pub use scroll::{ScrollBoth, ScrollHorizontal, ScrollVertical};
pub use select::{Select, SelectOption, SelectTriggerState};
pub use sheet::{
Sheet, SheetDetent, SheetDress, SheetHost, SheetHostPart, SheetHostProps, SheetHostStyle, SheetNode, SheetProps,
SheetStyle,
};
pub use slider::Slider;
pub use slot::Slot;
pub use spacer::Spacer;
pub use stack::Stack;
#[cfg(feature = "router")]
pub use stack_outlet::{
NavigationBar, NavigationBarBuilder, NavigationBarPart, NavigationBarScreen, NavigationBarState, NavigationItem,
NavigationSearch, StackMotion, StackOutlet, StackOutletProps, StackPart,
};
#[cfg(feature = "markdown")]
pub use styled_text::{
InlineObject, LinkClick, MarkPresence, ParagraphKind, ParagraphMarker, ParagraphStyle, ParagraphStyles, RichText,
SelectionStyle, SpanStyle, StyledChange, StyledEdit, StyledSpan, StyledText, TextMark,
};
#[cfg(feature = "canvas")]
pub use svg::Svg;
pub use swipe_row::{SwipeAction, SwipeRow, SwipeRowPart, SwipeRowProps, SwipeRowStyle};
#[cfg(feature = "router")]
pub use tabs::{
TabBar, TabBarBuilder, TabBarPart, TabBarPlace, TabBarState, TabEntry, TabItem, TabOutlet, TabOutletProps, Tabs,
};
pub use text::{OBJECT_CHARACTER, Text, TextOverflow};
pub use text_input::{
ContentKind, InputGhost, InputSquiggles, KeyboardKind, LineGutter, ReturnKey, TextInput, TextInputOverflow,
TextInputOverflowAnchor,
};
pub use text_input_controller::{InputCaretPoint, InputEditError, InputSelection, TextInputController};
pub use text_input_tokens::{InputToken, InputTokenError, InputTokenIcon, InputTokenStyle, InputTokens};
#[cfg(feature = "raster")]
pub use video::Video;
pub use virtualized_list::VirtualizedList;
pub use window_chrome::{
ChromeBorderPolicy, ChromeTitleBar, ResizeHandlePlacement, ResizeHandlePolicy, WindowChrome, WindowChromeMetrics,
WindowChromeMode, WindowChromeProps,
};
pub use window_controls::{
TrafficLightColors, WindowControlColors, WindowControlContent, WindowControlKind, WindowControlStyle, WindowControls,
};
pub use zoom::{ZoomScroll, ZoomScrollProps};
pub use crate::{
app::ctx::{CollisionStrategy, Modal, ModalTarget, OpenState, OutsidePress, Overlay, Parent, Placement, Root},
node::text_highlight::TextHighlight,
};
#[macro_export]
macro_rules! impl_into_node {
($(#[$attribute:meta])* $struct_name:ident) => {
$(#[$attribute])*
pub struct $struct_name {
pub(crate) node: Box<$crate::node::Node>,
}
impl $struct_name {
pub(crate) fn from_node(node: $crate::node::Node) -> Self {
Self {
node: $crate::node::element::boxed_node(node.with_tag_name(Self::tag_name())),
}
}
pub(crate) fn update_node(&mut self, f: impl FnOnce(&mut $crate::node::Node)) {
f(&mut *self.node);
}
pub(crate) fn tag_name() -> std::sync::Arc<str> {
static TAG_NAME: std::sync::OnceLock<std::sync::Arc<str>> = std::sync::OnceLock::new();
TAG_NAME
.get_or_init(|| std::sync::Arc::from(stringify!($struct_name)))
.clone()
}
pub fn node_id(&self) -> $crate::core::NodeId {
self.node.node_id()
}
pub fn key(mut self, key: impl Into<std::sync::Arc<str>>) -> Self {
let key = key.into();
self.update_node(|node| node.set_component_key(Some(&key)));
self
}
pub fn part(mut self, part: &$crate::ui::ResolvedPart) -> Self {
self.update_node(|node| part.apply(node));
self
}
pub fn describe(mut self, name: impl Into<std::sync::Arc<str>>, value: impl Into<std::sync::Arc<str>>) -> Self {
let name = name.into();
let value = value.into();
self.update_node(|node| $crate::node::NodeUpdate::describe(node, name, value));
self
}
pub fn id(mut self, id: impl Into<std::sync::Arc<str>>) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::id(node, id));
self
}
pub fn class(mut self, class: impl Into<std::sync::Arc<str>>) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::class(node, class));
self
}
pub fn classes<C: Into<std::sync::Arc<str>>>(mut self, classes: impl IntoIterator<Item = C>) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::classes(node, classes));
self
}
pub fn background(mut self, color: impl Into<$crate::node::BackgroundColor>) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::background(node, color));
self
}
pub fn background_gradient(mut self, gradient: impl Into<$crate::node::Gradient>) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::background_gradient(node, gradient));
self
}
pub fn foreground(mut self, color: impl Into<$crate::node::TextColor>) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::foreground(node, color));
self
}
pub fn outline(mut self, outline: $crate::node::Outline) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::outline(node, outline));
self
}
pub fn box_shadow(mut self, shadow: impl Into<$crate::node::BoxShadowValue>) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::box_shadow(node, shadow));
self
}
pub fn size(
mut self,
width: impl Into<$crate::node::dimension::Dimension>,
height: impl Into<$crate::node::dimension::Dimension>,
) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::size(node, width, height));
self
}
pub fn width(mut self, width: impl Into<$crate::node::dimension::Dimension>) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::width(node, width));
self
}
pub fn height(mut self, height: impl Into<$crate::node::dimension::Dimension>) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::height(node, height));
self
}
pub fn min_width(mut self, width: impl Into<$crate::node::dimension::Dimension>) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::min_width(node, width));
self
}
pub fn max_width(mut self, width: impl Into<$crate::node::dimension::Dimension>) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::max_width(node, width));
self
}
pub fn min_height(mut self, height: impl Into<$crate::node::dimension::Dimension>) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::min_height(node, height));
self
}
pub fn max_height(mut self, height: impl Into<$crate::node::dimension::Dimension>) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::max_height(node, height));
self
}
pub fn aspect_ratio(mut self, ratio: f32) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::aspect_ratio(node, ratio));
self
}
pub fn min_size(
mut self,
width: impl Into<$crate::node::dimension::Dimension>,
height: impl Into<$crate::node::dimension::Dimension>,
) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::min_size(node, width, height));
self
}
pub fn max_size(
mut self,
width: impl Into<$crate::node::dimension::Dimension>,
height: impl Into<$crate::node::dimension::Dimension>,
) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::max_size(node, width, height));
self
}
pub fn padding_left(mut self, val: impl Into<$crate::node::SpacingValue>) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::padding_left(node, val));
self
}
pub fn padding_right(mut self, val: impl Into<$crate::node::SpacingValue>) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::padding_right(node, val));
self
}
pub fn padding_top(mut self, val: impl Into<$crate::node::SpacingValue>) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::padding_top(node, val));
self
}
pub fn padding_bottom(mut self, val: impl Into<$crate::node::SpacingValue>) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::padding_bottom(node, val));
self
}
pub fn padding_horizontal(mut self, val: impl Into<$crate::node::SpacingValue>) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::padding_horizontal(node, val));
self
}
pub fn padding_vertical(mut self, val: impl Into<$crate::node::SpacingValue>) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::padding_vertical(node, val));
self
}
pub fn padding(mut self, padding: impl Into<$crate::node::padding::Padding>) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::padding(node, padding));
self
}
pub fn padding_custom(mut self, padding: $crate::node::padding::Padding) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::padding_custom(node, padding));
self
}
pub fn frame(mut self, frame: $crate::layout::layout_kind::FrameConstraints) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::frame(node, frame));
self
}
pub fn offset(mut self, x: f32, y: f32) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::offset(node, x, y));
self
}
pub fn offset_by_size(mut self, x: f32, y: f32) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::offset_by_size(node, x, y));
self
}
pub fn relative(mut self, x: f32, y: f32) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::relative(node, x, y));
self
}
pub fn sticky(mut self, sticky: $crate::layout::layout_kind::Sticky) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::sticky(node, sticky));
self
}
pub fn column_tracks(mut self, tracks: &$crate::layout::column_tracks::ColumnTracks) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::column_tracks(node, tracks.clone()));
self
}
pub fn track_span(mut self, span: usize) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::track_span(node, span));
self
}
pub fn measures_column_tracks(mut self, tracks: &$crate::layout::column_tracks::ColumnTracks) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::measures_column_tracks(node, tracks.clone()));
self
}
pub fn absolute(
mut self,
x: f32,
y: f32,
width: impl Into<$crate::node::dimension::Dimension>,
height: impl Into<$crate::node::dimension::Dimension>,
) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::absolute(node, x, y, width, height));
self
}
pub fn absolute_position(mut self, x: f32, y: f32) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::absolute_position(node, x, y));
self
}
pub fn align(mut self, alignment: $crate::layout::Alignment) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::align(node, alignment));
self
}
pub fn flex(mut self, factor: f32) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::flex(node, factor));
self
}
pub fn grid_column(mut self, index: usize) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::grid_cell(node, |cell| cell.set_column(index)));
self
}
pub fn grid_row(mut self, index: usize) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::grid_cell(node, |cell| cell.set_row(index)));
self
}
pub fn column_span(mut self, columns: usize) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::grid_cell(node, |cell| cell.set_column_span(columns)));
self
}
pub fn row_span(mut self, rows: usize) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::grid_cell(node, |cell| cell.set_row_span(rows)));
self
}
pub fn flex_shrink(mut self, factor: f32) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::flex_shrink(node, factor));
self
}
pub fn flex_full(mut self, grow: f32, shrink: f32, basis: Option<f32>) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::flex_full(node, grow, shrink, basis));
self
}
pub fn shrink_order(mut self, order: i32) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::shrink_order(node, order));
self
}
pub fn shrink_limit(mut self, limit: $crate::layout::layout_kind::ShrinkLimit) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::shrink_limit(node, limit));
self
}
pub fn shrink_drop_below(mut self, size: f32) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::shrink_drop_below(node, size));
self
}
pub fn drop_outside(mut self, bounds: $crate::layout::layout_kind::SizeBounds) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::drop_outside(node, bounds));
self
}
pub fn image_anchor(mut self, x: f32, y: f32) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::image_anchor(node, x, y));
self
}
pub fn drop_marker(mut self, marker: bool) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::drop_marker(node, marker));
self
}
pub fn corner_radius(mut self, radius: impl Into<$crate::node::RadiusValue>) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::corner_radius(node, radius));
self
}
pub fn corner_radius_custom(mut self, radius: $crate::node::border::BorderRadius) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::corner_radius_custom(node, radius));
self
}
pub fn corner_radius_top_left(mut self, radius: impl Into<$crate::node::RadiusValue>) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::corner_radius_top_left(node, radius));
self
}
pub fn corner_radius_top_right(mut self, radius: impl Into<$crate::node::RadiusValue>) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::corner_radius_top_right(node, radius));
self
}
pub fn corner_radius_bottom_right(mut self, radius: impl Into<$crate::node::RadiusValue>) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::corner_radius_bottom_right(node, radius));
self
}
pub fn corner_radius_bottom_left(mut self, radius: impl Into<$crate::node::RadiusValue>) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::corner_radius_bottom_left(node, radius));
self
}
pub fn rounded(mut self, radius: impl Into<$crate::node::RadiusValue>) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::rounded(node, radius));
self
}
pub fn border_inside(
mut self,
width: impl Into<$crate::node::BorderSizeValue>,
color: impl Into<$crate::node::BackgroundColor>,
) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::border_inside(node, width, color));
self
}
pub fn border_outside(
mut self,
width: impl Into<$crate::node::BorderSizeValue>,
color: impl Into<$crate::node::BackgroundColor>,
) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::border_outside(node, width, color));
self
}
pub fn border_center(
mut self,
width: impl Into<$crate::node::BorderSizeValue>,
color: impl Into<$crate::node::BackgroundColor>,
) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::border_center(node, width, color));
self
}
pub fn border(mut self, border: $crate::node::border::Border) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::border(node, border));
self
}
pub fn border_custom(mut self, border: $crate::node::border::Borders) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::border_custom(node, border));
self
}
pub fn border_top(mut self, border: $crate::node::border::Border) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::border_top(node, border));
self
}
pub fn border_right(mut self, border: $crate::node::border::Border) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::border_right(node, border));
self
}
pub fn border_bottom(mut self, border: $crate::node::border::Border) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::border_bottom(node, border));
self
}
pub fn border_left(mut self, border: $crate::node::border::Border) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::border_left(node, border));
self
}
#[cfg(feature = "raster")]
pub fn background_image(mut self, data: impl Into<$crate::images::ImageKind>) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::background_image(node, data));
self
}
#[cfg(feature = "raster")]
pub fn background_size(mut self, size: $crate::node::BackgroundSize) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::background_size(node, size));
self
}
#[cfg(feature = "raster")]
pub fn background_cover(mut self) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::background_cover(node));
self
}
#[cfg(feature = "raster")]
pub fn background_contain(mut self) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::background_contain(node));
self
}
pub fn cursor(mut self, cursor: $crate::node::CursorIcon) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::cursor(node, cursor));
self
}
pub fn hovered_style(mut self, style: $crate::node::Style) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::hovered_style(node, style));
self
}
pub fn active_style(mut self, style: $crate::node::Style) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::active_style(node, style));
self
}
pub fn focused_style(mut self, style: $crate::node::Style) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::focused_style(node, style));
self
}
pub fn focus_visible_style(mut self, style: $crate::node::Style) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::focus_visible_style(node, style));
self
}
pub fn drag_over_style(mut self, style: $crate::node::Style) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::drag_over_style(node, style));
self
}
pub fn hovered(mut self, f: impl FnOnce($crate::node::Style) -> $crate::node::Style) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::hovered(node, f));
self
}
pub fn disabled(mut self, disabled: bool) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::disabled(node, disabled));
self
}
pub fn disabled_style(mut self, style: $crate::node::Style) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::disabled_style(node, style));
self
}
pub fn when_disabled(mut self, f: impl FnOnce($crate::node::Style) -> $crate::node::Style) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::when_disabled(node, f));
self
}
pub fn within_style(mut self, style: $crate::node::Style) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::within_style(node, style));
self
}
pub fn within_hovered_style(mut self, style: $crate::node::Style) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::within_hovered_style(node, style));
self
}
pub fn within_pressed_style(mut self, style: $crate::node::Style) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::within_pressed_style(node, style));
self
}
pub fn interaction_group(mut self, group: bool) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::interaction_group(node, group));
self
}
pub fn snap_to_pixels(mut self, snap: bool) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::snap_to_pixels(node, snap));
self
}
pub fn repeat(mut self, repeat: $crate::layout::Repeat) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::repeat(node, Some(repeat)));
self
}
pub fn window_control(mut self, control: $crate::node::WindowControl) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::window_control(node, control));
self
}
pub fn drag_over(mut self, f: impl FnOnce($crate::node::Style) -> $crate::node::Style) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::drag_over(node, f));
self
}
pub fn active(mut self, f: impl FnOnce($crate::node::Style) -> $crate::node::Style) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::active(node, f));
self
}
pub fn focused(mut self, f: impl FnOnce($crate::node::Style) -> $crate::node::Style) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::focused(node, f));
self
}
pub fn focus_visible(mut self, f: impl FnOnce($crate::node::Style) -> $crate::node::Style) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::focus_visible(node, f));
self
}
pub fn on_click(mut self, f: impl $crate::node::IntoMouseEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_click(node, f));
self
}
pub fn off_click(mut self, f: impl $crate::node::IntoMouseEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_click(node, f));
self
}
pub fn on_mouse_click(
mut self,
button: $crate::app::events::MouseButton,
f: impl $crate::node::IntoMouseEventHandler,
) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_mouse_click(node, button, f));
self
}
pub fn off_mouse_click(
mut self,
button: $crate::app::events::MouseButton,
f: impl $crate::node::IntoMouseEventHandler,
) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_mouse_click(node, button, f));
self
}
pub fn on_dblclick(mut self, f: impl $crate::node::IntoMouseEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_dblclick(node, f));
self
}
pub fn off_dblclick(mut self, f: impl $crate::node::IntoMouseEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_dblclick(node, f));
self
}
pub fn on_mouse_down(mut self, f: impl $crate::node::IntoMouseEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_mouse_down(node, f));
self
}
pub fn off_mouse_down(mut self, f: impl $crate::node::IntoMouseEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_mouse_down(node, f));
self
}
pub fn on_mouse_up(mut self, f: impl $crate::node::IntoMouseEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_mouse_up(node, f));
self
}
pub fn off_mouse_up(mut self, f: impl $crate::node::IntoMouseEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_mouse_up(node, f));
self
}
pub fn on_mouse_move(mut self, f: impl $crate::node::IntoMouseEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_mouse_move(node, f));
self
}
pub fn off_mouse_move(mut self, f: impl $crate::node::IntoMouseEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_mouse_move(node, f));
self
}
pub fn start_drag_buttons(mut self, buttons: $crate::app::events::MouseButtonMask) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::start_drag_buttons(node, buttons));
self
}
pub fn finger_drags(mut self, drags: bool) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::finger_drags(node, drags));
self
}
pub fn drag_autoscroll(mut self, enabled: bool) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::drag_autoscroll(node, enabled));
self
}
pub fn on_drag_start(mut self, f: impl $crate::node::IntoDragEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_drag_start(node, f));
self
}
pub fn off_drag_start(mut self, f: impl $crate::node::IntoDragEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_drag_start(node, f));
self
}
pub fn on_drag_move(mut self, f: impl $crate::node::IntoDragEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_drag_move(node, f));
self
}
pub fn off_drag_move(mut self, f: impl $crate::node::IntoDragEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_drag_move(node, f));
self
}
pub fn on_drag_end(mut self, f: impl $crate::node::IntoDragEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_drag_end(node, f));
self
}
pub fn off_drag_end(mut self, f: impl $crate::node::IntoDragEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_drag_end(node, f));
self
}
pub fn on_drop(mut self, f: impl $crate::node::IntoDropEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_drop(node, f));
self
}
pub fn off_drop(mut self, f: impl $crate::node::IntoDropEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_drop(node, f));
self
}
pub fn on_file_drag_enter(mut self, f: impl $crate::node::IntoFileDragEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_file_drag_enter(node, f));
self
}
pub fn off_file_drag_enter(mut self, f: impl $crate::node::IntoFileDragEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_file_drag_enter(node, f));
self
}
pub fn on_file_drag_over(mut self, f: impl $crate::node::IntoFileDragEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_file_drag_over(node, f));
self
}
pub fn off_file_drag_over(mut self, f: impl $crate::node::IntoFileDragEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_file_drag_over(node, f));
self
}
pub fn on_file_drag_leave(mut self, f: impl $crate::node::IntoVoidEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_file_drag_leave(node, f));
self
}
pub fn off_file_drag_leave(mut self, f: impl $crate::node::IntoVoidEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_file_drag_leave(node, f));
self
}
pub fn on_file_drop(mut self, f: impl $crate::node::IntoFileDropEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_file_drop(node, f));
self
}
pub fn off_file_drop(mut self, f: impl $crate::node::IntoFileDropEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_file_drop(node, f));
self
}
pub fn on_paste(mut self, f: impl $crate::node::IntoPasteEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_paste(node, f));
self
}
pub fn off_paste(mut self, f: impl $crate::node::IntoPasteEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_paste(node, f));
self
}
pub fn on_copy(mut self, f: impl $crate::node::IntoCopyEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_copy(node, f));
self
}
pub fn off_copy(mut self, f: impl $crate::node::IntoCopyEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_copy(node, f));
self
}
pub fn on_undo(mut self, f: impl $crate::node::IntoEditEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_undo(node, f));
self
}
pub fn off_undo(mut self, f: impl $crate::node::IntoEditEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_undo(node, f));
self
}
pub fn on_redo(mut self, f: impl $crate::node::IntoEditEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_redo(node, f));
self
}
pub fn off_redo(mut self, f: impl $crate::node::IntoEditEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_redo(node, f));
self
}
pub fn on_select_all(mut self, f: impl $crate::node::IntoEditEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_select_all(node, f));
self
}
pub fn off_select_all(mut self, f: impl $crate::node::IntoEditEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_select_all(node, f));
self
}
pub fn on_history_swipe(mut self, f: impl $crate::node::IntoHistorySwipeEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_history_swipe(node, f));
self
}
pub fn off_history_swipe(mut self, f: impl $crate::node::IntoHistorySwipeEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_history_swipe(node, f));
self
}
pub fn on_history_back(mut self, f: impl $crate::node::IntoHistoryEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_history_back(node, f));
self
}
pub fn off_history_back(mut self, f: impl $crate::node::IntoHistoryEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_history_back(node, f));
self
}
pub fn on_history_forward(mut self, f: impl $crate::node::IntoHistoryEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_history_forward(node, f));
self
}
pub fn off_history_forward(mut self, f: impl $crate::node::IntoHistoryEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_history_forward(node, f));
self
}
pub fn on_touch_start(mut self, f: impl $crate::node::IntoTouchEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_touch_start(node, f));
self
}
pub fn off_touch_start(mut self, f: impl $crate::node::IntoTouchEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_touch_start(node, f));
self
}
pub fn on_touch_move(mut self, f: impl $crate::node::IntoTouchEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_touch_move(node, f));
self
}
pub fn off_touch_move(mut self, f: impl $crate::node::IntoTouchEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_touch_move(node, f));
self
}
pub fn on_touch_end(mut self, f: impl $crate::node::IntoTouchEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_touch_end(node, f));
self
}
pub fn off_touch_end(mut self, f: impl $crate::node::IntoTouchEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_touch_end(node, f));
self
}
pub fn on_touch_cancel(mut self, f: impl $crate::node::IntoTouchEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_touch_cancel(node, f));
self
}
pub fn off_touch_cancel(mut self, f: impl $crate::node::IntoTouchEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_touch_cancel(node, f));
self
}
pub fn on_long_press(mut self, f: impl $crate::node::IntoLongPressEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_long_press(node, f));
self
}
pub fn off_long_press(mut self, f: impl $crate::node::IntoLongPressEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_long_press(node, f));
self
}
pub fn on_pinch(mut self, f: impl $crate::node::IntoPinchEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_pinch(node, f));
self
}
pub fn off_pinch(mut self, f: impl $crate::node::IntoPinchEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_pinch(node, f));
self
}
pub fn on_rotate(mut self, f: impl $crate::node::IntoRotateEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_rotate(node, f));
self
}
pub fn off_rotate(mut self, f: impl $crate::node::IntoRotateEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_rotate(node, f));
self
}
pub fn on_tap(mut self, f: impl $crate::node::IntoTapEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_tap(node, f));
self
}
pub fn off_tap(mut self, f: impl $crate::node::IntoTapEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_tap(node, f));
self
}
pub fn on_double_tap(mut self, f: impl $crate::node::IntoTapEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_double_tap(node, f));
self
}
pub fn off_double_tap(mut self, f: impl $crate::node::IntoTapEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_double_tap(node, f));
self
}
pub fn on_swipe(mut self, f: impl $crate::node::IntoSwipeEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_swipe(node, f));
self
}
pub fn off_swipe(mut self, f: impl $crate::node::IntoSwipeEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_swipe(node, f));
self
}
pub fn on_pan(mut self, f: impl $crate::node::IntoPanEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_pan(node, f));
self
}
pub fn off_pan(mut self, f: impl $crate::node::IntoPanEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_pan(node, f));
self
}
pub fn on_edge_pan(mut self, f: impl $crate::node::IntoEdgePanEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_edge_pan(node, f));
self
}
pub fn off_edge_pan(mut self, f: impl $crate::node::IntoEdgePanEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_edge_pan(node, f));
self
}
pub fn on_mouse_enter(mut self, f: impl $crate::node::IntoVoidEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_mouse_enter(node, f));
self
}
pub fn off_mouse_enter(mut self, f: impl $crate::node::IntoVoidEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_mouse_enter(node, f));
self
}
pub fn on_mouse_leave(mut self, f: impl $crate::node::IntoVoidEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_mouse_leave(node, f));
self
}
pub fn off_mouse_leave(mut self, f: impl $crate::node::IntoVoidEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_mouse_leave(node, f));
self
}
pub fn on_key_down(mut self, f: impl $crate::node::IntoKeyboardEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_key_down(node, f));
self
}
pub fn off_key_down(mut self, f: impl $crate::node::IntoKeyboardEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_key_down(node, f));
self
}
pub fn on_key_up(mut self, f: impl $crate::node::IntoKeyboardEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_key_up(node, f));
self
}
pub fn off_key_up(mut self, f: impl $crate::node::IntoKeyboardEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_key_up(node, f));
self
}
pub fn on_focus(mut self, f: impl $crate::node::IntoVoidEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_focus(node, f));
self
}
pub fn off_focus(mut self, f: impl $crate::node::IntoVoidEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_focus(node, f));
self
}
pub fn on_blur(mut self, f: impl $crate::node::IntoVoidEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_blur(node, f));
self
}
pub fn off_blur(mut self, f: impl $crate::node::IntoVoidEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_blur(node, f));
self
}
pub fn on_scroll(mut self, f: impl $crate::node::IntoScrollEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_scroll(node, f));
self
}
pub fn on_wheel(mut self, f: impl $crate::node::IntoScrollEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_wheel(node, f));
self
}
pub fn off_wheel(mut self, f: impl $crate::node::IntoScrollEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_wheel(node, f));
self
}
pub fn off_scroll(mut self, f: impl $crate::node::IntoScrollEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_scroll(node, f));
self
}
pub fn on_scroll_start(mut self, f: impl $crate::node::IntoScrollEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_scroll_start(node, f));
self
}
pub fn off_scroll_start(mut self, f: impl $crate::node::IntoScrollEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_scroll_start(node, f));
self
}
pub fn on_scroll_end(mut self, f: impl $crate::node::IntoScrollEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_scroll_end(node, f));
self
}
pub fn off_scroll_end(mut self, f: impl $crate::node::IntoScrollEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_scroll_end(node, f));
self
}
pub fn on_scroll_reach_top(mut self, f: impl $crate::node::IntoScrollEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_scroll_reach_top(node, f));
self
}
pub fn off_scroll_reach_top(mut self, f: impl $crate::node::IntoScrollEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_scroll_reach_top(node, f));
self
}
pub fn on_scroll_reach_bottom(mut self, f: impl $crate::node::IntoScrollEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_scroll_reach_bottom(node, f));
self
}
pub fn off_scroll_reach_bottom(mut self, f: impl $crate::node::IntoScrollEventHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_scroll_reach_bottom(node, f));
self
}
pub fn on_page_change(mut self, f: impl $crate::node::IntoPageHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::on_page_change(node, f));
self
}
pub fn off_page_change(mut self, f: impl $crate::node::IntoPageHandler) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::off_page_change(node, f));
self
}
pub fn scrollbar(mut self, style: $crate::layout::scrollbar::ScrollBarStyle) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::scrollbar(node, style));
self
}
pub fn scrollbar_hovered(
mut self,
f: impl Fn($crate::layout::scrollbar::ScrollBarStyle) -> $crate::layout::scrollbar::ScrollBarStyle
+ Send
+ Sync
+ 'static,
) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::scrollbar_hovered(node, f));
self
}
pub fn hit_test(mut self, behavior: $crate::node::HitTestBehavior) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::hit_test(node, behavior));
self
}
pub fn pointer_events_none(mut self) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::pointer_events_none(node));
self
}
pub fn ref_element(mut self, element_ref: impl Into<$crate::core::ElementRef>) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::ref_element(node, element_ref));
self
}
pub fn focuses(mut self, target: &$crate::core::ElementRef) -> Self {
let target = target.clone();
self.update_node(|node| node.events.focuses = Some(target));
self
}
pub fn repeat_press(mut self, repeats: bool) -> Self {
self.update_node(|node| node.events.press_repeats = repeats);
self
}
pub fn tab_stop(mut self, stops: bool) -> Self {
self.update_node(|node| {
if node.events.skips_tab == stops {
node.events.skips_tab = !stops;
}
});
self
}
pub fn focus_on_press(mut self, focuses: bool) -> Self {
self.update_node(|node| {
if node.events.press_keeps_focus == focuses {
node.events.press_keeps_focus = !focuses;
}
});
self
}
pub fn on_press_end(mut self, f: impl Fn() + Send + Sync + 'static) -> Self {
self.update_node(|node| node.events.on_press_end.push($crate::node::VoidEventHandler::new(f)));
self
}
pub fn interactive(mut self, state: $crate::node::interaction_state::InteractionState) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::interactive(node, state));
self
}
pub fn focusable(mut self, focusable: bool) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::focusable(node, focusable));
self
}
pub fn inert(mut self, inert: bool) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::inert(node, inert));
self
}
pub fn captures_keys(mut self, captures: bool) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::captures_keys(node, captures));
self
}
pub fn keys_first(mut self, first: bool) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::keys_first(node, first));
self
}
pub fn tab_index(mut self, tab_index: i32) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::tab_index(node, tab_index));
self
}
pub fn focus_group(mut self, group: $crate::node::FocusGroup) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::focus_group(node, group));
self
}
pub fn focus_entry(mut self, entry: bool) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::focus_entry(node, entry));
self
}
pub fn stops_inside(mut self, stops: bool) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::stops_inside(node, stops));
self
}
pub fn autofocus(mut self, autofocus: bool) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::autofocus(node, autofocus));
self
}
pub fn focus_label(mut self, label: impl Into<std::sync::Arc<str>>) -> Self {
let label = label.into();
self.update_node(|node| $crate::node::NodeUpdate::focus_label(node, label));
self
}
pub fn focus_level(mut self, level: u32) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::focus_level(node, level));
self
}
pub fn focus_expanded(mut self, open: bool, toggle: impl Fn(bool) + Send + Sync + 'static) -> Self {
let toggle: std::sync::Arc<dyn Fn(bool) + Send + Sync> = std::sync::Arc::new(toggle);
self.update_node(|node| $crate::node::NodeUpdate::focus_expanded(node, open, toggle));
self
}
pub fn focus_row(mut self, row: usize) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::focus_row(node, row));
self
}
pub fn focus_column(mut self, column: usize) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::focus_column(node, column));
self
}
pub fn focus_rows(mut self, rows: std::sync::Arc<dyn $crate::node::FocusRows>) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::focus_rows(node, rows));
self
}
#[cfg(feature = "form")]
pub fn name(mut self, name: impl Into<std::sync::Arc<str>>) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::name(node, name));
self
}
pub fn copy_text(mut self, text: &str) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::copy_text(node, Some(std::sync::Arc::from(text))));
self
}
#[cfg(feature = "form")]
pub fn form_value(mut self, value: Option<std::sync::Arc<str>>) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::form_value(node, value));
self
}
pub fn clip(mut self) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::clip(node));
self
}
pub fn overflow_visible(mut self) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::overflow_visible(node));
self
}
pub fn theme(mut self, theme: &$crate::app::theme::Theme) -> Self {
self.update_node(|node| node.set_theme_scope(theme));
self
}
pub fn intrinsic(mut self, width: f32, height: f32) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::intrinsic(node, width, height));
self
}
pub fn opacity(mut self, value: f32) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::opacity(node, value));
self
}
pub fn blur(mut self, radius: f32) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::blur(node, radius));
self
}
pub fn backdrop_blur(mut self, radius: f32) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::backdrop_blur(node, radius));
self
}
pub fn transition(mut self, spec: $crate::animation::Transition) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::transition(node, spec));
self
}
pub fn animation(mut self, spec: $crate::animation::Animation) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::animation(node, spec));
self
}
pub fn presence(mut self) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::presence(node, true));
self
}
pub fn exit_animation(mut self, spec: $crate::animation::Animation) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::exit_animation(node, spec));
self
}
pub fn transform(mut self, t: $crate::node::transform::Transform2D) -> Self {
self.update_node(|node| $crate::node::NodeUpdate::transform(node, t));
self
}
}
impl From<$struct_name> for $crate::node::Element {
fn from(component: $struct_name) -> Self {
$crate::node::Element::from_boxed_node(component.node)
}
}
};
}