zng_wgt_text/node/
resolve.rs

Help
1use std::{borrow::Cow, num::Wrapping, sync::Arc};
2
3use parking_lot::RwLock;
4use zng_app::{
5    access::{ACCESS_SELECTION_EVENT, ACCESS_TEXT_EVENT},
6    event::{CommandHandle, EventHandle},
7    render::FontSynthesis,
8    update::{EventUpdate, UpdateOp},
9    widget::{
10        WIDGET,
11        info::INTERACTIVITY_CHANGED_EVENT,
12        node::{UiNode, UiNodeOp, match_node},
13    },
14    window::WINDOW,
15};
16use zng_ext_clipboard::{CLIPBOARD, COPY_CMD, CUT_CMD, PASTE_CMD};
17use zng_ext_font::{CaretIndex, FONT_CHANGED_EVENT, FONTS, FontFaceList, SegmentedText};
18use zng_ext_input::{
19    focus::{FOCUS, FOCUS_CHANGED_EVENT, FocusInfoBuilder, WidgetInfoFocusExt as _},
20    keyboard::{KEY_INPUT_EVENT, KEYBOARD},
21};
22use zng_ext_l10n::LANG_VAR;
23use zng_ext_undo::UNDO;
24use zng_ext_window::{IME_EVENT, WINDOW_Ext as _, WindowLoadingHandle, cmd::CANCEL_IME_CMD};
25use zng_layout::context::{DIRECTION_VAR, LayoutDirection};
26use zng_view_api::keyboard::{Key, KeyState};
27use zng_wgt::prelude::*;
28
29use crate::{
30    ACCEPTS_ENTER_VAR, ACCEPTS_TAB_VAR, AUTO_SELECTION_VAR, AutoSelection, FONT_FAMILY_VAR, FONT_STRETCH_VAR, FONT_STYLE_VAR,
31    FONT_SYNTHESIS_VAR, FONT_WEIGHT_VAR, MAX_CHARS_COUNT_VAR, OBSCURE_TXT_VAR, TEXT_EDITABLE_VAR, TEXT_SELECTABLE_VAR, TEXT_TRANSFORM_VAR,
32    WHITE_SPACE_VAR,
33    cmd::{EDIT_CMD, SELECT_ALL_CMD, SELECT_CMD, TextEditOp, TextSelectOp, UndoTextEditOp},
34};
35
36use super::{CaretInfo, ImePreview, PendingLayout, RESOLVED_TEXT, ResolvedText, SelectionBy, TEXT};
37
38/// An UI node that resolves the text context vars, applies the text transform and white space correction and segments the `text`.
39///
40/// This node setups the [`ResolvedText`] for all inner nodes, the `Text!` widget includes this node in the [`NestGroup::EVENT`] group,
41/// so all properties except [`NestGroup::CONTEXT`] have access using the [`TEXT::resolved`] method.
42///
43/// This node also sets the accessibility label to the resolved text.
44///
45/// [`NestGroup::EVENT`]: zng_wgt::prelude::NestGroup::EVENT
46/// [`NestGroup::CONTEXT`]: zng_wgt::prelude::NestGroup::CONTEXT
47pub fn resolve_text(child: impl UiNode, text: impl IntoVar<Txt>) -> impl UiNode {
48    let child = resolve_text_font(child);
49    let child = resolve_text_access(child);
50    let child = resolve_text_edit(child);
51    let child = resolve_text_segments(child);
52    resolve_text_context(child, text.into_var().boxed())
53}
54fn resolve_text_context(child: impl UiNode, text: BoxedVar<Txt>) -> impl UiNode {
55    let mut resolved = None;
56    match_node(child, move |child, op| match op {
57        UiNodeOp::Init => {
58            resolved = Some(Arc::new(RwLock::new(ResolvedText {
59                txt: text.clone(),
60                ime_preview: None,
61                synthesis: FontSynthesis::empty(),
62                faces: FontFaceList::empty(),
63                segmented_text: SegmentedText::new(Txt::from_static(""), LayoutDirection::LTR),
64                pending_layout: PendingLayout::empty(),
65                pending_edit: false,
66                caret: CaretInfo {
67                    opacity: var(0.fct()).read_only(),
68                    index: None,
69                    selection_index: None,
70                    initial_selection: None,
71                    index_version: Wrapping(0),
72                    used_retained_x: false,
73                    skip_next_scroll: false,
74                },
75                selection_by: SelectionBy::Command,
76                selection_toolbar_is_open: false,
77            })));
78
79            RESOLVED_TEXT.with_context(&mut resolved, || child.init());
80        }
81        UiNodeOp::Deinit => {
82            RESOLVED_TEXT.with_context(&mut resolved, || child.deinit());
83
84            resolved = None;
85        }
86        UiNodeOp::Layout { wl, final_size } => RESOLVED_TEXT.with_context(&mut resolved, || {
87            *final_size = child.layout(wl);
88            TEXT.resolve().pending_layout = PendingLayout::empty();
89        }),
90        op => RESOLVED_TEXT.with_context(&mut resolved, || child.op(op)),
91    })
92}
93fn resolve_text_font(child: impl UiNode) -> impl UiNode {
94    enum State {
95        Reload,
96        Loading {
97            response: ResponseVar<FontFaceList>,
98            _update_handle: VarHandle,
99            _window_load_handle: Option<WindowLoadingHandle>,
100        },
101        Loaded,
102    }
103    let mut state = State::Reload;
104
105    match_node(child, move |_, op| {
106        match op {
107            UiNodeOp::Init => {
108                WIDGET
109                    .sub_var(&FONT_FAMILY_VAR)
110                    .sub_var(&FONT_STYLE_VAR)
111                    .sub_var(&FONT_WEIGHT_VAR)
112                    .sub_var(&FONT_STRETCH_VAR)
113                    .sub_event(&FONT_CHANGED_EVENT)
114                    .sub_var(&FONT_SYNTHESIS_VAR);
115            }
116            UiNodeOp::Event { update } => {
117                if FONT_CHANGED_EVENT.has(update) {
118                    state = State::Reload;
119                }
120            }
121            UiNodeOp::Update { .. } => {
122                if FONT_FAMILY_VAR.is_new() || FONT_STYLE_VAR.is_new() || FONT_WEIGHT_VAR.is_new() || FONT_STRETCH_VAR.is_new() {
123                    state = State::Reload;
124                } else if let State::Loading { response, .. } = &state {
125                    if let Some(f) = response.rsp() {
126                        let mut txt = TEXT.resolve();
127                        txt.synthesis = FONT_SYNTHESIS_VAR.get() & f.best().synthesis_for(FONT_STYLE_VAR.get(), FONT_WEIGHT_VAR.get());
128                        txt.faces = f;
129                        state = State::Loaded;
130
131                        WIDGET.layout();
132                    }
133                } else if let State::Loaded = &state {
134                    if FONT_SYNTHESIS_VAR.is_new() {
135                        let mut txt = TEXT.resolve();
136                        txt.synthesis =
137                            FONT_SYNTHESIS_VAR.get() & txt.faces.best().synthesis_for(FONT_STYLE_VAR.get(), FONT_WEIGHT_VAR.get());
138
139                        WIDGET.render();
140                    }
141                }
142            }
143            UiNodeOp::Deinit => {
144                state = State::Reload;
145                return;
146            }
147            _ => {}
148        }
149
150        if let State::Reload = &state {
151            let font_list = FONT_FAMILY_VAR.with(|family| {
152                LANG_VAR.with(|lang| {
153                    FONTS.list(
154                        family,
155                        FONT_STYLE_VAR.get(),
156                        FONT_WEIGHT_VAR.get(),
157                        FONT_STRETCH_VAR.get(),
158                        lang.best(),
159                    )
160                })
161            });
162
163            if let Some(f) = font_list.rsp() {
164                let mut txt = TEXT.resolve();
165                txt.synthesis = FONT_SYNTHESIS_VAR.get() & f.best().synthesis_for(FONT_STYLE_VAR.get(), FONT_WEIGHT_VAR.get());
166                txt.faces = f;
167                state = State::Loaded;
168
169                WIDGET.layout();
170            } else {
171                state = State::Loading {
172                    _update_handle: font_list.subscribe(UpdateOp::Update, WIDGET.id()),
173                    response: font_list,
174                    _window_load_handle: WINDOW.loading_handle(1.secs()),
175                };
176            }
177        }
178    })
179}
180fn resolve_text_access(child: impl UiNode) -> impl UiNode {
181    match_node(child, |child, op| match op {
182        UiNodeOp::Init => {
183            WIDGET
184                .sub_var_info(&TEXT.resolved().txt)
185                .sub_var_info(&TEXT_EDITABLE_VAR)
186                .sub_var_info(&TEXT_SELECTABLE_VAR)
187                .sub_var_info(&OBSCURE_TXT_VAR);
188        }
189        UiNodeOp::Info { info } => {
190            let editable = TEXT_EDITABLE_VAR.get();
191            if editable || TEXT_SELECTABLE_VAR.get() {
192                FocusInfoBuilder::new(info).focusable_passive(true);
193            }
194
195            child.info(info);
196
197            if !editable && !OBSCURE_TXT_VAR.get() {
198                if let Some(mut a) = info.access() {
199                    a.set_label(TEXT.resolved().segmented_text.text().clone());
200                }
201            }
202        }
203        _ => {}
204    })
205}
206fn resolve_text_segments(child: impl UiNode) -> impl UiNode {
207    match_node(child, |_, op| {
208        let mut segment = false;
209        match op {
210            UiNodeOp::Init => {
211                WIDGET
212                    .sub_var(&TEXT.resolved().txt)
213                    .sub_var(&TEXT_TRANSFORM_VAR)
214                    .sub_var(&WHITE_SPACE_VAR)
215                    .sub_var(&DIRECTION_VAR)
216                    .sub_var(&TEXT_EDITABLE_VAR);
217
218                segment = true;
219            }
220            UiNodeOp::Update { .. } => {
221                segment = TEXT.resolved().txt.is_new()
222                    || TEXT_TRANSFORM_VAR.is_new()
223                    || WHITE_SPACE_VAR.is_new()
224                    || DIRECTION_VAR.is_new()
225                    || TEXT_EDITABLE_VAR.is_new();
226            }
227            _ => {}
228        }
229        if segment {
230            let mut ctx = TEXT.resolve();
231
232            let mut txt = ctx.txt.get();
233
234            if !TEXT_EDITABLE_VAR.get() {
235                TEXT_TRANSFORM_VAR.with(|t| {
236                    if let Cow::Owned(t) = t.transform(&txt) {
237                        txt = t;
238                    }
239                });
240                WHITE_SPACE_VAR.with(|t| {
241                    if let Cow::Owned(t) = t.transform(&txt) {
242                        txt = t;
243                    }
244                });
245            }
246
247            let direction = DIRECTION_VAR.get();
248            if ctx.segmented_text.text() != &txt || ctx.segmented_text.base_direction() != direction {
249                ctx.segmented_text = SegmentedText::new(txt, direction);
250
251                ctx.pending_layout = PendingLayout::RESHAPE;
252                WIDGET.layout();
253            }
254        }
255    })
256}
257fn resolve_text_edit(child: impl UiNode) -> impl UiNode {
258    // Use `ResolveTextEdit::get` to access.
259    let mut edit = None::<Box<ResolveTextEdit>>;
260
261    match_node(child, move |child, op| {
262        let mut enable = false;
263        match op {
264            UiNodeOp::Init => {
265                WIDGET
266                    .sub_var(&TEXT_EDITABLE_VAR)
267                    .sub_var(&TEXT_SELECTABLE_VAR)
268                    .sub_var(&MAX_CHARS_COUNT_VAR);
269                enable = TEXT_EDITABLE_VAR.get() || TEXT_SELECTABLE_VAR.get();
270            }
271            UiNodeOp::Deinit => {
272                edit = None;
273            }
274            UiNodeOp::Update { .. } => {
275                if TEXT_EDITABLE_VAR.is_new() || TEXT_SELECTABLE_VAR.is_new() {
276                    enable = TEXT_EDITABLE_VAR.get() || TEXT_SELECTABLE_VAR.get();
277                    if !enable && edit.is_some() {
278                        edit = None;
279                        TEXT.resolve().caret.opacity = var(0.fct()).read_only();
280                    }
281                }
282
283                if let Some(edit) = &mut edit {
284                    resolve_text_edit_update(edit);
285                }
286            }
287            UiNodeOp::Event { update } => {
288                child.event(update);
289
290                if let Some(edit) = &mut edit {
291                    if TEXT_EDITABLE_VAR.get() && TEXT.resolved().txt.capabilities().can_modify() {
292                        resolve_text_edit_events(update, edit);
293                    }
294                    if TEXT_EDITABLE_VAR.get() || TEXT_SELECTABLE_VAR.get() {
295                        resolve_text_edit_or_select_events(update, edit);
296                    }
297
298                    let enable = !OBSCURE_TXT_VAR.get() && TEXT.resolved().caret.selection_range().is_some();
299                    edit.cut.set_enabled(enable);
300                    edit.copy.set_enabled(enable);
301                }
302            }
303            _ => {}
304        }
305        if enable {
306            let edit = ResolveTextEdit::get(&mut edit);
307
308            let editable = TEXT_EDITABLE_VAR.get();
309            if editable {
310                let id = WIDGET.id();
311
312                edit.events[0] = FOCUS_CHANGED_EVENT.subscribe(id);
313                edit.events[1] = INTERACTIVITY_CHANGED_EVENT.subscribe(id);
314                edit.events[2] = KEY_INPUT_EVENT.subscribe(id);
315                edit.events[3] = ACCESS_TEXT_EVENT.subscribe(id);
316                edit.events[5] = IME_EVENT.subscribe(id);
317
318                edit.paste = PASTE_CMD.scoped(id).subscribe(true);
319                edit.edit = EDIT_CMD.scoped(id).subscribe(true);
320
321                edit.max_count = MAX_CHARS_COUNT_VAR.subscribe(UpdateOp::Update, id);
322
323                let mut ctx = TEXT.resolve();
324
325                enforce_max_count(&ctx.txt);
326
327                if FOCUS.is_focused(WIDGET.id()).get() {
328                    ctx.caret.opacity = KEYBOARD.caret_animation();
329                    edit.caret_animation = ctx.caret.opacity.subscribe(UpdateOp::Update, WIDGET.id());
330                }
331            }
332
333            if TEXT_SELECTABLE_VAR.get() {
334                let id = WIDGET.id();
335
336                edit.events[4] = ACCESS_SELECTION_EVENT.subscribe(id);
337
338                let enabled = !OBSCURE_TXT_VAR.get() && TEXT.resolved().caret.selection_range().is_some();
339                edit.copy = COPY_CMD.scoped(id).subscribe(enabled);
340                if editable {
341                    edit.cut = CUT_CMD.scoped(id).subscribe(enabled);
342                } else {
343                    // used in `render_selection`
344                    edit.events[0] = FOCUS_CHANGED_EVENT.subscribe(id);
345
346                    edit.events[2] = KEY_INPUT_EVENT.subscribe(id);
347                }
348            }
349        }
350    })
351}
352/// Data allocated only when `editable`.
353#[derive(Default)]
354struct ResolveTextEdit {
355    events: [EventHandle; 6],
356    caret_animation: VarHandle,
357    max_count: VarHandle,
358    cut: CommandHandle,
359    copy: CommandHandle,
360    paste: CommandHandle,
361    edit: CommandHandle,
362}
363impl ResolveTextEdit {
364    fn get(edit_data: &mut Option<Box<Self>>) -> &mut Self {
365        &mut *edit_data.get_or_insert_with(Default::default)
366    }
367}
368fn enforce_max_count(text: &BoxedVar<Txt>) {
369    let max_count = MAX_CHARS_COUNT_VAR.get();
370    if max_count > 0 {
371        let count = text.with(|t| t.chars().count());
372        if count > max_count {
373            tracing::debug!("txt var set to text longer than can be typed");
374            let _ = text.modify(move |t| {
375                if let Some((i, _)) = t.as_str().char_indices().nth(max_count) {
376                    t.to_mut().truncate(i);
377                }
378            });
379        }
380    }
381}
382fn resolve_text_edit_events(update: &EventUpdate, edit: &mut ResolveTextEdit) {
383    if let Some(args) = INTERACTIVITY_CHANGED_EVENT.on(update) {
384        if args.is_disable(WIDGET.id()) {
385            edit.caret_animation = VarHandle::dummy();
386            TEXT.resolve().caret.opacity = var(0.fct()).read_only();
387        }
388    }
389
390    if TEXT.resolved().pending_edit {
391        return;
392    }
393    let widget = WIDGET.info();
394    if !widget.interactivity().is_enabled() {
395        return;
396    }
397
398    let prev_caret = {
399        let r = TEXT.resolved();
400        (r.caret.index, r.caret.index_version, r.caret.selection_index)
401    };
402
403    if let Some(args) = KEY_INPUT_EVENT.on_unhandled(update) {
404        let mut ctx = TEXT.resolve();
405        if args.state == KeyState::Pressed && args.target.widget_id() == widget.id() {
406            match &args.key {
407                Key::Backspace => {
408                    let caret = &mut ctx.caret;
409                    if caret.selection_index.is_some() || caret.index.unwrap_or(CaretIndex::ZERO).index > 0 {
410                        if args.modifiers.is_only_ctrl() {
411                            args.propagation().stop();
412                            ctx.selection_by = SelectionBy::Keyboard;
413                            drop(ctx);
414                            TextEditOp::backspace_word().call_edit_op();
415                        } else if args.modifiers.is_empty() {
416                            args.propagation().stop();
417                            ctx.selection_by = SelectionBy::Keyboard;
418                            drop(ctx);
419                            TextEditOp::backspace().call_edit_op();
420                        }
421                    }
422                }
423                Key::Delete => {
424                    let caret = &mut ctx.caret;
425                    let caret_idx = caret.index.unwrap_or(CaretIndex::ZERO);
426                    if caret.selection_index.is_some() || caret_idx.index < ctx.segmented_text.text().len() {
427                        if args.modifiers.is_only_ctrl() {
428                            args.propagation().stop();
429                            ctx.selection_by = SelectionBy::Keyboard;
430                            drop(ctx);
431                            TextEditOp::delete_word().call_edit_op();
432                        } else if args.modifiers.is_empty() {
433                            args.propagation().stop();
434                            ctx.selection_by = SelectionBy::Keyboard;
435                            drop(ctx);
436                            TextEditOp::delete().call_edit_op();
437                        }
438                    }
439                }
440                _ => {
441                    let insert = args.insert_str();
442                    if !insert.is_empty() {
443                        let skip = (args.is_tab() && !ACCEPTS_TAB_VAR.get()) || (args.is_line_break() && !ACCEPTS_ENTER_VAR.get());
444                        if !skip {
445                            args.propagation().stop();
446                            ctx.selection_by = SelectionBy::Keyboard;
447                            drop(ctx);
448                            TextEditOp::insert(Txt::from_str(insert)).call_edit_op();
449                        }
450                    }
451                }
452            }
453        }
454    } else if let Some(args) = FOCUS_CHANGED_EVENT.on(update) {
455        let mut ctx = TEXT.resolve();
456        let caret = &mut ctx.caret;
457        let caret_index = &mut caret.index;
458
459        if args.is_focused(widget.id()) {
460            if caret_index.is_none() {
461                *caret_index = Some(CaretIndex::ZERO);
462            } else {
463                // restore animation when the caret_index did not change
464                caret.opacity = KEYBOARD.caret_animation();
465                edit.caret_animation = caret.opacity.subscribe(UpdateOp::RenderUpdate, widget.id());
466            }
467        } else {
468            edit.caret_animation = VarHandle::dummy();
469            caret.opacity = var(0.fct()).read_only();
470        }
471
472        let auto_select = AUTO_SELECTION_VAR.get();
473        if auto_select != AutoSelection::DISABLED && caret.selection_index.is_some() && TEXT_SELECTABLE_VAR.get() {
474            if auto_select.contains(AutoSelection::CLEAR_ON_BLUR) && args.is_blur(widget.id()) {
475                // deselect if the widget is not the ALT return focus and is not the parent scope return focus.
476
477                let us = Some(widget.id());
478                let alt_return = FOCUS.alt_return().with(|p| p.as_ref().map(|p| p.widget_id()));
479                if alt_return != us {
480                    if let Some(info) = WIDGET.info().into_focusable(true, true) {
481                        if let Some(scope) = info.scope() {
482                            let parent_return = FOCUS.return_focused(scope.info().id()).with(|p| p.as_ref().map(|p| p.widget_id()));
483                            if parent_return != us {
484                                SELECT_CMD.scoped(widget.id()).notify_param(TextSelectOp::next());
485                            }
486                        }
487                    }
488                }
489            }
490
491            if auto_select.contains(AutoSelection::ALL_ON_FOCUS_KEYBOARD) && args.highlight && args.is_focus(widget.id()) {
492                // select all on keyboard caused focus
493                SELECT_ALL_CMD.scoped(widget.id()).notify();
494            }
495
496            // ALL_ON_FOCUS_POINTER handled by `layout_text_edit_events`
497        }
498    } else if let Some(args) = CUT_CMD.scoped(widget.id()).on_unhandled(update) {
499        let mut ctx = TEXT.resolve();
500        if let Some(range) = ctx.caret.selection_char_range() {
501            args.propagation().stop();
502            ctx.selection_by = SelectionBy::Command;
503            CLIPBOARD.set_text(Txt::from_str(&ctx.segmented_text.text()[range]));
504            drop(ctx);
505            TextEditOp::delete().call_edit_op();
506        }
507    } else if let Some(args) = PASTE_CMD.scoped(widget.id()).on_unhandled(update) {
508        if let Some(paste) = CLIPBOARD.text().ok().flatten() {
509            if !paste.is_empty() {
510                args.propagation().stop();
511                TEXT.resolve().selection_by = SelectionBy::Command;
512                TextEditOp::insert(paste).call_edit_op();
513            }
514        }
515    } else if let Some(args) = EDIT_CMD.scoped(widget.id()).on_unhandled(update) {
516        if let Some(op) = args.param::<UndoTextEditOp>() {
517            args.propagation().stop();
518
519            op.call();
520            if !TEXT.resolved().pending_edit {
521                TEXT.resolve().pending_edit = true;
522                WIDGET.update();
523            }
524        } else if let Some(op) = args.param::<TextEditOp>() {
525            args.propagation().stop();
526
527            op.clone().call_edit_op();
528        }
529    } else if let Some(args) = ACCESS_TEXT_EVENT.on_unhandled(update) {
530        if args.widget_id == widget.id() {
531            args.propagation().stop();
532
533            if args.selection_only {
534                TextEditOp::insert(args.txt.clone())
535            } else {
536                let current_len = TEXT.resolved().txt.with(|t| t.len());
537                let new_len = args.txt.len();
538                TextEditOp::replace(0..current_len, args.txt.clone(), new_len..new_len)
539            }
540            .call_edit_op();
541        }
542    } else if let Some(args) = IME_EVENT.on_unhandled(update) {
543        let mut resegment = false;
544
545        if let Some((start, end)) = args.preview_caret {
546            // update preview txt
547
548            let mut ctx = TEXT.resolve();
549            let ctx = &mut *ctx;
550
551            if args.txt.is_empty() {
552                if let Some(preview) = ctx.ime_preview.take() {
553                    resegment = true;
554                    let caret = &mut ctx.caret;
555                    caret.set_index(preview.prev_caret);
556                    caret.selection_index = preview.prev_selection;
557                }
558            } else if let Some(preview) = &mut ctx.ime_preview {
559                resegment = preview.txt != args.txt;
560                if resegment {
561                    preview.txt = args.txt.clone();
562                }
563            } else {
564                resegment = true;
565                let caret = &mut ctx.caret;
566                ctx.ime_preview = Some(ImePreview {
567                    txt: args.txt.clone(),
568                    prev_caret: caret.index.unwrap_or(CaretIndex::ZERO),
569                    prev_selection: caret.selection_index,
570                });
571            }
572
573            // update preview caret/selection indexes.
574            if let Some(preview) = &ctx.ime_preview {
575                let caret = &mut ctx.caret;
576                let ime_start = if let Some(s) = preview.prev_selection {
577                    preview.prev_caret.index.min(s.index)
578                } else {
579                    preview.prev_caret.index
580                };
581                if start != end {
582                    let start = ime_start + start;
583                    let end = ime_start + end;
584                    resegment |= caret.selection_char_range() != Some(start..end);
585                    caret.set_char_selection(start, end);
586                } else {
587                    let start = ime_start + start;
588                    resegment |= caret.selection_index.is_some() || caret.index.map(|c| c.index) != Some(start);
589                    caret.set_char_index(start);
590                    caret.selection_index = None;
591                }
592            }
593        } else {
594            // commit IME insert
595
596            args.propagation().stop();
597            {
598                let mut ctx = TEXT.resolve();
599                if let Some(preview) = ctx.ime_preview.take() {
600                    // restore caret
601                    let caret = &mut ctx.caret;
602                    caret.set_index(preview.prev_caret);
603                    caret.selection_index = preview.prev_selection;
604
605                    if args.txt.is_empty() {
606                        // the actual insert already re-segments, except in this case
607                        // where there is nothing to insert.
608                        resegment = true;
609                    }
610                }
611            }
612
613            if !args.txt.is_empty() {
614                // actual insert
615                let mut ctx = TEXT.resolve();
616                ctx.selection_by = SelectionBy::Keyboard;
617
618                // if the committed text is equal the last preview reshape is skipped
619                // leaving behind the IME underline highlight.
620                ctx.pending_layout |= PendingLayout::UNDERLINE;
621                WIDGET.layout();
622
623                drop(ctx);
624                TextEditOp::insert(args.txt.clone()).call_edit_op();
625            }
626        }
627
628        if resegment {
629            let mut ctx = TEXT.resolve();
630
631            // re-segment text to insert or remove the preview
632            let mut text = ctx.txt.get();
633            if let Some(preview) = &ctx.ime_preview {
634                if let Some(s) = preview.prev_selection {
635                    let range = if preview.prev_caret.index < s.index {
636                        preview.prev_caret.index..s.index
637                    } else {
638                        s.index..preview.prev_caret.index
639                    };
640                    text.to_mut().replace_range(range, preview.txt.as_str());
641                } else {
642                    text.to_mut().insert_str(preview.prev_caret.index, preview.txt.as_str());
643                }
644                text.end_mut();
645            }
646            ctx.segmented_text = SegmentedText::new(text, DIRECTION_VAR.get());
647
648            ctx.pending_layout |= PendingLayout::RESHAPE;
649            WIDGET.layout();
650        }
651    }
652
653    let mut ctx = TEXT.resolve();
654    let caret = &mut ctx.caret;
655
656    if (caret.index, caret.index_version, caret.selection_index) != prev_caret {
657        caret.used_retained_x = false;
658        if caret.index.is_none() || !FOCUS.is_focused(widget.id()).get() {
659            edit.caret_animation = VarHandle::dummy();
660            caret.opacity = var(0.fct()).read_only();
661        } else {
662            caret.opacity = KEYBOARD.caret_animation();
663            edit.caret_animation = caret.opacity.subscribe(UpdateOp::RenderUpdate, widget.id());
664        }
665        ctx.pending_layout |= PendingLayout::CARET;
666        WIDGET.layout(); // update caret_origin
667    }
668}
669fn resolve_text_edit_or_select_events(update: &EventUpdate, _: &mut ResolveTextEdit) {
670    let widget_id = WIDGET.id();
671
672    if let Some(args) = COPY_CMD.scoped(widget_id).on_unhandled(update) {
673        let ctx = TEXT.resolved();
674        if let Some(range) = ctx.caret.selection_char_range() {
675            args.propagation().stop();
676            let _ = CLIPBOARD.set_text(Txt::from_str(&ctx.segmented_text.text()[range]));
677        }
678    } else if let Some(args) = ACCESS_SELECTION_EVENT.on_unhandled(update) {
679        if args.start.0 == widget_id && args.caret.0 == widget_id {
680            args.propagation().stop();
681
682            let mut ctx = TEXT.resolve();
683
684            ctx.caret.set_char_selection(args.start.1, args.caret.1);
685
686            ctx.pending_layout |= PendingLayout::CARET;
687            WIDGET.layout();
688        }
689    }
690}
691fn resolve_text_edit_update(_: &mut ResolveTextEdit) {
692    let mut ctx = TEXT.resolve();
693    let ctx = &mut *ctx;
694    if ctx.txt.is_new() {
695        if !ctx.pending_edit && UNDO.scope() == Some(WIDGET.id()) {
696            UNDO.clear();
697        }
698
699        if let Some(p) = ctx.ime_preview.take() {
700            ctx.caret.index = Some(p.prev_caret);
701            ctx.caret.selection_index = p.prev_selection;
702
703            CANCEL_IME_CMD.scoped(WINDOW.id()).notify();
704        }
705
706        enforce_max_count(&ctx.txt);
707
708        // prevent invalid indexes
709        let caret = &mut ctx.caret;
710        if let Some(i) = &mut caret.index {
711            i.index = ctx.segmented_text.snap_grapheme_boundary(i.index);
712        }
713        if let Some(i) = &mut caret.selection_index {
714            i.index = ctx.segmented_text.snap_grapheme_boundary(i.index);
715        }
716        if let Some((cr, _)) = &mut caret.initial_selection {
717            cr.start.index = ctx.segmented_text.snap_grapheme_boundary(cr.start.index);
718            cr.end.index = ctx.segmented_text.snap_grapheme_boundary(cr.end.index);
719        }
720    }
721
722    if TEXT_EDITABLE_VAR.get() && MAX_CHARS_COUNT_VAR.is_new() {
723        enforce_max_count(&TEXT.resolved().txt);
724    }
725
726    // either txt was new or the edit did not change the text.
727    ctx.pending_edit = false;
728}
zng_wgt_text/node/resolve.rs

zng_wgt_text/node/
resolve.rs
