zng_wgt_text/node/
layout.rs

1use std::{mem, sync::Arc};
2
3use atomic::Atomic;
4use parking_lot::RwLock;
5use zng_app::{
6    DInstant,
7    event::CommandHandle,
8    widget::{
9        WIDGET,
10        node::{UiNode, UiNodeOp, match_node},
11    },
12};
13use zng_ext_font::{
14    CaretIndex, FontFaceList, Hyphens, SegmentedText, ShapedText, TextReshapingArgs, TextShapingArgs, font_features::FontVariations,
15};
16use zng_ext_input::{
17    focus::FOCUS,
18    keyboard::{KEY_INPUT_EVENT, KEYBOARD},
19    mouse::{MOUSE, MOUSE_INPUT_EVENT, MOUSE_MOVE_EVENT},
20    pointer_capture::{POINTER_CAPTURE, POINTER_CAPTURE_EVENT},
21    touch::{TOUCH_INPUT_EVENT, TOUCH_LONG_PRESS_EVENT, TOUCH_TAP_EVENT},
22};
23use zng_ext_l10n::LANG_VAR;
24use zng_ext_undo::UNDO;
25use zng_ext_window::WidgetInfoBuilderImeArea as _;
26use zng_layout::{
27    context::{InlineConstraints, InlineConstraintsMeasure, InlineSegment, LAYOUT, LayoutMetrics},
28    unit::{DipPoint, FactorUnits as _, Px, PxBox, PxConstraints2d, PxRect, PxSize, PxTransform, Rect, Size},
29};
30use zng_view_api::keyboard::{Key, KeyState};
31use zng_wgt::prelude::*;
32use zng_wgt_scroll::{SCROLL, cmd::ScrollToMode};
33
34use crate::{
35    ACCEPTS_ENTER_VAR, AUTO_SELECTION_VAR, AutoSelection, FONT_FAMILY_VAR, FONT_FEATURES_VAR, FONT_SIZE_VAR, FONT_STRETCH_VAR,
36    FONT_STYLE_VAR, FONT_VARIATIONS_VAR, FONT_WEIGHT_VAR, HYPHEN_CHAR_VAR, HYPHENS_VAR, IME_UNDERLINE_THICKNESS_VAR, JUSTIFY_MODE_VAR,
37    LETTER_SPACING_VAR, LINE_BREAK_VAR, LINE_HEIGHT_VAR, LINE_SPACING_VAR, OBSCURE_TXT_VAR, OBSCURING_CHAR_VAR, OVERLINE_THICKNESS_VAR,
38    PARAGRAPH_BREAK_VAR, PARAGRAPH_INDENT_VAR, PARAGRAPH_SPACING_VAR, STRIKETHROUGH_THICKNESS_VAR, TAB_LENGTH_VAR, TEXT_ALIGN_VAR,
39    TEXT_EDITABLE_VAR, TEXT_OVERFLOW_ALIGN_VAR, TEXT_OVERFLOW_VAR, TEXT_SELECTABLE_ALT_ONLY_VAR, TEXT_SELECTABLE_VAR, TEXT_WRAP_VAR,
40    TextOverflow, UNDERLINE_POSITION_VAR, UNDERLINE_SKIP_VAR, UNDERLINE_THICKNESS_VAR, UnderlinePosition, UnderlineSkip, WORD_BREAK_VAR,
41    WORD_SPACING_VAR,
42    cmd::{SELECT_ALL_CMD, SELECT_CMD, TextSelectOp},
43    node::SelectionBy,
44};
45
46use super::{LAIDOUT_TEXT, LaidoutText, PendingLayout, RenderInfo, TEXT};
47
48/// An UI node that layouts the parent [`ResolvedText`] defined by the text context vars.
49///
50/// This node setups the [`LaidoutText`] for all inner nodes, the `Text!` widget includes this
51/// node in the `NestGroup::CHILD_LAYOUT + 100` nest group, so all properties in [`NestGroup::CHILD_LAYOUT`]
52/// can affect the layout normally and custom properties can be created to be inside this group and have access
53/// to the [`TEXT::laidout`] method.
54///
55/// [`ResolvedText`]: super::ResolvedText
56///
57/// [`NestGroup::CHILD_LAYOUT`]: zng_wgt::prelude::NestGroup::CHILD_LAYOUT
58pub fn layout_text(child: impl IntoUiNode) -> UiNode {
59    let child = layout_text_edit(child);
60    let child = layout_text_layout(child);
61    layout_text_context(child)
62}
63fn layout_text_context(child: impl IntoUiNode) -> UiNode {
64    let mut laidout = None;
65    match_node(child, move |child, op| match op {
66        UiNodeOp::Init => {
67            let fonts = FontFaceList::empty().sized(Px(10), vec![]);
68            laidout = Some(Arc::new(RwLock::new(LaidoutText {
69                shaped_text: ShapedText::new(fonts.best()),
70                fonts,
71                overflow: None,
72                overflow_suffix: None,
73                shaped_text_version: 0,
74                overlines: vec![],
75                overline_thickness: Px(0),
76                strikethroughs: vec![],
77                strikethrough_thickness: Px(0),
78                underlines: vec![],
79                underline_thickness: Px(0),
80                ime_underlines: vec![],
81                ime_underline_thickness: Px(0),
82                caret_origin: None,
83                caret_selection_origin: None,
84                caret_retained_x: Px(0),
85                render_info: RenderInfo {
86                    transform: PxTransform::identity(),
87                    scale_factor: 1.fct(),
88                },
89                viewport: PxSize::zero(),
90            })));
91
92            LAIDOUT_TEXT.with_context(&mut laidout, || child.init());
93        }
94        UiNodeOp::Deinit => {
95            LAIDOUT_TEXT.with_context(&mut laidout, || child.deinit());
96
97            laidout = None;
98        }
99        op => LAIDOUT_TEXT.with_context(&mut laidout, || child.op(op)),
100    })
101}
102fn layout_text_layout(child: impl IntoUiNode) -> UiNode {
103    let mut txt = LayoutTextFinal {
104        shaping_args: TextShapingArgs::default(),
105        pending: PendingLayout::empty(),
106        txt_is_measured: false,
107        last_layout: (LayoutMetrics::new(1.fct(), PxSize::zero(), Px(0)), None),
108        baseline: Px(0),
109    };
110
111    match_node(child, move |child, op| match op {
112        UiNodeOp::Init => {
113            WIDGET
114                .sub_var(&FONT_SIZE_VAR)
115                .sub_var(&FONT_VARIATIONS_VAR)
116                .sub_var(&LETTER_SPACING_VAR)
117                .sub_var(&WORD_SPACING_VAR)
118                .sub_var(&LINE_SPACING_VAR)
119                .sub_var(&PARAGRAPH_SPACING_VAR)
120                .sub_var(&PARAGRAPH_INDENT_VAR)
121                .sub_var(&LINE_HEIGHT_VAR)
122                .sub_var(&TAB_LENGTH_VAR);
123            WIDGET
124                .sub_var(&UNDERLINE_POSITION_VAR)
125                .sub_var(&UNDERLINE_SKIP_VAR)
126                .sub_var_layout(&OVERLINE_THICKNESS_VAR)
127                .sub_var_layout(&STRIKETHROUGH_THICKNESS_VAR)
128                .sub_var_layout(&UNDERLINE_THICKNESS_VAR);
129            WIDGET
130                .sub_var(&PARAGRAPH_BREAK_VAR)
131                .sub_var(&LINE_BREAK_VAR)
132                .sub_var(&WORD_BREAK_VAR)
133                .sub_var(&HYPHENS_VAR)
134                .sub_var(&HYPHEN_CHAR_VAR)
135                .sub_var(&TEXT_WRAP_VAR)
136                .sub_var(&TEXT_OVERFLOW_VAR);
137            WIDGET
138                .sub_var_layout(&TEXT_ALIGN_VAR)
139                .sub_var_layout(&JUSTIFY_MODE_VAR)
140                .sub_var_layout(&TEXT_OVERFLOW_ALIGN_VAR);
141
142            WIDGET.sub_var(&FONT_FEATURES_VAR);
143
144            WIDGET.sub_var(&OBSCURE_TXT_VAR).sub_var(&OBSCURING_CHAR_VAR);
145
146            // LANG_VAR already subscribed by resolve_text
147
148            txt.shaping_args.lang = LANG_VAR.with(|l| l.best().clone());
149            txt.shaping_args.direction = txt.shaping_args.lang.direction();
150            txt.shaping_args.paragraph_break = PARAGRAPH_BREAK_VAR.get();
151            txt.shaping_args.line_break = LINE_BREAK_VAR.get();
152            txt.shaping_args.word_break = WORD_BREAK_VAR.get();
153            txt.shaping_args.hyphens = HYPHENS_VAR.get();
154            txt.shaping_args.hyphen_char = HYPHEN_CHAR_VAR.get();
155            txt.shaping_args.font_features = FONT_FEATURES_VAR.with(|f| f.finalize());
156
157            if OBSCURE_TXT_VAR.get() {
158                txt.shaping_args.obscuring_char = Some(OBSCURING_CHAR_VAR.get());
159            }
160        }
161        UiNodeOp::Deinit => {
162            txt.shaping_args = TextShapingArgs::default();
163        }
164        UiNodeOp::Update { .. } => {
165            if FONT_SIZE_VAR.is_new() || FONT_VARIATIONS_VAR.is_new() {
166                txt.pending.insert(PendingLayout::RESHAPE);
167                TEXT.layout().overflow_suffix = None;
168                WIDGET.layout();
169            }
170
171            if LETTER_SPACING_VAR.is_new() || WORD_SPACING_VAR.is_new() || TAB_LENGTH_VAR.is_new() {
172                TEXT.layout().overflow_suffix = None;
173                txt.pending.insert(PendingLayout::RESHAPE);
174                WIDGET.layout();
175            }
176
177            if LINE_SPACING_VAR.is_new() || LINE_HEIGHT_VAR.is_new() || PARAGRAPH_SPACING_VAR.is_new() || PARAGRAPH_INDENT_VAR.is_new() {
178                TEXT.layout().overflow_suffix = None;
179                txt.pending.insert(PendingLayout::RESHAPE_LINES);
180                WIDGET.layout();
181            }
182
183            if let Some(l) = LANG_VAR.get_new() {
184                txt.shaping_args.lang = l.best().clone();
185                txt.shaping_args.direction = txt.shaping_args.lang.direction(); // will be set in layout too.
186                TEXT.layout().overflow_suffix = None;
187                txt.pending.insert(PendingLayout::RESHAPE);
188                WIDGET.layout();
189            }
190
191            if UNDERLINE_POSITION_VAR.is_new() || UNDERLINE_SKIP_VAR.is_new() {
192                txt.pending.insert(PendingLayout::UNDERLINE);
193                WIDGET.layout();
194            }
195            if let Some(pb) = PARAGRAPH_BREAK_VAR.get_new()
196                && txt.shaping_args.paragraph_break != pb
197            {
198                txt.shaping_args.paragraph_break = pb;
199                txt.pending.insert(PendingLayout::RESHAPE_LINES);
200                WIDGET.layout();
201            }
202            if let Some(lb) = LINE_BREAK_VAR.get_new()
203                && txt.shaping_args.line_break != lb
204            {
205                txt.shaping_args.line_break = lb;
206                txt.pending.insert(PendingLayout::RESHAPE);
207                WIDGET.layout();
208            }
209            if let Some(wb) = WORD_BREAK_VAR.get_new()
210                && txt.shaping_args.word_break != wb
211            {
212                txt.shaping_args.word_break = wb;
213                txt.pending.insert(PendingLayout::RESHAPE);
214                WIDGET.layout();
215            }
216            if let Some(h) = HYPHENS_VAR.get_new()
217                && txt.shaping_args.hyphens != h
218            {
219                txt.shaping_args.hyphens = h;
220                txt.pending.insert(PendingLayout::RESHAPE);
221                WIDGET.layout();
222            }
223            if let Some(c) = HYPHEN_CHAR_VAR.get_new() {
224                txt.shaping_args.hyphen_char = c;
225                if Hyphens::None != txt.shaping_args.hyphens {
226                    txt.pending.insert(PendingLayout::RESHAPE);
227                    WIDGET.layout();
228                }
229            }
230
231            if OBSCURE_TXT_VAR.is_new() || OBSCURING_CHAR_VAR.is_new() {
232                let c = if OBSCURE_TXT_VAR.get() {
233                    Some(OBSCURING_CHAR_VAR.get())
234                } else {
235                    None
236                };
237                if txt.shaping_args.obscuring_char != c {
238                    txt.shaping_args.obscuring_char = c;
239                    txt.pending.insert(PendingLayout::RESHAPE);
240                    WIDGET.layout();
241                }
242            }
243
244            if TEXT_WRAP_VAR.is_new() {
245                txt.pending.insert(PendingLayout::RESHAPE);
246                WIDGET.layout();
247            }
248            if TEXT_OVERFLOW_VAR.is_new() {
249                TEXT.layout().overflow_suffix = None;
250                txt.pending.insert(PendingLayout::OVERFLOW);
251                WIDGET.layout();
252            }
253
254            FONT_FEATURES_VAR.with_new(|f| {
255                txt.shaping_args.font_features = f.finalize();
256                txt.pending.insert(PendingLayout::RESHAPE);
257                WIDGET.layout();
258            });
259
260            if FONT_FAMILY_VAR.is_new()
261                || FONT_STYLE_VAR.is_new()
262                || FONT_STRETCH_VAR.is_new()
263                || FONT_WEIGHT_VAR.is_new()
264                || LANG_VAR.is_new()
265            {
266                // resolve_text already requests RESHAPE
267                TEXT.layout().overflow_suffix = None;
268            }
269        }
270        UiNodeOp::Measure { wm, desired_size } => {
271            child.delegated();
272
273            let metrics = LAYOUT.metrics();
274
275            *desired_size = if let Some(size) = txt.measure(&metrics) {
276                size
277            } else {
278                let size = txt.layout(&metrics, true);
279
280                if let Some(inline) = wm.inline() {
281                    let ctx = TEXT.laidout();
282
283                    if let Some(first_line) = ctx.shaped_text.line(0) {
284                        inline.first = first_line.original_size();
285                        inline.with_first_segs(|i| {
286                            for seg in first_line.segs() {
287                                i.push(InlineSegment::new(seg.advance(), seg.kind()));
288                            }
289                        });
290                    } else {
291                        inline.first = PxSize::zero();
292                        inline.with_first_segs(|i| i.clear());
293                    }
294
295                    if ctx.shaped_text.lines_len() == 1 {
296                        inline.last = inline.first;
297                        inline.last_segs = inline.first_segs.clone();
298                    } else if let Some(last_line) = ctx.shaped_text.line(ctx.shaped_text.lines_len().saturating_sub(1)) {
299                        inline.last = last_line.original_size();
300                        inline.with_last_segs(|i| {
301                            for seg in last_line.segs() {
302                                i.push(InlineSegment::new(seg.advance(), seg.kind()));
303                            }
304                        })
305                    } else {
306                        inline.last = PxSize::zero();
307                        inline.with_last_segs(|i| i.clear());
308                    }
309
310                    inline.first_wrapped = ctx.shaped_text.first_wrapped();
311                    inline.last_wrapped = ctx.shaped_text.lines_len() > 1;
312                }
313                size
314            };
315
316            LAYOUT.with_constraints(metrics.constraints().with_new_min_size(*desired_size), || {
317                // foreign nodes in the CHILD_LAYOUT+100 ..= CHILD range may change the size
318                *desired_size = child.measure(wm);
319            });
320        }
321        UiNodeOp::Layout { wl, final_size } => {
322            child.delegated();
323
324            let metrics = LAYOUT.metrics();
325
326            TEXT.layout().viewport = metrics.viewport();
327
328            *final_size = txt.layout(&metrics, false);
329
330            if txt.pending != PendingLayout::empty() {
331                WIDGET.render();
332                txt.pending = PendingLayout::empty();
333            }
334
335            if let Some(inline) = wl.inline() {
336                let ctx = TEXT.laidout();
337
338                let last_line = ctx.shaped_text.lines_len().saturating_sub(1);
339
340                inline.first_segs.clear();
341                inline.last_segs.clear();
342
343                for (i, line) in ctx.shaped_text.lines().enumerate() {
344                    if i == 0 {
345                        let info = ctx.shaped_text.line(0).unwrap().segs().map(|s| s.inline_info());
346                        if LAYOUT.direction().is_rtl() {
347                            // help sort
348                            inline.set_first_segs(info.rev());
349                        } else {
350                            inline.set_first_segs(info);
351                        }
352                    } else if i == last_line {
353                        let info = ctx
354                            .shaped_text
355                            .line(ctx.shaped_text.lines_len().saturating_sub(1))
356                            .unwrap()
357                            .segs()
358                            .map(|s| s.inline_info());
359                        if LAYOUT.direction().is_rtl() {
360                            // help sort
361                            inline.set_last_segs(info.rev());
362                        } else {
363                            inline.set_last_segs(info);
364                        }
365                    }
366
367                    inline.rows.push(line.rect());
368                }
369            }
370
371            wl.set_baseline(txt.baseline);
372
373            LAYOUT.with_constraints(metrics.constraints().with_new_min_size(*final_size), || {
374                // foreign nodes in the CHILD_LAYOUT+100 ..= CHILD range may change the size
375                *final_size = child.layout(wl);
376            });
377        }
378        UiNodeOp::Render { .. } => {
379            txt.ensure_layout_for_render();
380        }
381        UiNodeOp::RenderUpdate { .. } => {
382            txt.ensure_layout_for_render();
383        }
384        _ => {}
385    })
386}
387struct LayoutTextFinal {
388    shaping_args: TextShapingArgs,
389    pending: PendingLayout,
390
391    txt_is_measured: bool,
392    last_layout: (LayoutMetrics, Option<InlineConstraintsMeasure>),
393    baseline: Px,
394}
395impl LayoutTextFinal {
396    /// Fast measure.
397    ///
398    /// If the metrics fully define the size the text does not need to be shaped.
399    fn measure(&mut self, metrics: &LayoutMetrics) -> Option<PxSize> {
400        if metrics.inline_constraints().is_some() {
401            return None;
402        }
403
404        metrics.constraints().fill_or_exact()
405    }
406
407    /// Slow measure/layout.
408    ///
409    /// If `is_measure` the text will be reshaped just like layout, it only skips render only state update.
410    /// Text shaping is state heavy and there is significant perf gains for caching and "reshaping", reusing
411    /// the same layout state for measure is the least bad option as it does not cause allocation and full shaping.
412    ///
413    /// Because measure affects the state the `ensure_layout_for_render` method must be called because the measure API
414    /// is not supposed to change state a parent panel can measure and discard the results and go directly to render, expecting
415    /// the widget to still have the last layout state.
416    fn layout(&mut self, metrics: &LayoutMetrics, is_measure: bool) -> PxSize {
417        let mut resolved = TEXT.resolved();
418
419        self.pending |= resolved.pending_layout;
420
421        let font_size = metrics.font_size();
422
423        let mut ctx = TEXT.layout();
424
425        if font_size != ctx.fonts.requested_size() || !ctx.fonts.is_sized_from(&resolved.faces) {
426            ctx.fonts = resolved.faces.sized(font_size, FONT_VARIATIONS_VAR.with(FontVariations::finalize));
427            self.pending.insert(PendingLayout::RESHAPE);
428        }
429
430        if TEXT_WRAP_VAR.get() && !metrics.constraints().x.is_unbounded() {
431            let max_width = metrics.constraints().x.max().unwrap();
432            if self.shaping_args.max_width != max_width {
433                self.shaping_args.max_width = max_width;
434
435                if !self.pending.contains(PendingLayout::RESHAPE) && ctx.shaped_text.can_rewrap(max_width) {
436                    self.pending.insert(PendingLayout::RESHAPE);
437                }
438            }
439        } else if self.shaping_args.max_width != Px::MAX {
440            self.shaping_args.max_width = Px::MAX;
441            if !self.pending.contains(PendingLayout::RESHAPE) && ctx.shaped_text.can_rewrap(Px::MAX) {
442                self.pending.insert(PendingLayout::RESHAPE);
443            }
444        }
445
446        if ctx.caret_origin.is_none() {
447            self.pending.insert(PendingLayout::CARET);
448        }
449
450        if let Some(inline) = metrics.inline_constraints() {
451            match inline {
452                InlineConstraints::Measure(m) => {
453                    if self.shaping_args.inline_constraints != Some(m) {
454                        self.shaping_args.inline_constraints = Some(m);
455                        self.pending.insert(PendingLayout::RESHAPE);
456                    }
457                }
458                InlineConstraints::Layout(l) => {
459                    if !self.pending.contains(PendingLayout::RESHAPE)
460                        && (Some(l.first_segs.len()) != ctx.shaped_text.line(0).map(|l| l.segs_len())
461                            || Some(l.last_segs.len())
462                                != ctx
463                                    .shaped_text
464                                    .line(ctx.shaped_text.lines_len().saturating_sub(1))
465                                    .map(|l| l.segs_len()))
466                    {
467                        self.pending.insert(PendingLayout::RESHAPE);
468                    }
469
470                    if !self.pending.contains(PendingLayout::RESHAPE_LINES)
471                        && (ctx.shaped_text.mid_clear() != l.mid_clear
472                            || ctx.shaped_text.line(0).map(|l| l.rect()) != Some(l.first)
473                            || ctx
474                                .shaped_text
475                                .line(ctx.shaped_text.lines_len().saturating_sub(1))
476                                .map(|l| l.rect())
477                                != Some(l.last))
478                    {
479                        self.pending.insert(PendingLayout::RESHAPE_LINES);
480                    }
481                }
482            }
483        } else if self.shaping_args.inline_constraints.is_some() {
484            self.shaping_args.inline_constraints = None;
485            self.pending.insert(PendingLayout::RESHAPE);
486        }
487
488        if !self.pending.contains(PendingLayout::RESHAPE_LINES) {
489            let size = ctx.shaped_text.size();
490            if metrics.constraints().fill_size_or(size) != ctx.shaped_text.align_size() {
491                self.pending.insert(PendingLayout::RESHAPE_LINES);
492            }
493        }
494
495        let font = ctx.fonts.best();
496
497        let space_len = font.space_x_advance();
498        let dft_tab_len = space_len * 3;
499
500        let (letter_spacing, word_spacing, tab_length, paragraph_indent) = {
501            LAYOUT.with_constraints(PxConstraints2d::new_exact(space_len, space_len), || {
502                (
503                    LETTER_SPACING_VAR.layout_x(),
504                    WORD_SPACING_VAR.layout_x(),
505                    TAB_LENGTH_VAR.layout_dft_x(dft_tab_len),
506                    PARAGRAPH_INDENT_VAR.with(|i| i.spacing.layout_x()),
507                )
508            })
509        };
510        let paragraph_indent = (paragraph_indent, PARAGRAPH_INDENT_VAR.with(|i| i.invert));
511
512        let dft_line_height = font.metrics().line_height();
513        let line_height = LAYOUT.with_constraints(PxConstraints2d::new_exact(dft_line_height, dft_line_height), || {
514            LINE_HEIGHT_VAR.layout_dft_y(dft_line_height)
515        });
516        let line_spacing = LAYOUT.with_constraints(PxConstraints2d::new_exact(line_height, line_height), || LINE_SPACING_VAR.layout_y());
517
518        let paragraph_spacing = LAYOUT.with_constraints(PxConstraints2d::new_exact(line_height, line_height), || {
519            PARAGRAPH_SPACING_VAR.layout_y()
520        });
521
522        if !self.pending.contains(PendingLayout::RESHAPE)
523            && (letter_spacing != self.shaping_args.letter_spacing
524                || word_spacing != self.shaping_args.word_spacing
525                || tab_length != self.shaping_args.tab_x_advance
526                || paragraph_indent != self.shaping_args.paragraph_indent)
527        {
528            self.pending.insert(PendingLayout::RESHAPE);
529        }
530        if !self.pending.contains(PendingLayout::RESHAPE_LINES)
531            && (line_spacing != self.shaping_args.line_spacing
532                || line_height != self.shaping_args.line_height
533                || paragraph_spacing != self.shaping_args.paragraph_spacing)
534        {
535            self.pending.insert(PendingLayout::RESHAPE_LINES);
536        }
537
538        self.shaping_args.letter_spacing = letter_spacing;
539        self.shaping_args.word_spacing = word_spacing;
540        self.shaping_args.tab_x_advance = tab_length;
541        self.shaping_args.line_height = line_height;
542        self.shaping_args.line_spacing = line_spacing;
543        self.shaping_args.paragraph_spacing = paragraph_spacing;
544        self.shaping_args.paragraph_indent = paragraph_indent;
545
546        let dft_thickness = font.metrics().underline_thickness;
547        let (overline, strikethrough, underline, ime_underline) = {
548            LAYOUT.with_constraints(PxConstraints2d::new_exact(line_height, line_height), || {
549                (
550                    OVERLINE_THICKNESS_VAR.layout_dft_y(dft_thickness),
551                    STRIKETHROUGH_THICKNESS_VAR.layout_dft_y(dft_thickness),
552                    UNDERLINE_THICKNESS_VAR.layout_dft_y(dft_thickness),
553                    IME_UNDERLINE_THICKNESS_VAR.layout_dft_y(dft_thickness),
554                )
555            })
556        };
557
558        if !self.pending.contains(PendingLayout::OVERLINE) && (ctx.overline_thickness == 0) != (overline == 0) {
559            self.pending.insert(PendingLayout::OVERLINE);
560        }
561        if !self.pending.contains(PendingLayout::STRIKETHROUGH) && (ctx.strikethrough_thickness == 0) != (strikethrough == 0) {
562            self.pending.insert(PendingLayout::STRIKETHROUGH);
563        }
564        if !self.pending.contains(PendingLayout::UNDERLINE)
565            && ((ctx.underline_thickness == 0) != (underline == 0) || (ctx.ime_underline_thickness != 0) != (ime_underline != 0))
566        {
567            self.pending.insert(PendingLayout::UNDERLINE);
568        }
569        ctx.overline_thickness = overline;
570        ctx.strikethrough_thickness = strikethrough;
571        ctx.underline_thickness = underline;
572        ctx.ime_underline_thickness = ime_underline;
573
574        let align = TEXT_ALIGN_VAR.get();
575        let justify = JUSTIFY_MODE_VAR.get();
576        let overflow_align = TEXT_OVERFLOW_ALIGN_VAR.get();
577        if !self.pending.contains(PendingLayout::RESHAPE_LINES)
578            && (align != ctx.shaped_text.align()
579                || justify != ctx.shaped_text.justify_mode().unwrap_or_default()
580                || overflow_align != ctx.shaped_text.overflow_align())
581        {
582            self.pending.insert(PendingLayout::RESHAPE_LINES);
583        }
584
585        /*
586            APPLY
587        */
588
589        if self.pending.contains(PendingLayout::RESHAPE) {
590            ctx.shaped_text = ctx.fonts.shape_text(&resolved.segmented_text, &self.shaping_args);
591            self.pending = self.pending.intersection(PendingLayout::RESHAPE_LINES);
592        }
593
594        if !self.pending.contains(PendingLayout::RESHAPE_LINES)
595            && ctx.shaped_text.align_size() != metrics.constraints().fill_size_or(ctx.shaped_text.block_size())
596        {
597            self.pending.insert(PendingLayout::RESHAPE_LINES);
598        }
599
600        if self.pending.contains(PendingLayout::RESHAPE_LINES) && metrics.inline_constraints().is_none() {
601            // Affects block size in measure too
602            //
603            // This breaks inline context, so it is avoided here and called later in the `if !is_measure` block.
604            // This is needed to measure the same block size a layout call would output.
605            //
606            // Not sure if it is a bug that it does not work inlining, but it is not needed there anyway, so for now
607            // this fix is sufficient.
608            let mut args = TextReshapingArgs::default();
609            args.constraints = metrics.constraints();
610            args.inline_constraints = metrics.inline_constraints().map(|c| c.layout());
611            args.align = align;
612            args.overflow_align = overflow_align;
613            args.direction = metrics.direction();
614            args.line_height = line_height;
615            args.line_spacing = line_spacing;
616            args.paragraph_spacing = paragraph_spacing;
617            args.paragraph_indent = paragraph_indent;
618            args.paragraph_break = PARAGRAPH_BREAK_VAR.get();
619            ctx.shaped_text.reshape_lines(&args);
620        }
621
622        if !is_measure {
623            self.last_layout = (metrics.clone(), self.shaping_args.inline_constraints);
624
625            if self.pending.contains(PendingLayout::RESHAPE_LINES) {
626                if metrics.inline_constraints().is_some() {
627                    // when inlining, only reshape lines in layout passes
628                    let mut args = TextReshapingArgs::default();
629                    args.constraints = metrics.constraints();
630                    args.inline_constraints = metrics.inline_constraints().map(|c| c.layout());
631                    args.align = align;
632                    args.overflow_align = overflow_align;
633                    args.direction = metrics.direction();
634                    args.line_height = line_height;
635                    args.line_spacing = line_spacing;
636                    args.paragraph_spacing = paragraph_spacing;
637                    args.paragraph_indent = paragraph_indent;
638                    args.paragraph_break = PARAGRAPH_BREAK_VAR.get();
639                    ctx.shaped_text.reshape_lines(&args);
640                }
641                ctx.shaped_text.reshape_lines_justify(justify, &self.shaping_args.lang);
642
643                ctx.shaped_text_version = ctx.shaped_text_version.wrapping_add(1);
644                drop(resolved);
645                self.baseline = ctx.shaped_text.baseline();
646                resolved = TEXT.resolved();
647                ctx.caret_origin = None;
648                ctx.caret_selection_origin = None;
649            }
650            if self.pending.contains(PendingLayout::OVERFLOW) {
651                let txt_size = ctx.shaped_text.size();
652                let max_size = metrics.constraints().fill_size_or(txt_size);
653                if txt_size.width > max_size.width || txt_size.height > max_size.height {
654                    let suf_width = ctx.overflow_suffix.as_ref().map(|s| s.size().width).unwrap_or(Px(0));
655                    ctx.overflow = ctx.shaped_text.overflow_info(max_size, suf_width);
656
657                    if ctx.overflow.is_some() && ctx.overflow_suffix.is_none() && !TEXT_EDITABLE_VAR.get() {
658                        match TEXT_OVERFLOW_VAR.get() {
659                            TextOverflow::Truncate(suf) if !suf.is_empty() => {
660                                let suf = SegmentedText::new(suf, self.shaping_args.direction);
661                                let suf = ctx.fonts.shape_text(&suf, &self.shaping_args);
662
663                                ctx.overflow = ctx.shaped_text.overflow_info(max_size, suf.size().width);
664                                ctx.overflow_suffix = Some(suf);
665                            }
666                            _ => {}
667                        }
668                    }
669                } else {
670                    ctx.overflow = None;
671                }
672            }
673            if self.pending.contains(PendingLayout::OVERLINE) {
674                if ctx.overline_thickness > Px(0) {
675                    ctx.overlines = ctx.shaped_text.lines().map(|l| l.overline()).collect();
676                } else {
677                    ctx.overlines = vec![];
678                }
679            }
680            if self.pending.contains(PendingLayout::STRIKETHROUGH) {
681                if ctx.strikethrough_thickness > Px(0) {
682                    ctx.strikethroughs = ctx.shaped_text.lines().map(|l| l.strikethrough()).collect();
683                } else {
684                    ctx.strikethroughs = vec![];
685                }
686            }
687
688            if self.pending.contains(PendingLayout::UNDERLINE) {
689                let ime_range = if let Some(ime) = &resolved.ime_preview {
690                    let start = ime.prev_selection.unwrap_or(ime.prev_caret).index.min(ime.prev_caret.index);
691                    start..start + ime.txt.len()
692                } else {
693                    0..0
694                };
695                let caret_ime_range = if !ime_range.is_empty() && (ctx.underline_thickness > Px(0) || ctx.ime_underline_thickness > Px(0)) {
696                    let start = ctx.shaped_text.snap_caret_line(CaretIndex {
697                        index: ime_range.start,
698                        line: 0,
699                    });
700                    let end = ctx.shaped_text.snap_caret_line(CaretIndex {
701                        index: ime_range.end,
702                        line: 0,
703                    });
704
705                    start..end
706                } else {
707                    CaretIndex::ZERO..CaretIndex::ZERO
708                };
709
710                if ctx.underline_thickness > Px(0) {
711                    let mut underlines = vec![];
712
713                    let skip = UNDERLINE_SKIP_VAR.get();
714                    match UNDERLINE_POSITION_VAR.get() {
715                        UnderlinePosition::Font => {
716                            if skip == UnderlineSkip::GLYPHS | UnderlineSkip::SPACES {
717                                for line in ctx.shaped_text.lines() {
718                                    for und in line.underline_skip_glyphs_and_spaces(ctx.underline_thickness) {
719                                        underlines.push(und);
720                                    }
721                                }
722                            } else if skip.contains(UnderlineSkip::GLYPHS) {
723                                for line in ctx.shaped_text.lines() {
724                                    for und in line.underline_skip_glyphs(ctx.underline_thickness) {
725                                        underlines.push(und);
726                                    }
727                                }
728                            } else if skip.contains(UnderlineSkip::SPACES) {
729                                for line in ctx.shaped_text.lines() {
730                                    for und in line.underline_skip_spaces() {
731                                        underlines.push(und);
732                                    }
733                                }
734                            } else {
735                                for line in ctx.shaped_text.lines() {
736                                    let und = line.underline();
737                                    underlines.push(und);
738                                }
739                            }
740                        }
741                        UnderlinePosition::Descent => {
742                            // descent clears all glyphs, so we only need to care about spaces
743                            if skip.contains(UnderlineSkip::SPACES) {
744                                for line in ctx.shaped_text.lines() {
745                                    for und in line.underline_descent_skip_spaces() {
746                                        underlines.push(und);
747                                    }
748                                }
749                            } else {
750                                for line in ctx.shaped_text.lines() {
751                                    let und = line.underline_descent();
752                                    underlines.push(und);
753                                }
754                            }
755                        }
756                    }
757
758                    if !ime_range.is_empty() {
759                        underlines = ctx.shaped_text.clip_lines(
760                            caret_ime_range.clone(),
761                            true,
762                            resolved.segmented_text.text(),
763                            underlines.into_iter(),
764                        );
765                    }
766
767                    ctx.underlines = underlines;
768                } else {
769                    ctx.underlines = vec![];
770                }
771
772                if ctx.ime_underline_thickness > Px(0) && !ime_range.is_empty() {
773                    let mut ime_underlines = vec![];
774
775                    // collects underlines for all segments that intersect with the IME text.
776                    for line in ctx.shaped_text.lines() {
777                        let line_range = line.text_range();
778                        if line_range.start < ime_range.end && line_range.end > ime_range.start {
779                            for seg in line.segs() {
780                                let seg_range = seg.text_range();
781                                if seg_range.start < ime_range.end && seg_range.end > ime_range.start {
782                                    for und in seg.underline_skip_glyphs(ctx.ime_underline_thickness) {
783                                        ime_underlines.push(und);
784                                    }
785                                }
786                            }
787                        }
788                    }
789
790                    ctx.ime_underlines =
791                        ctx.shaped_text
792                            .clip_lines(caret_ime_range, false, resolved.segmented_text.text(), ime_underlines.into_iter());
793                } else {
794                    ctx.ime_underlines = vec![];
795                }
796            }
797
798            if self.pending.contains(PendingLayout::CARET) {
799                drop(resolved);
800                let mut resolved_mut = TEXT.resolve();
801                let resolved_mut = &mut *resolved_mut;
802                let caret = &mut resolved_mut.caret;
803                if let Some(index) = &mut caret.index {
804                    *index = ctx.shaped_text.snap_caret_line(*index);
805
806                    let p = ctx.shaped_text.caret_origin(*index, resolved_mut.segmented_text.text());
807                    if !caret.used_retained_x {
808                        ctx.caret_retained_x = p.x;
809                    }
810                    ctx.caret_origin = Some(p);
811
812                    if let Some(sel) = &mut caret.selection_index {
813                        *sel = ctx.shaped_text.snap_caret_line(*sel);
814                        ctx.caret_selection_origin = Some(ctx.shaped_text.caret_origin(*sel, resolved_mut.segmented_text.text()));
815                    }
816
817                    if !mem::take(&mut caret.skip_next_scroll)
818                        && SCROLL.try_id().is_some()
819                        && let Some(focused) = FOCUS.focused().get()
820                        && focused.contains(TEXT.try_rich().map(|r| r.root_id).unwrap_or_else(|| WIDGET.id()))
821                    {
822                        let line_height = ctx
823                            .shaped_text
824                            .line(index.line)
825                            .map(|l| l.rect().height())
826                            .unwrap_or_else(|| ctx.shaped_text.line_height());
827
828                        if let Some(p) = ctx.render_info.transform.transform_point(p) {
829                            let p = p - WIDGET.info().inner_bounds().origin;
830                            let min_rect = Rect::new(p.to_point(), Size::new(Px(1), line_height * 2 + ctx.shaped_text.line_spacing()));
831                            SCROLL.scroll_to(ScrollToMode::minimal_rect(min_rect));
832                        }
833                    }
834                }
835            }
836
837            // self.pending is cleared in the node layout, after this method call
838        }
839        self.txt_is_measured = is_measure;
840
841        metrics.constraints().inner().fill_size_or(ctx.shaped_text.size())
842    }
843
844    /// See `layout` docs.
845    fn ensure_layout_for_render(&mut self) {
846        if self.txt_is_measured {
847            let metrics = self.last_layout.0.clone();
848            self.shaping_args.inline_constraints = self.last_layout.1;
849            LAYOUT.with_context(metrics.clone(), || {
850                self.layout(&metrics, false);
851            });
852
853            debug_assert!(!self.txt_is_measured);
854        }
855    }
856}
857
858fn layout_text_edit(child: impl IntoUiNode) -> UiNode {
859    // Use `LayoutTextEdit::get` to access.
860    let mut edit = None::<Box<LayoutTextEdit>>;
861
862    match_node(child, move |child, op| {
863        let mut enable = false;
864        match op {
865            UiNodeOp::Init => {
866                child.init(); // let other nodes subscribe to events first (needed for `only_alt_...`)
867                enable = TEXT_EDITABLE_VAR.get() || TEXT_SELECTABLE_VAR.get();
868            }
869            UiNodeOp::Deinit => {
870                edit = None;
871            }
872            UiNodeOp::Info { info } => {
873                if let Some(e) = &edit {
874                    info.set_ime_area(e.ime_area.clone());
875                }
876            }
877            UiNodeOp::Update { .. } => {
878                if TEXT_EDITABLE_VAR.is_new() || TEXT_SELECTABLE_VAR.is_new() {
879                    enable = TEXT_EDITABLE_VAR.get() || TEXT_SELECTABLE_VAR.get();
880                    if !enable && edit.is_some() {
881                        edit = None;
882                    }
883                } else if let Some(edit) = &edit {
884                    TEXT.resolved().txt.with_new(|t| {
885                        edit.select_all.enabled().set(!t.is_empty());
886                    });
887                }
888
889                if (OBSCURE_TXT_VAR.is_new() || OBSCURING_CHAR_VAR.is_new())
890                    && let Some(obscure) = OBSCURE_TXT_VAR.get_new()
891                {
892                    if edit.is_none() && WINDOW.info().access_enabled().is_enabled() {
893                        WIDGET.update_info();
894                    }
895
896                    if obscure {
897                        UNDO.clear();
898                    }
899                }
900
901                if let Some(e) = &mut edit {
902                    layout_text_edit_events(e);
903                }
904            }
905            UiNodeOp::Render { frame } => {
906                child.render(frame);
907                if let Some(e) = &edit {
908                    e.update_ime(&mut TEXT.layout());
909                }
910            }
911            UiNodeOp::RenderUpdate { update } => {
912                child.render_update(update);
913                if let Some(e) = &edit {
914                    e.update_ime(&mut TEXT.layout());
915                }
916            }
917            _ => {}
918        }
919
920        if enable {
921            let edit = LayoutTextEdit::get(&mut edit);
922
923            let editable = TEXT_EDITABLE_VAR.get();
924            let selectable = TEXT_SELECTABLE_VAR.get();
925
926            if selectable || editable {
927                let id = WIDGET.id();
928
929                edit.events[0] = MOUSE_INPUT_EVENT.subscribe(UpdateOp::Update, id);
930                edit.events[1] = TOUCH_TAP_EVENT.subscribe(UpdateOp::Update, id);
931                edit.events[2] = TOUCH_LONG_PRESS_EVENT.subscribe(UpdateOp::Update, id);
932                edit.events[3] = TOUCH_INPUT_EVENT.subscribe(UpdateOp::Update, id);
933                // KEY_INPUT_EVENT subscribed by `resolve_text`.
934            } else {
935                edit.events = Default::default();
936            }
937
938            if selectable {
939                let id = WIDGET.id();
940
941                edit.select = SELECT_CMD.scoped(id).subscribe(true);
942                let is_empty = TEXT.resolved().txt.with(|t| t.is_empty());
943                edit.select_all = SELECT_ALL_CMD.scoped(id).subscribe(!is_empty);
944            } else {
945                edit.select = Default::default();
946                edit.select_all = Default::default();
947            }
948        }
949    })
950}
951/// Data allocated only when `editable`.
952#[derive(Default)]
953struct LayoutTextEdit {
954    events: [VarHandle; 4],
955    caret_animation: VarHandle,
956    select: CommandHandle,
957    select_all: CommandHandle,
958    ime_area: Arc<Atomic<PxRect>>,
959    click_count: u8,
960    selection_mouse_down: Option<SelectionMouseDown>,
961    auto_select: bool,
962    selection_move_handles: VarHandles,
963    selection_started_by_alt: bool,
964}
965struct SelectionMouseDown {
966    position: DipPoint,
967    timestamp: DInstant,
968    count: u8,
969}
970impl LayoutTextEdit {
971    fn get(edit_data: &mut Option<Box<Self>>) -> &mut Self {
972        &mut *edit_data.get_or_insert_with(Default::default)
973    }
974
975    fn update_ime(&self, txt: &mut LaidoutText) {
976        let transform = txt.render_info.transform;
977        let area;
978
979        if let Some(a) = txt.caret_origin {
980            let (ac, bc) = {
981                let ctx = TEXT.resolved();
982                let c = &ctx.caret;
983                (c.index, c.selection_index)
984            };
985            let ac = ac.unwrap_or(CaretIndex::ZERO);
986            let mut a_line = PxRect::new(a, PxSize::new(Px(1), txt.shaped_text.line(ac.line).unwrap().height())).to_box2d();
987
988            if let Some(b) = txt.caret_selection_origin {
989                let bc = bc.unwrap_or(CaretIndex::ZERO);
990                let b_line = PxRect::new(b, PxSize::new(Px(1), txt.shaped_text.line(bc.line).unwrap().height())).to_box2d();
991
992                a_line.min = a_line.min.min(b_line.min);
993                a_line.max = a_line.max.min(b_line.max);
994            }
995            area = a_line;
996        } else {
997            area = PxBox::from_size(txt.shaped_text.size());
998        }
999
1000        if let Some(area) = transform.outer_transformed(area) {
1001            self.ime_area.store(area.to_rect(), atomic::Ordering::Relaxed);
1002        }
1003    }
1004}
1005
1006fn layout_text_edit_events(edit: &mut LayoutTextEdit) {
1007    let resolved = TEXT.resolved();
1008    let editable = TEXT_EDITABLE_VAR.get() && resolved.txt.capabilities().can_modify();
1009    let selectable = TEXT_SELECTABLE_VAR.get();
1010
1011    if !editable && !selectable {
1012        return;
1013    }
1014    let widget = WIDGET.info();
1015    if !widget.interactivity().is_enabled() {
1016        return;
1017    }
1018
1019    let selectable_alt_only = selectable && !editable && TEXT_SELECTABLE_ALT_ONLY_VAR.get();
1020
1021    let prev_caret_index = {
1022        let caret = &resolved.caret;
1023        (caret.index, caret.index_version, caret.selection_index)
1024    };
1025    drop(resolved);
1026
1027    KEY_INPUT_EVENT.each_update(false, |args| {
1028        if args.state == KeyState::Pressed {
1029            if args.target.widget_id() == widget.id() {
1030                match &args.key {
1031                    Key::ArrowRight => {
1032                        let mut modifiers = args.modifiers;
1033                        let select = selectable && modifiers.take_shift();
1034                        let word = modifiers.take_ctrl();
1035                        if modifiers.is_empty() && (editable || select) {
1036                            args.propagation.stop();
1037
1038                            TEXT.resolve().selection_by = SelectionBy::Keyboard;
1039
1040                            if select {
1041                                if word {
1042                                    TextSelectOp::select_next_word()
1043                                } else {
1044                                    TextSelectOp::select_next()
1045                                }
1046                            } else if word {
1047                                TextSelectOp::next_word()
1048                            } else {
1049                                TextSelectOp::next()
1050                            }
1051                            .call();
1052                        }
1053                    }
1054                    Key::ArrowLeft => {
1055                        let mut modifiers = args.modifiers;
1056                        let select = selectable && modifiers.take_shift();
1057                        let word = modifiers.take_ctrl();
1058                        if modifiers.is_empty() && (editable || select) {
1059                            args.propagation.stop();
1060
1061                            TEXT.resolve().selection_by = SelectionBy::Keyboard;
1062
1063                            if select {
1064                                if word {
1065                                    TextSelectOp::select_prev_word()
1066                                } else {
1067                                    TextSelectOp::select_prev()
1068                                }
1069                            } else if word {
1070                                TextSelectOp::prev_word()
1071                            } else {
1072                                TextSelectOp::prev()
1073                            }
1074                            .call();
1075                        }
1076                    }
1077                    Key::ArrowUp => {
1078                        if ACCEPTS_ENTER_VAR.get() || TEXT.laidout().shaped_text.lines_len() > 1 || TEXT.try_rich().is_some() {
1079                            let mut modifiers = args.modifiers;
1080                            let select = selectable && modifiers.take_shift();
1081                            if modifiers.is_empty() && (editable || select) {
1082                                args.propagation.stop();
1083
1084                                TEXT.resolve().selection_by = SelectionBy::Keyboard;
1085
1086                                if select {
1087                                    TextSelectOp::select_line_up()
1088                                } else {
1089                                    TextSelectOp::line_up()
1090                                }
1091                                .call();
1092                            }
1093                        }
1094                    }
1095                    Key::ArrowDown => {
1096                        if ACCEPTS_ENTER_VAR.get() || TEXT.laidout().shaped_text.lines_len() > 1 || TEXT.try_rich().is_some() {
1097                            let mut modifiers = args.modifiers;
1098                            let select = selectable && modifiers.take_shift();
1099                            if modifiers.is_empty() && (editable || select) {
1100                                args.propagation.stop();
1101
1102                                TEXT.resolve().selection_by = SelectionBy::Keyboard;
1103
1104                                if select {
1105                                    TextSelectOp::select_line_down()
1106                                } else {
1107                                    TextSelectOp::line_down()
1108                                }
1109                                .call();
1110                            }
1111                        }
1112                    }
1113                    Key::PageUp => {
1114                        if ACCEPTS_ENTER_VAR.get() || TEXT.laidout().shaped_text.lines_len() > 1 || TEXT.try_rich().is_some() {
1115                            let mut modifiers = args.modifiers;
1116                            let select = selectable && modifiers.take_shift();
1117                            if modifiers.is_empty() && (editable || select) {
1118                                args.propagation.stop();
1119
1120                                TEXT.resolve().selection_by = SelectionBy::Keyboard;
1121
1122                                if select {
1123                                    TextSelectOp::select_page_up()
1124                                } else {
1125                                    TextSelectOp::page_up()
1126                                }
1127                                .call();
1128                            }
1129                        }
1130                    }
1131                    Key::PageDown => {
1132                        if ACCEPTS_ENTER_VAR.get() || TEXT.laidout().shaped_text.lines_len() > 1 || TEXT.try_rich().is_some() {
1133                            let mut modifiers = args.modifiers;
1134                            let select = selectable && modifiers.take_shift();
1135                            if modifiers.is_empty() && (editable || select) {
1136                                args.propagation.stop();
1137
1138                                TEXT.resolve().selection_by = SelectionBy::Keyboard;
1139
1140                                if select {
1141                                    TextSelectOp::select_page_down()
1142                                } else {
1143                                    TextSelectOp::page_down()
1144                                }
1145                                .call();
1146                            }
1147                        }
1148                    }
1149                    Key::Home => {
1150                        let mut modifiers = args.modifiers;
1151                        let select = selectable && modifiers.take_shift();
1152                        let full_text = modifiers.take_ctrl();
1153                        if modifiers.is_empty() && (editable || select) {
1154                            args.propagation.stop();
1155
1156                            TEXT.resolve().selection_by = SelectionBy::Keyboard;
1157
1158                            if select {
1159                                if full_text {
1160                                    TextSelectOp::select_text_start()
1161                                } else {
1162                                    TextSelectOp::select_line_start()
1163                                }
1164                            } else if full_text {
1165                                TextSelectOp::text_start()
1166                            } else {
1167                                TextSelectOp::line_start()
1168                            }
1169                            .call();
1170                        }
1171                    }
1172                    Key::End => {
1173                        let mut modifiers = args.modifiers;
1174                        let select = selectable && modifiers.take_shift();
1175                        let full_text = modifiers.take_ctrl();
1176                        if modifiers.is_empty() && (editable || select) {
1177                            args.propagation.stop();
1178
1179                            TEXT.resolve().selection_by = SelectionBy::Keyboard;
1180
1181                            if select {
1182                                if full_text {
1183                                    TextSelectOp::select_text_end()
1184                                } else {
1185                                    TextSelectOp::select_line_end()
1186                                }
1187                            } else if full_text {
1188                                TextSelectOp::text_end()
1189                            } else {
1190                                TextSelectOp::line_end()
1191                            }
1192                            .call();
1193                        }
1194                    }
1195                    Key::Escape => {
1196                        if args.modifiers.is_empty() && (editable || selectable) {
1197                            args.propagation.stop();
1198                            TEXT.resolve().selection_by = SelectionBy::Keyboard;
1199
1200                            TextSelectOp::clear_selection().call();
1201                        }
1202                    }
1203                    _ => {}
1204                }
1205            }
1206        } else if let Key::Alt | Key::AltGraph = &args.key {
1207            if TEXT.try_rich().is_some() {
1208                if TEXT.take_rich_selection_started_by_alt() {
1209                    args.propagation.stop();
1210                }
1211            } else if mem::take(&mut edit.selection_started_by_alt) {
1212                args.propagation.stop();
1213            }
1214        }
1215    });
1216    MOUSE_INPUT_EVENT.each_update(true, |args| {
1217        if args.is_primary() && args.is_mouse_down() && args.target.widget_id() == widget.id() {
1218            let mut modifiers = args.modifiers;
1219            let alt = modifiers.take_alt();
1220            let select = selectable && modifiers.take_shift();
1221
1222            if modifiers.is_empty() && (!selectable_alt_only || alt) {
1223                args.propagation.stop();
1224                TEXT.resolve().selection_by = SelectionBy::Mouse;
1225                if alt {
1226                    if TEXT.try_rich().is_some() {
1227                        TEXT.flag_rich_selection_started_by_alt();
1228                    } else {
1229                        edit.selection_started_by_alt = true;
1230                    }
1231                }
1232
1233                edit.click_count = if let Some(info) = &mut edit.selection_mouse_down {
1234                    let cfg = MOUSE.multi_click_config().get();
1235
1236                    let double_allowed = args.timestamp.duration_since(info.timestamp) <= cfg.time && {
1237                        let dist = (info.position.to_vector() - args.position.to_vector()).abs();
1238                        let area = cfg.area;
1239                        dist.x <= area.width && dist.y <= area.height
1240                    };
1241
1242                    if double_allowed {
1243                        info.timestamp = args.timestamp;
1244                        info.count += 1;
1245                        info.count = info.count.min(4);
1246                    } else {
1247                        *info = SelectionMouseDown {
1248                            position: args.position,
1249                            timestamp: args.timestamp,
1250                            count: 1,
1251                        };
1252                    }
1253
1254                    info.count
1255                } else {
1256                    edit.selection_mouse_down = Some(SelectionMouseDown {
1257                        position: args.position,
1258                        timestamp: args.timestamp,
1259                        count: 1,
1260                    });
1261                    1
1262                };
1263
1264                match edit.click_count {
1265                    1 => {
1266                        if select {
1267                            TextSelectOp::select_nearest_to(args.position).call()
1268                        } else {
1269                            TextSelectOp::nearest_to(args.position).call();
1270
1271                            // select all on mouse-up if only acquire focus
1272                            edit.auto_select = selectable
1273                                && AUTO_SELECTION_VAR.get().contains(AutoSelection::ALL_ON_FOCUS_POINTER)
1274                                && !FOCUS.is_focused(widget.id()).get()
1275                                && TEXT.resolved().caret.selection_range().is_none();
1276                        }
1277                    }
1278                    2 => {
1279                        if selectable {
1280                            TextSelectOp::select_word_nearest_to(!select, args.position).call()
1281                        }
1282                    }
1283                    3 => {
1284                        if selectable {
1285                            TextSelectOp::select_line_nearest_to(!select, args.position).call()
1286                        }
1287                    }
1288                    4 => {
1289                        if selectable {
1290                            TextSelectOp::select_all().call()
1291                        }
1292                    }
1293                    _ => unreachable!(),
1294                };
1295                if selectable {
1296                    let id = widget.id();
1297                    edit.selection_move_handles.push(MOUSE_MOVE_EVENT.subscribe(UpdateOp::Update, id));
1298                    edit.selection_move_handles
1299                        .push(POINTER_CAPTURE_EVENT.subscribe(UpdateOp::Update, id));
1300                    POINTER_CAPTURE.capture_widget(id);
1301                }
1302            }
1303        } else {
1304            if mem::take(&mut edit.auto_select)
1305                && selectable
1306                && AUTO_SELECTION_VAR.get().contains(AutoSelection::ALL_ON_FOCUS_POINTER)
1307                && args.is_primary()
1308                && args.is_mouse_up()
1309                && FOCUS.is_focused(widget.id()).get()
1310                && TEXT.resolved().caret.selection_range().is_none()
1311            {
1312                TextSelectOp::select_all().call()
1313            }
1314            edit.selection_move_handles.clear();
1315        }
1316    });
1317
1318    TOUCH_INPUT_EVENT.each_update(false, |args| {
1319        let mut modifiers = args.modifiers;
1320        let alt = modifiers.take_alt();
1321        if modifiers.is_empty() && (!selectable_alt_only || alt) && args.target.widget_id() == widget.id() {
1322            edit.auto_select = selectable
1323                && AUTO_SELECTION_VAR.get().contains(AutoSelection::ALL_ON_FOCUS_POINTER)
1324                && args.modifiers.is_empty()
1325                && args.is_touch_start()
1326                && !FOCUS.is_focused(widget.id()).get()
1327                && TEXT.resolved().caret.selection_range().is_none();
1328        }
1329    });
1330
1331    TOUCH_TAP_EVENT.each_update(false, |args| {
1332        let mut modifiers = args.modifiers;
1333        let alt = modifiers.take_alt();
1334        if modifiers.is_empty() && (!selectable_alt_only || alt) && args.target.widget_id() == widget.id() {
1335            args.propagation.stop();
1336
1337            TEXT.resolve().selection_by = SelectionBy::Touch;
1338            if alt {
1339                if TEXT.try_rich().is_some() {
1340                    TEXT.flag_rich_selection_started_by_alt();
1341                } else {
1342                    edit.selection_started_by_alt = true;
1343                }
1344            }
1345
1346            TextSelectOp::nearest_to(args.position).call();
1347
1348            if mem::take(&mut edit.auto_select)
1349                && selectable
1350                && AUTO_SELECTION_VAR.get().contains(AutoSelection::ALL_ON_FOCUS_POINTER)
1351                && FOCUS.is_focused(WIDGET.id()).get()
1352                && TEXT.resolved().caret.selection_range().is_none()
1353            {
1354                TextSelectOp::select_all().call()
1355            }
1356        }
1357    });
1358    TOUCH_LONG_PRESS_EVENT.each_update(false, |args| {
1359        let mut modifiers = args.modifiers;
1360        let alt = modifiers.take_alt();
1361        if modifiers.is_empty() && (!selectable_alt_only || alt) && selectable && args.target.widget_id() == widget.id() {
1362            args.propagation.stop();
1363
1364            TEXT.resolve().selection_by = SelectionBy::Touch;
1365            if alt {
1366                if TEXT.try_rich().is_some() {
1367                    TEXT.flag_rich_selection_started_by_alt();
1368                } else {
1369                    edit.selection_started_by_alt = true;
1370                }
1371            }
1372
1373            TextSelectOp::select_word_nearest_to(true, args.position).call();
1374        }
1375    });
1376    MOUSE_MOVE_EVENT.each_update(false, |args| {
1377        if !edit.selection_move_handles.is_dummy() && selectable {
1378            let handle = if let Some(rich_root_id) = TEXT.try_rich().map(|r| r.root_id) {
1379                args.target.contains(rich_root_id)
1380            } else {
1381                args.target.widget_id() == widget.id()
1382            };
1383
1384            if handle {
1385                args.propagation.stop();
1386
1387                match edit.click_count {
1388                    1 => TextSelectOp::select_nearest_to(args.position).call(),
1389                    2 => TextSelectOp::select_word_nearest_to(false, args.position).call(),
1390                    3 => TextSelectOp::select_line_nearest_to(false, args.position).call(),
1391                    4 => {}
1392                    _ => unreachable!(),
1393                }
1394            }
1395        }
1396    });
1397    POINTER_CAPTURE_EVENT.each_update(false, |args| {
1398        if args.is_lost(widget.id()) {
1399            edit.selection_move_handles.clear();
1400            edit.auto_select = false;
1401        }
1402    });
1403
1404    if selectable {
1405        SELECT_CMD.scoped(widget.id()).each_update(true, false, |args| {
1406            if let Some(op) = args.param::<TextSelectOp>() {
1407                args.propagation.stop();
1408                op.clone().call();
1409            }
1410        });
1411        SELECT_ALL_CMD.scoped(widget.id()).each_update(true, false, |args| {
1412            args.propagation.stop();
1413            TextSelectOp::select_all().call();
1414        });
1415    }
1416
1417    let mut resolve = TEXT.resolve();
1418    let caret = &mut resolve.caret;
1419    if (caret.index, caret.index_version, caret.selection_index) != prev_caret_index {
1420        if !editable || caret.index.is_none() || !FOCUS.is_focused(widget.id()).get() {
1421            edit.caret_animation = VarHandle::dummy();
1422            caret.opacity = var(0.fct()).read_only();
1423        } else {
1424            caret.opacity = KEYBOARD.caret_animation();
1425            edit.caret_animation = caret.opacity.subscribe(UpdateOp::RenderUpdate, widget.id());
1426        }
1427        resolve.pending_layout |= PendingLayout::CARET;
1428        WIDGET.layout(); // update caret_origin
1429    }
1430}
zng_wgt_text/node/layout.rs

zng_wgt_text/node/
layout.rs
