cranpose_ui/modifier/
slices.rs

1use std::{fmt, mem::size_of, rc::Rc};
2
3use cranpose_foundation::{ModifierNodeChain, NodeCapabilities, PointerEvent};
4use cranpose_ui_graphics::{
5    ColorFilter, EdgeInsets, GraphicsLayer, LayerShape, PointerIcon, RenderEffect,
6    RoundedCornerShape,
7};
8
9use super::{ModifierChainHandle, Point};
10use crate::{
11    draw::DrawCommand,
12    modifier::{
13        Modifier,
14        scroll::{MotionContextAnimatedNode, TranslatedContentContextNode},
15    },
16    modifier_nodes::{
17        BackgroundNode, ClipToBoundsNode, CornerShapeNode, DrawCommandNode, GraphicsLayerNode,
18        PaddingNode, PointerIconNode, WindowRectReporterNode,
19    },
20    text::{TextLayoutOptions, TextStyle},
21    text_field_modifier_node::{TextFieldModifierNode, TextPanResolver},
22    text_modifier_node::{TextModifierNode, TextPreparedLayoutHandle},
23};
24
25/// Snapshot of modifier node slices that impact draw and pointer subsystems.
26#[derive(Default)]
27pub struct ModifierNodeSlices {
28    draw_commands: Vec<DrawCommand>,
29    layer_draw_boundary: Option<usize>,
30    pointer_inputs: Vec<Rc<dyn Fn(PointerEvent)>>,
31    pointer_input_sizes: Vec<Rc<std::cell::Cell<cranpose_ui_graphics::Size>>>,
32    click_handlers: Vec<Rc<dyn Fn(Point)>>,
33    pointer_icon: Option<PointerIcon>,
34    clip_to_bounds: bool,
35    motion_context_animated: bool,
36    translated_content_context: bool,
37    translated_content_context_identity: Option<usize>,
38    translated_content_offset_reader: Option<Rc<dyn Fn() -> Point>>,
39    text_content: Option<Rc<crate::text::AnnotatedString>>,
40    text_style: Option<TextStyle>,
41    text_layout_options: Option<TextLayoutOptions>,
42    prepared_text_layout: Option<TextPreparedLayoutHandle>,
43    text_pan: Option<TextPanResolver>,
44    text_field_window_origin: Option<Rc<std::cell::Cell<Point>>>,
45    viewport_window_rect: Option<Rc<dyn crate::modifier_nodes::WindowRectSink>>,
46    graphics_layer: Option<GraphicsLayer>,
47    graphics_layer_resolver: Option<Rc<dyn Fn() -> GraphicsLayer>>,
48    corner_shape: Option<RoundedCornerShape>,
49    chain_guard: Option<Rc<ChainGuard>>,
50}
51
52struct ChainGuard {
53    _handle: ModifierChainHandle,
54}
55
56#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
57pub struct ModifierNodeSlicesDebugStats {
58    pub draw_command_count: usize,
59    pub draw_command_capacity: usize,
60    pub pointer_input_count: usize,
61    pub pointer_input_capacity: usize,
62    pub click_handler_count: usize,
63    pub click_handler_capacity: usize,
64    pub has_text_content: bool,
65    pub has_text_style: bool,
66    pub has_text_layout_options: bool,
67    pub has_prepared_text_layout: bool,
68    pub has_graphics_layer: bool,
69    pub has_graphics_layer_resolver: bool,
70    pub heap_bytes: usize,
71}
72
73impl Clone for ModifierNodeSlices {
74    fn clone(&self) -> Self {
75        Self {
76            draw_commands: self.draw_commands.clone(),
77            layer_draw_boundary: self.layer_draw_boundary,
78            pointer_inputs: self.pointer_inputs.clone(),
79            pointer_input_sizes: self.pointer_input_sizes.clone(),
80            click_handlers: self.click_handlers.clone(),
81            pointer_icon: self.pointer_icon.clone(),
82            clip_to_bounds: self.clip_to_bounds,
83            motion_context_animated: self.motion_context_animated,
84            translated_content_context: self.translated_content_context,
85            translated_content_context_identity: self.translated_content_context_identity,
86            translated_content_offset_reader: self.translated_content_offset_reader.clone(),
87            text_content: self.text_content.clone(),
88            text_style: self.text_style.clone(),
89            text_layout_options: self.text_layout_options,
90            prepared_text_layout: self.prepared_text_layout.clone(),
91            text_pan: self.text_pan.clone(),
92            text_field_window_origin: self.text_field_window_origin.clone(),
93            viewport_window_rect: self.viewport_window_rect.clone(),
94            graphics_layer: self.graphics_layer.clone(),
95            graphics_layer_resolver: self.graphics_layer_resolver.clone(),
96            corner_shape: self.corner_shape,
97            chain_guard: self.chain_guard.clone(),
98        }
99    }
100}
101
102fn merge_graphics_layers(base: GraphicsLayer, overlay: GraphicsLayer) -> GraphicsLayer {
103    GraphicsLayer {
104        alpha: (base.alpha * overlay.alpha).clamp(0.0, 1.0),
105        scale: base.scale * overlay.scale,
106        scale_x: base.scale_x * overlay.scale_x,
107        scale_y: base.scale_y * overlay.scale_y,
108        rotation_x: base.rotation_x + overlay.rotation_x,
109        rotation_y: base.rotation_y + overlay.rotation_y,
110        rotation_z: base.rotation_z + overlay.rotation_z,
111        camera_distance: overlay.camera_distance,
112        transform_origin: overlay.transform_origin,
113        translation_x: base.translation_x + overlay.translation_x,
114        translation_y: base.translation_y + overlay.translation_y,
115        shadow_elevation: overlay.shadow_elevation,
116        ambient_shadow_color: overlay.ambient_shadow_color,
117        spot_shadow_color: overlay.spot_shadow_color,
118        shape: merged_layer_shape(&base, &overlay),
119        clip: base.clip || overlay.clip,
120        compositing_strategy: overlay.compositing_strategy,
121        blend_mode: overlay.blend_mode,
122        color_filter: compose_color_filters(base.color_filter, overlay.color_filter),
123        render_effect: compose_render_effects(base.render_effect, overlay.render_effect),
124        backdrop_effect: overlay.backdrop_effect.or(base.backdrop_effect),
125    }
126}
127
128/// The shape of two stacked layers merged into one: the layer that clips
129/// owns it, else the layer that carries the backdrop (its effect covers that
130/// shape), else the later layer, whose default resets it like every other
131/// parent-local field.
132fn merged_layer_shape(base: &GraphicsLayer, overlay: &GraphicsLayer) -> LayerShape {
133    if overlay.clip || (!base.clip && overlay.backdrop_effect.is_some()) {
134        overlay.shape
135    } else if base.clip || base.backdrop_effect.is_some() {
136        base.shape
137    } else {
138        overlay.shape
139    }
140}
141
142fn compose_render_effects(
143    outer: Option<RenderEffect>,
144    inner: Option<RenderEffect>,
145) -> Option<RenderEffect> {
146    match (outer, inner) {
147        (None, None) => None,
148        (Some(effect), None) | (None, Some(effect)) => Some(effect),
149        (Some(outer_effect), Some(inner_effect)) => Some(inner_effect.then(outer_effect)),
150    }
151}
152
153fn compose_color_filters(
154    base: Option<ColorFilter>,
155    overlay: Option<ColorFilter>,
156) -> Option<ColorFilter> {
157    match (base, overlay) {
158        (None, None) => None,
159        (Some(filter), None) | (None, Some(filter)) => Some(filter),
160        (Some(filter), Some(next)) => Some(filter.compose(next)),
161    }
162}
163
164impl ModifierNodeSlices {
165    pub fn draw_commands(&self) -> &[DrawCommand] {
166        &self.draw_commands
167    }
168
169    /// How many leading [`draw_commands`](Self::draw_commands) come from
170    /// modifiers chained before the node's graphics layer or clip. Those draw
171    /// around the layer in the parent's space, outside its clip, alpha and
172    /// transform, exactly as an outer `drawBehind` wraps a `graphicsLayer`.
173    pub fn outer_draw_command_count(&self) -> usize {
174        self.layer_draw_boundary.unwrap_or(0)
175    }
176
177    fn insert_background_draw(
178        &mut self,
179        insert_index: Option<usize>,
180        precedes_layer: bool,
181        command: DrawCommand,
182    ) {
183        let insert_index = insert_index.unwrap_or(0).min(self.draw_commands.len());
184        self.draw_commands.insert(insert_index, command);
185        if let Some(boundary) = self.layer_draw_boundary.as_mut()
186            && precedes_layer
187        {
188            *boundary += 1;
189        }
190    }
191
192    fn mark_layer_draw_boundary(&mut self) {
193        if self.layer_draw_boundary.is_none() {
194            self.layer_draw_boundary = Some(self.draw_commands.len());
195        }
196    }
197
198    pub fn pointer_inputs(&self) -> &[Rc<dyn Fn(PointerEvent)>] {
199        &self.pointer_inputs
200    }
201
202    /// The write targets for this node's resolved size, one per pointer-input
203    /// node that exposes a size to its handler. See
204    /// [`ModifierNodeSlices::publish_pointer_input_size`].
205    pub fn pointer_input_size_sinks(&self) -> &[Rc<std::cell::Cell<cranpose_ui_graphics::Size>>] {
206        &self.pointer_input_sizes
207    }
208
209    /// Publishes this layout node's resolved size to every pointer-input
210    /// handler attached to it, so `PointerInputScope::size()` reports the
211    /// node's real dimensions.
212    ///
213    /// Called by every pass that resolves a node's geometry (the layout `place`
214    /// passes and the per-frame scene build), so the size is current before any
215    /// pointer event for that frame is dispatched and tracks resizes.
216    ///
217    /// `size` is the node's layout box — the same box the dispatched
218    /// [`PointerEvent`] positions are made local to — so handlers can compare
219    /// event coordinates against it directly.
220    pub fn publish_pointer_input_size(&self, size: cranpose_ui_graphics::Size) {
221        for sink in &self.pointer_input_sizes {
222            sink.set(size);
223        }
224    }
225
226    pub fn click_handlers(&self) -> &[Rc<dyn Fn(Point)>] {
227        &self.click_handlers
228    }
229
230    /// The pointer's appearance over this node, when a `pointer_icon`
231    /// modifier names one. The innermost declaration in the chain wins.
232    pub fn pointer_icon(&self) -> Option<&PointerIcon> {
233        self.pointer_icon.as_ref()
234    }
235
236    pub fn clip_to_bounds(&self) -> bool {
237        self.clip_to_bounds
238    }
239
240    pub fn motion_context_animated(&self) -> bool {
241        self.motion_context_animated
242    }
243
244    pub fn translated_content_context(&self) -> bool {
245        self.translated_content_context
246    }
247
248    pub fn translated_content_context_identity(&self) -> Option<usize> {
249        self.translated_content_context_identity
250    }
251
252    pub fn translated_content_offset(&self) -> Option<Point> {
253        self.translated_content_offset_reader
254            .as_ref()
255            .map(|reader| reader())
256    }
257
258    pub fn text_content(&self) -> Option<&str> {
259        self.text_content.as_ref().map(|a| a.text.as_str())
260    }
261
262    pub fn annotated_text(&self) -> Option<&crate::text::AnnotatedString> {
263        self.text_content.as_deref()
264    }
265
266    pub fn annotated_string(&self) -> Option<crate::text::AnnotatedString> {
267        self.annotated_text().cloned()
268    }
269
270    pub fn text_style(&self) -> Option<&TextStyle> {
271        self.text_style.as_ref()
272    }
273
274    pub fn text_layout_options(&self) -> Option<TextLayoutOptions> {
275        self.text_layout_options
276    }
277
278    /// Returns the horizontal pan resolver for single-line text fields.
279    ///
280    /// The resolver takes the content viewport width (px) and returns the
281    /// horizontal scroll offset that keeps the cursor visible. Renderers
282    /// subtract this offset from the text origin so the glyphs pan together
283    /// with the cursor and selection.
284    pub fn text_pan_resolver(&self) -> Option<TextPanResolver> {
285        self.text_pan.clone()
286    }
287
288    /// The write target for a text field's composited window origin, if this
289    /// node is a `BasicTextField`. The layout pass writes the field's true
290    /// on-screen top-left here so its finger selection handles track the field
291    /// across scroll. See [`ModifierNodeSlices::text_field_window_origin`].
292    pub fn text_field_window_origin(&self) -> Option<Rc<std::cell::Cell<Point>>> {
293        self.text_field_window_origin.clone()
294    }
295
296    /// The write target for a scroll container's composited window rect, if this
297    /// node carries a `report_window_rect` modifier. The layout pass writes the
298    /// node's true on-screen viewport rect here so a `BringIntoViewResponder`
299    /// can scroll a focused field's caret above the soft keyboard.
300    pub fn viewport_window_rect(&self) -> Option<Rc<dyn crate::modifier_nodes::WindowRectSink>> {
301        self.viewport_window_rect.clone()
302    }
303
304    pub fn prepare_text_layout(
305        &self,
306        max_width: Option<f32>,
307    ) -> Option<crate::text::PreparedTextLayout> {
308        if let Some(handle) = &self.prepared_text_layout {
309            return Some(handle.prepare(max_width));
310        }
311
312        let text = self.annotated_text()?;
313        let style = self.text_style.clone().unwrap_or_default();
314        Some(crate::text::prepare_text_layout(
315            text,
316            &style,
317            self.text_layout_options.unwrap_or_default(),
318            max_width,
319        ))
320    }
321
322    pub fn graphics_layer(&self) -> Option<GraphicsLayer> {
323        if let Some(resolve) = &self.graphics_layer_resolver {
324            Some(resolve())
325        } else {
326            self.graphics_layer.clone()
327        }
328    }
329
330    pub fn corner_shape(&self) -> Option<RoundedCornerShape> {
331        self.corner_shape
332    }
333
334    fn push_graphics_layer(
335        &mut self,
336        layer: GraphicsLayer,
337        resolver: Option<Rc<dyn Fn() -> GraphicsLayer>>,
338    ) {
339        let existing_snapshot = self.graphics_layer.clone();
340        let next_snapshot = existing_snapshot
341            .as_ref()
342            .map(|current| merge_graphics_layers(current.clone(), layer.clone()))
343            .unwrap_or_else(|| layer.clone());
344        let existing_resolver = self.graphics_layer_resolver.clone();
345
346        self.graphics_layer = Some(next_snapshot);
347        self.graphics_layer_resolver = match (existing_resolver, resolver) {
348            (None, None) => None,
349            (Some(current_resolver), None) => {
350                let layer = layer.clone();
351                Some(Rc::new(move || {
352                    merge_graphics_layers(current_resolver(), layer.clone())
353                }))
354            }
355            (None, Some(next_resolver)) => {
356                let base = existing_snapshot.unwrap_or_default();
357                Some(Rc::new(move || {
358                    merge_graphics_layers(base.clone(), next_resolver())
359                }))
360            }
361            (Some(current_resolver), Some(next_resolver)) => Some(Rc::new(move || {
362                merge_graphics_layers(current_resolver(), next_resolver())
363            })),
364        };
365    }
366
367    pub fn with_chain_guard(mut self, handle: ModifierChainHandle) -> Self {
368        self.chain_guard = Some(Rc::new(ChainGuard { _handle: handle }));
369        self
370    }
371
372    pub fn debug_stats(&self) -> ModifierNodeSlicesDebugStats {
373        let draw_command_bytes = self.draw_commands.capacity() * size_of::<DrawCommand>();
374        let pointer_input_bytes =
375            self.pointer_inputs.capacity() * size_of::<Rc<dyn Fn(PointerEvent)>>();
376        let click_handler_bytes = self.click_handlers.capacity() * size_of::<Rc<dyn Fn(Point)>>();
377        ModifierNodeSlicesDebugStats {
378            draw_command_count: self.draw_commands.len(),
379            draw_command_capacity: self.draw_commands.capacity(),
380            pointer_input_count: self.pointer_inputs.len(),
381            pointer_input_capacity: self.pointer_inputs.capacity(),
382            click_handler_count: self.click_handlers.len(),
383            click_handler_capacity: self.click_handlers.capacity(),
384            has_text_content: self.text_content.is_some(),
385            has_text_style: self.text_style.is_some(),
386            has_text_layout_options: self.text_layout_options.is_some(),
387            has_prepared_text_layout: self.prepared_text_layout.is_some(),
388            has_graphics_layer: self.graphics_layer.is_some(),
389            has_graphics_layer_resolver: self.graphics_layer_resolver.is_some(),
390            heap_bytes: draw_command_bytes + pointer_input_bytes + click_handler_bytes,
391        }
392    }
393
394    /// Resets the slice collection for reuse, retaining vector capacity.
395    pub fn clear(&mut self) {
396        self.draw_commands.clear();
397        self.layer_draw_boundary = None;
398        self.pointer_inputs.clear();
399        self.pointer_input_sizes.clear();
400        self.click_handlers.clear();
401        self.pointer_icon = None;
402        self.clip_to_bounds = false;
403        self.motion_context_animated = false;
404        self.translated_content_context = false;
405        self.translated_content_context_identity = None;
406        self.translated_content_offset_reader = None;
407        self.text_content = None;
408        self.text_style = None;
409        self.text_layout_options = None;
410        self.prepared_text_layout = None;
411        self.text_pan = None;
412        self.graphics_layer = None;
413        self.graphics_layer_resolver = None;
414        self.corner_shape = None;
415        self.chain_guard = None;
416    }
417}
418
419impl fmt::Debug for ModifierNodeSlices {
420    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
421        f.debug_struct("ModifierNodeSlices")
422            .field("draw_commands", &self.draw_commands.len())
423            .field("pointer_inputs", &self.pointer_inputs.len())
424            .field("click_handlers", &self.click_handlers.len())
425            .field("pointer_icon", &self.pointer_icon)
426            .field("clip_to_bounds", &self.clip_to_bounds)
427            .field("motion_context_animated", &self.motion_context_animated)
428            .field(
429                "translated_content_context",
430                &self.translated_content_context,
431            )
432            .field(
433                "translated_content_context_identity",
434                &self.translated_content_context_identity,
435            )
436            .field(
437                "translated_content_offset",
438                &self.translated_content_offset(),
439            )
440            .field("text_content", &self.text_content)
441            .field("text_style", &self.text_style)
442            .field("text_layout_options", &self.text_layout_options)
443            .field("prepared_text_layout", &self.prepared_text_layout.is_some())
444            .field("graphics_layer", &self.graphics_layer)
445            .field(
446                "graphics_layer_resolver",
447                &self.graphics_layer_resolver.is_some(),
448            )
449            .field("corner_shape", &self.corner_shape)
450            .finish()
451    }
452}
453
454/// Records `node`'s pointer icon when it declares one, leaving the icon already
455/// collected in place when it does not.
456///
457/// The chain is walked head to tail, so the innermost declaration is the last
458/// one written and the one that survives.
459fn collect_pointer_icon(node: &dyn std::any::Any, slices: &mut ModifierNodeSlices) {
460    if let Some(icon_node) = node.downcast_ref::<PointerIconNode>() {
461        slices.pointer_icon = Some(icon_node.icon().clone());
462    }
463}
464
465/// Collects modifier node slices directly from a reconciled [`ModifierNodeChain`].
466pub fn collect_modifier_slices(chain: &ModifierNodeChain) -> ModifierNodeSlices {
467    let mut slices = ModifierNodeSlices::default();
468    collect_modifier_slices_into(chain, &mut slices);
469    slices
470}
471
472/// Collects modifier node slices into an existing buffer to reuse allocations.
473///
474/// Single-pass: iterates the chain once instead of 4 separate capability-filtered
475/// traversals, reducing per-node `RefCell::borrow()` overhead.
476pub fn collect_modifier_slices_into(chain: &ModifierNodeChain, slices: &mut ModifierNodeSlices) {
477    slices.clear();
478
479    let caps = chain.capabilities();
480    let has_pointer = caps.intersects(NodeCapabilities::POINTER_INPUT);
481    let has_draw = caps.intersects(NodeCapabilities::DRAW);
482    let has_layout = caps.intersects(NodeCapabilities::LAYOUT);
483
484    if !has_pointer && !has_draw && !has_layout {
485        return;
486    }
487
488    let mut background_color = None;
489    let mut background_insert_index = None::<usize>;
490    let mut background_precedes_layer = false;
491    let mut corner_shape = None;
492    let mut padding = EdgeInsets::default();
493
494    for node_ref in chain.head_to_tail() {
495        let node_caps = node_ref.kind_set();
496
497        node_ref.with_node(|node| {
498            let any = node.as_any();
499
500            if has_pointer
501                && node_caps.intersects(NodeCapabilities::POINTER_INPUT)
502                && let Some(pointer_node) = node.as_pointer_input_node()
503            {
504                if let Some(handler) = pointer_node.pointer_input_handler() {
505                    slices.pointer_inputs.push(handler);
506                }
507                if let Some(sink) = pointer_node.layout_size_sink() {
508                    slices.pointer_input_sizes.push(sink);
509                }
510                collect_pointer_icon(any, slices);
511            }
512
513            if has_draw && node_caps.intersects(NodeCapabilities::DRAW) {
514                if let Some(bg_node) = any.downcast_ref::<BackgroundNode>() {
515                    background_color = Some(bg_node.color());
516                    background_insert_index = Some(slices.draw_commands.len());
517                    background_precedes_layer = slices.layer_draw_boundary.is_none();
518                    if bg_node.shape().is_some() {
519                        corner_shape = bg_node.shape();
520                    }
521                }
522
523                if let Some(shape_node) = any.downcast_ref::<CornerShapeNode>() {
524                    corner_shape = Some(shape_node.shape());
525                }
526
527                if let Some(commands) = any.downcast_ref::<DrawCommandNode>() {
528                    slices.draw_commands.extend(commands.observed_commands());
529                }
530
531                if let Some(draw_node) = node.as_draw_node() {
532                    if let Some(closure) = draw_node.create_behind_draw_closure() {
533                        slices.draw_commands.push(DrawCommand::Behind(closure));
534                    }
535                    if let Some(closure) = draw_node.create_draw_closure() {
536                        slices.draw_commands.push(DrawCommand::Overlay(closure));
537                    } else {
538                        use cranpose_ui_graphics::{DrawScope as _, DrawScopeDefault};
539                        let mut scope = DrawScopeDefault::with_text_measurer(
540                            crate::modifier::Size {
541                                width: 0.0,
542                                height: 0.0,
543                            },
544                            crate::text::AppContextTextMeasurer::shared(),
545                        );
546                        draw_node.draw(&mut scope);
547                        let primitives = scope.into_primitives();
548                        if !primitives.is_empty() {
549                            let draw_cmd = Rc::new(
550                                move |scope: &mut cranpose_ui_graphics::DrawScopeDefault| {
551                                    scope.push_recorded(primitives.clone())
552                                },
553                            );
554                            slices.draw_commands.push(DrawCommand::Overlay(draw_cmd));
555                        }
556                    }
557                }
558
559                if let Some(layer_node) = any.downcast_ref::<GraphicsLayerNode>() {
560                    slices.mark_layer_draw_boundary();
561                    slices.push_graphics_layer(
562                        layer_node.layer_snapshot(),
563                        layer_node.layer_resolver(),
564                    );
565                }
566
567                if any.is::<ClipToBoundsNode>() {
568                    slices.mark_layer_draw_boundary();
569                    slices.clip_to_bounds = true;
570                }
571            }
572
573            if has_layout && node_caps.intersects(NodeCapabilities::LAYOUT) {
574                if let Some(padding_node) = any.downcast_ref::<PaddingNode>() {
575                    let p = padding_node.padding();
576                    padding.left += p.left;
577                    padding.top += p.top;
578                    padding.right += p.right;
579                    padding.bottom += p.bottom;
580                }
581
582                if let Some(motion_context_node) = any.downcast_ref::<MotionContextAnimatedNode>() {
583                    slices.motion_context_animated = motion_context_node.is_active();
584                }
585
586                if let Some(reporter) = any.downcast_ref::<WindowRectReporterNode>() {
587                    slices.viewport_window_rect = Some(reporter.window_rect_sink());
588                }
589
590                if let Some(translated_content_node) =
591                    any.downcast_ref::<TranslatedContentContextNode>()
592                {
593                    slices.translated_content_context = translated_content_node.is_active();
594                    slices.translated_content_context_identity =
595                        Some(translated_content_node.identity());
596                    slices.translated_content_offset_reader =
597                        translated_content_node.content_offset_reader();
598                }
599
600                if let Some(text_node) = any.downcast_ref::<TextModifierNode>() {
601                    slices.text_content = Some(text_node.annotated_text());
602                    slices.text_style = Some(text_node.style().clone());
603                    slices.text_layout_options = Some(text_node.options());
604                    slices.prepared_text_layout = Some(text_node.prepared_layout_handle());
605                }
606
607                if let Some(text_field_node) = any.downcast_ref::<TextFieldModifierNode>() {
608                    let text = text_field_node.text();
609                    slices.text_content = Some(Rc::new(crate::text::AnnotatedString::from(text)));
610                    slices.text_style = Some(text_field_node.style().clone());
611                    slices.text_layout_options = Some(TextLayoutOptions::default());
612                    slices.prepared_text_layout = None;
613                    slices.text_pan = text_field_node.text_pan_resolver();
614                    slices.text_field_window_origin = Some(text_field_node.window_origin_sink());
615
616                    text_field_node.set_content_offset(padding.left);
617                    text_field_node.set_content_y_offset(padding.top);
618                }
619            }
620        });
621    }
622
623    slices.corner_shape = corner_shape;
624
625    if let Some(color) = background_color {
626        let draw_cmd = Rc::new(move |scope: &mut cranpose_ui_graphics::DrawScopeDefault| {
627            use cranpose_ui_graphics::{CornerRadii, DrawScope as _};
628
629            use crate::modifier::Brush;
630
631            let size = scope.size();
632            let brush = Brush::solid(color);
633            if let Some(shape) = corner_shape {
634                let radii: CornerRadii = shape.resolve(size.width, size.height);
635                scope.draw_round_rect(brush, radii);
636            } else {
637                scope.draw_rect(brush);
638            }
639        });
640
641        slices.insert_background_draw(
642            background_insert_index,
643            background_precedes_layer,
644            DrawCommand::Behind(draw_cmd),
645        );
646    }
647}
648
649/// Collects modifier node slices by instantiating a temporary node chain from a [`Modifier`].
650pub fn collect_slices_from_modifier(modifier: &Modifier) -> ModifierNodeSlices {
651    let mut handle = ModifierChainHandle::new();
652    let _ = handle.update(modifier);
653    collect_modifier_slices(handle.chain()).with_chain_guard(handle)
654}
cranpose_ui/modifier/slices.rs

cranpose_ui/modifier/
slices.rs
