Struct Selection 

#[non_exhaustive]
pub struct Selection {
    pub anchor: usize,
    pub active: usize,
    pub h_pos: Option<f64>,
}

A range of selected text, or a caret.

A caret is the blinking vertical bar where text is to be inserted. We represent it as a selection with zero length, where anchor == active. Indices are always expressed in UTF-8 bytes, and must be between 0 and the document length, inclusive.

As an example, if the input caret is at the start of the document hello world, we would expect both anchor and active to be 0. If the user holds shift and presses the right arrow key five times, we would expect the word hello to be selected, the anchor to still be 0, and the active to now be 5.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

anchor: usize

The ‘anchor’ end of the selection.

This is the end of the selection that stays unchanged while holding shift and pressing the arrow keys.

active: usize

The ‘active’ end of the selection.

This is the end of the selection that moves while holding shift and pressing the arrow keys.

h_pos: Option<f64>

The saved horizontal position, during vertical movement.

This should not be set by the IME; it will be tracked and handled by the text field.

Implementations

impl Selection

pub fn new(anchor: usize, active: usize) -> Selection

Create a new Selection with the provided anchor and active positions.

Both positions refer to UTF-8 byte indices in some text.

If your selection is a caret, you can use Selection::caret instead.

Examples found in repository

examples/edit_text.rs (line 297)

fn apply_default_behavior(handler: &mut AppInputHandler, action: Action) -> bool {
    let is_caret = handler.selection().is_caret();
    match action {
        Action::Move(movement) => {
            let selection = handler.selection();
            let index = if movement_goes_downstream(movement) {
                selection.max()
            } else {
                selection.min()
            };
            let updated_index = if let (false, text::Movement::Grapheme(_)) = (is_caret, movement) {
                // handle special cases of pressing left/right when the selection is not a caret
                index
            } else {
                match apply_movement(handler, movement, index) {
                    Some(v) => v,
                    None => return false,
                }
            };
            handler.set_selection(Selection::caret(updated_index));
        }
        Action::MoveSelecting(movement) => {
            let mut selection = handler.selection();
            selection.active = match apply_movement(handler, movement, selection.active) {
                Some(v) => v,
                None => return false,
            };
            handler.set_selection(selection);
        }
        Action::SelectAll => {
            let len = handler.len();
            let selection = Selection::new(0, len);
            handler.set_selection(selection);
        }
        Action::Delete(_) if !is_caret => {
            // movement is ignored for non-caret selections
            let selection = handler.selection();
            handler.replace_range(selection.range(), "");
        }
        Action::Delete(movement) => {
            let mut selection = handler.selection();
            selection.active = match apply_movement(handler, movement, selection.active) {
                Some(v) => v,
                None => return false,
            };
            handler.replace_range(selection.range(), "");
        }
        _ => return false,
    }
    true
}

pub fn caret(index: usize) -> Selection

Create a new caret (zero-length selection) at the provided UTF-8 byte index.

index must be a grapheme cluster boundary.

Examples found in repository

examples/edit_text.rs (line 135)

    fn key_down(&mut self, event: KeyEvent) -> bool {
        if event.key == Key::Character("c".to_string()) {
            // custom hotkey for pressing "c"
            println!("user pressed c! wow! setting selection to 0");

            // update internal selection state
            self.document.borrow_mut().selection = Selection::caret(0);

            // notify the OS that we've updated the selection
            self.handle
                .update_text_field(self.text_input_token.unwrap(), Event::SelectionChanged);

            // repaint window
            self.handle.request_anim_frame();

            // return true prevents the keypress event from being handled as text input
            return true;
        }
        false
    }

    fn acquire_input_lock(
        &mut self,
        _token: TextFieldToken,
        _mutable: bool,
    ) -> Box<dyn InputHandler> {
        Box::new(AppInputHandler {
            state: self.document.clone(),
            window_size: self.size,
            window_handle: self.handle.clone(),
        })
    }

    fn release_input_lock(&mut self, _token: TextFieldToken) {
        // no action required; this example is simple enough that this
        // state is not actually shared.
    }

    fn size(&mut self, size: Size) {
        self.size = size;
    }

    fn request_close(&mut self) {
        self.handle.close();
    }

    fn destroy(&mut self) {
        Application::global().quit()
    }

    fn as_any(&mut self) -> &mut dyn Any {
        self
    }
}

struct AppInputHandler {
    state: Rc<RefCell<DocumentState>>,
    window_size: Size,
    window_handle: WindowHandle,
}

impl InputHandler for AppInputHandler {
    fn selection(&self) -> Selection {
        self.state.borrow().selection
    }
    fn composition_range(&self) -> Option<Range<usize>> {
        self.state.borrow().composition.clone()
    }
    fn set_selection(&mut self, range: Selection) {
        self.state.borrow_mut().selection = range;
        self.window_handle.request_anim_frame();
    }
    fn set_composition_range(&mut self, range: Option<Range<usize>>) {
        self.state.borrow_mut().composition = range;
        self.window_handle.request_anim_frame();
    }
    fn replace_range(&mut self, range: Range<usize>, text: &str) {
        let mut doc = self.state.borrow_mut();
        doc.text.replace_range(range.clone(), text);
        if doc.selection.anchor < range.start && doc.selection.active < range.start {
            // no need to update selection
        } else if doc.selection.anchor > range.end && doc.selection.active > range.end {
            doc.selection.anchor -= range.len();
            doc.selection.active -= range.len();
            doc.selection.anchor += text.len();
            doc.selection.active += text.len();
        } else {
            doc.selection.anchor = range.start + text.len();
            doc.selection.active = range.start + text.len();
        }
        doc.refresh_layout();
        doc.composition = None;
        self.window_handle.request_anim_frame();
    }
    fn slice(&self, range: Range<usize>) -> Cow<str> {
        self.state.borrow().text[range].to_string().into()
    }
    fn is_char_boundary(&self, i: usize) -> bool {
        self.state.borrow().text.is_char_boundary(i)
    }
    fn len(&self) -> usize {
        self.state.borrow().text.len()
    }
    fn hit_test_point(&self, point: Point) -> HitTestPoint {
        self.state
            .borrow()
            .layout
            .as_ref()
            .unwrap()
            .hit_test_point(point)
    }
    fn bounding_box(&self) -> Option<Rect> {
        Some(Rect::new(
            0.0,
            0.0,
            self.window_size.width,
            self.window_size.height,
        ))
    }
    fn slice_bounding_box(&self, range: Range<usize>) -> Option<Rect> {
        let doc = self.state.borrow();
        let layout = doc.layout.as_ref().unwrap();
        let range_start_x = layout.hit_test_text_position(range.start).point.x;
        let range_end_x = layout.hit_test_text_position(range.end).point.x;
        Some(Rect::new(range_start_x, 0.0, range_end_x, FONT_SIZE))
    }
    fn line_range(&self, _char_index: usize, _affinity: text::Affinity) -> Range<usize> {
        // we don't have multiple lines, so no matter the input, output is the whole document
        0..self.state.borrow().text.len()
    }

    fn handle_action(&mut self, action: Action) {
        let handled = apply_default_behavior(self, action);
        println!("action: {action:?} handled: {handled:?}");
    }
}

fn apply_default_behavior(handler: &mut AppInputHandler, action: Action) -> bool {
    let is_caret = handler.selection().is_caret();
    match action {
        Action::Move(movement) => {
            let selection = handler.selection();
            let index = if movement_goes_downstream(movement) {
                selection.max()
            } else {
                selection.min()
            };
            let updated_index = if let (false, text::Movement::Grapheme(_)) = (is_caret, movement) {
                // handle special cases of pressing left/right when the selection is not a caret
                index
            } else {
                match apply_movement(handler, movement, index) {
                    Some(v) => v,
                    None => return false,
                }
            };
            handler.set_selection(Selection::caret(updated_index));
        }
        Action::MoveSelecting(movement) => {
            let mut selection = handler.selection();
            selection.active = match apply_movement(handler, movement, selection.active) {
                Some(v) => v,
                None => return false,
            };
            handler.set_selection(selection);
        }
        Action::SelectAll => {
            let len = handler.len();
            let selection = Selection::new(0, len);
            handler.set_selection(selection);
        }
        Action::Delete(_) if !is_caret => {
            // movement is ignored for non-caret selections
            let selection = handler.selection();
            handler.replace_range(selection.range(), "");
        }
        Action::Delete(movement) => {
            let mut selection = handler.selection();
            selection.active = match apply_movement(handler, movement, selection.active) {
                Some(v) => v,
                None => return false,
            };
            handler.replace_range(selection.range(), "");
        }
        _ => return false,
    }
    true
}

pub fn with_h_pos(self, h_pos: Option<f64>) -> Self

Construct a new selection from this selection, with the provided h_pos.

Note

h_pos is used to track the pixel location of the cursor when moving vertically; lines may have available cursor positions at different positions, and arrowing down and then back up should always result in a cursor at the original starting location; doing this correctly requires tracking this state.

You probably don’t need to use this, unless you are implementing a new text field, or otherwise implementing vertical cursor motion, in which case you will want to set this during vertical motion if it is not already set.

pub fn constrained(self, s: &str) -> Self

Create a new selection that is guaranteed to be valid for the provided text.

pub fn min(&self) -> usize

Return the position of the upstream end of the selection.

This is end with the lesser byte index.

Because of bidirectional text, this is not necessarily “left”.

Examples found in repository

examples/edit_text.rs (line 274)

fn apply_default_behavior(handler: &mut AppInputHandler, action: Action) -> bool {
    let is_caret = handler.selection().is_caret();
    match action {
        Action::Move(movement) => {
            let selection = handler.selection();
            let index = if movement_goes_downstream(movement) {
                selection.max()
            } else {
                selection.min()
            };
            let updated_index = if let (false, text::Movement::Grapheme(_)) = (is_caret, movement) {
                // handle special cases of pressing left/right when the selection is not a caret
                index
            } else {
                match apply_movement(handler, movement, index) {
                    Some(v) => v,
                    None => return false,
                }
            };
            handler.set_selection(Selection::caret(updated_index));
        }
        Action::MoveSelecting(movement) => {
            let mut selection = handler.selection();
            selection.active = match apply_movement(handler, movement, selection.active) {
                Some(v) => v,
                None => return false,
            };
            handler.set_selection(selection);
        }
        Action::SelectAll => {
            let len = handler.len();
            let selection = Selection::new(0, len);
            handler.set_selection(selection);
        }
        Action::Delete(_) if !is_caret => {
            // movement is ignored for non-caret selections
            let selection = handler.selection();
            handler.replace_range(selection.range(), "");
        }
        Action::Delete(movement) => {
            let mut selection = handler.selection();
            selection.active = match apply_movement(handler, movement, selection.active) {
                Some(v) => v,
                None => return false,
            };
            handler.replace_range(selection.range(), "");
        }
        _ => return false,
    }
    true
}

pub fn max(&self) -> usize

Return the position of the downstream end of the selection.

This is the end with the greater byte index.

Because of bidirectional text, this is not necessarily “right”.

Examples found in repository

examples/edit_text.rs (line 272)

fn apply_default_behavior(handler: &mut AppInputHandler, action: Action) -> bool {
    let is_caret = handler.selection().is_caret();
    match action {
        Action::Move(movement) => {
            let selection = handler.selection();
            let index = if movement_goes_downstream(movement) {
                selection.max()
            } else {
                selection.min()
            };
            let updated_index = if let (false, text::Movement::Grapheme(_)) = (is_caret, movement) {
                // handle special cases of pressing left/right when the selection is not a caret
                index
            } else {
                match apply_movement(handler, movement, index) {
                    Some(v) => v,
                    None => return false,
                }
            };
            handler.set_selection(Selection::caret(updated_index));
        }
        Action::MoveSelecting(movement) => {
            let mut selection = handler.selection();
            selection.active = match apply_movement(handler, movement, selection.active) {
                Some(v) => v,
                None => return false,
            };
            handler.set_selection(selection);
        }
        Action::SelectAll => {
            let len = handler.len();
            let selection = Selection::new(0, len);
            handler.set_selection(selection);
        }
        Action::Delete(_) if !is_caret => {
            // movement is ignored for non-caret selections
            let selection = handler.selection();
            handler.replace_range(selection.range(), "");
        }
        Action::Delete(movement) => {
            let mut selection = handler.selection();
            selection.active = match apply_movement(handler, movement, selection.active) {
                Some(v) => v,
                None => return false,
            };
            handler.replace_range(selection.range(), "");
        }
        _ => return false,
    }
    true
}

pub fn range(&self) -> Range<usize>

The sequential range of the document represented by this selection.

This is the range that would be replaced if text were inserted at this selection.

Examples found in repository

examples/edit_text.rs (line 105)

    fn paint(&mut self, piet: &mut piet_common::Piet, _: &Region) {
        let rect = self.size.to_rect();
        piet.fill(rect, &BG_COLOR);
        let doc = self.document.borrow();
        let layout = doc.layout.as_ref().unwrap();
        // TODO(lord): rects for range on layout
        if let Some(composition_range) = doc.composition.as_ref() {
            for rect in layout.rects_for_range(composition_range.clone()) {
                piet.fill(rect, &COMPOSITION_BG_COLOR);
            }
        }
        if !doc.selection.is_caret() {
            for rect in layout.rects_for_range(doc.selection.range()) {
                piet.fill(rect, &SELECTION_BG_COLOR);
            }
        }
        piet.draw_text(layout, (0.0, 0.0));

        // draw caret
        let caret_x = layout.hit_test_text_position(doc.selection.active).point.x;
        piet.fill(
            Rect::new(caret_x - 1.0, 0.0, caret_x + 1.0, FONT_SIZE),
            &CARET_COLOR,
        );
    }

    fn command(&mut self, id: u32) {
        match id {
            0x100 => {
                self.handle.close();
                Application::global().quit()
            }
            _ => println!("unexpected id {id}"),
        }
    }

    fn key_down(&mut self, event: KeyEvent) -> bool {
        if event.key == Key::Character("c".to_string()) {
            // custom hotkey for pressing "c"
            println!("user pressed c! wow! setting selection to 0");

            // update internal selection state
            self.document.borrow_mut().selection = Selection::caret(0);

            // notify the OS that we've updated the selection
            self.handle
                .update_text_field(self.text_input_token.unwrap(), Event::SelectionChanged);

            // repaint window
            self.handle.request_anim_frame();

            // return true prevents the keypress event from being handled as text input
            return true;
        }
        false
    }

    fn acquire_input_lock(
        &mut self,
        _token: TextFieldToken,
        _mutable: bool,
    ) -> Box<dyn InputHandler> {
        Box::new(AppInputHandler {
            state: self.document.clone(),
            window_size: self.size,
            window_handle: self.handle.clone(),
        })
    }

    fn release_input_lock(&mut self, _token: TextFieldToken) {
        // no action required; this example is simple enough that this
        // state is not actually shared.
    }

    fn size(&mut self, size: Size) {
        self.size = size;
    }

    fn request_close(&mut self) {
        self.handle.close();
    }

    fn destroy(&mut self) {
        Application::global().quit()
    }

    fn as_any(&mut self) -> &mut dyn Any {
        self
    }
}

struct AppInputHandler {
    state: Rc<RefCell<DocumentState>>,
    window_size: Size,
    window_handle: WindowHandle,
}

impl InputHandler for AppInputHandler {
    fn selection(&self) -> Selection {
        self.state.borrow().selection
    }
    fn composition_range(&self) -> Option<Range<usize>> {
        self.state.borrow().composition.clone()
    }
    fn set_selection(&mut self, range: Selection) {
        self.state.borrow_mut().selection = range;
        self.window_handle.request_anim_frame();
    }
    fn set_composition_range(&mut self, range: Option<Range<usize>>) {
        self.state.borrow_mut().composition = range;
        self.window_handle.request_anim_frame();
    }
    fn replace_range(&mut self, range: Range<usize>, text: &str) {
        let mut doc = self.state.borrow_mut();
        doc.text.replace_range(range.clone(), text);
        if doc.selection.anchor < range.start && doc.selection.active < range.start {
            // no need to update selection
        } else if doc.selection.anchor > range.end && doc.selection.active > range.end {
            doc.selection.anchor -= range.len();
            doc.selection.active -= range.len();
            doc.selection.anchor += text.len();
            doc.selection.active += text.len();
        } else {
            doc.selection.anchor = range.start + text.len();
            doc.selection.active = range.start + text.len();
        }
        doc.refresh_layout();
        doc.composition = None;
        self.window_handle.request_anim_frame();
    }
    fn slice(&self, range: Range<usize>) -> Cow<str> {
        self.state.borrow().text[range].to_string().into()
    }
    fn is_char_boundary(&self, i: usize) -> bool {
        self.state.borrow().text.is_char_boundary(i)
    }
    fn len(&self) -> usize {
        self.state.borrow().text.len()
    }
    fn hit_test_point(&self, point: Point) -> HitTestPoint {
        self.state
            .borrow()
            .layout
            .as_ref()
            .unwrap()
            .hit_test_point(point)
    }
    fn bounding_box(&self) -> Option<Rect> {
        Some(Rect::new(
            0.0,
            0.0,
            self.window_size.width,
            self.window_size.height,
        ))
    }
    fn slice_bounding_box(&self, range: Range<usize>) -> Option<Rect> {
        let doc = self.state.borrow();
        let layout = doc.layout.as_ref().unwrap();
        let range_start_x = layout.hit_test_text_position(range.start).point.x;
        let range_end_x = layout.hit_test_text_position(range.end).point.x;
        Some(Rect::new(range_start_x, 0.0, range_end_x, FONT_SIZE))
    }
    fn line_range(&self, _char_index: usize, _affinity: text::Affinity) -> Range<usize> {
        // we don't have multiple lines, so no matter the input, output is the whole document
        0..self.state.borrow().text.len()
    }

    fn handle_action(&mut self, action: Action) {
        let handled = apply_default_behavior(self, action);
        println!("action: {action:?} handled: {handled:?}");
    }
}

fn apply_default_behavior(handler: &mut AppInputHandler, action: Action) -> bool {
    let is_caret = handler.selection().is_caret();
    match action {
        Action::Move(movement) => {
            let selection = handler.selection();
            let index = if movement_goes_downstream(movement) {
                selection.max()
            } else {
                selection.min()
            };
            let updated_index = if let (false, text::Movement::Grapheme(_)) = (is_caret, movement) {
                // handle special cases of pressing left/right when the selection is not a caret
                index
            } else {
                match apply_movement(handler, movement, index) {
                    Some(v) => v,
                    None => return false,
                }
            };
            handler.set_selection(Selection::caret(updated_index));
        }
        Action::MoveSelecting(movement) => {
            let mut selection = handler.selection();
            selection.active = match apply_movement(handler, movement, selection.active) {
                Some(v) => v,
                None => return false,
            };
            handler.set_selection(selection);
        }
        Action::SelectAll => {
            let len = handler.len();
            let selection = Selection::new(0, len);
            handler.set_selection(selection);
        }
        Action::Delete(_) if !is_caret => {
            // movement is ignored for non-caret selections
            let selection = handler.selection();
            handler.replace_range(selection.range(), "");
        }
        Action::Delete(movement) => {
            let mut selection = handler.selection();
            selection.active = match apply_movement(handler, movement, selection.active) {
                Some(v) => v,
                None => return false,
            };
            handler.replace_range(selection.range(), "");
        }
        _ => return false,
    }
    true
}

pub fn len(&self) -> usize

The length, in bytes of the selected region.

If the selection is a caret, this is 0.

pub fn is_caret(&self) -> bool

Returns true if the selection’s length is 0.

Examples found in repository

examples/edit_text.rs (line 104)

    fn paint(&mut self, piet: &mut piet_common::Piet, _: &Region) {
        let rect = self.size.to_rect();
        piet.fill(rect, &BG_COLOR);
        let doc = self.document.borrow();
        let layout = doc.layout.as_ref().unwrap();
        // TODO(lord): rects for range on layout
        if let Some(composition_range) = doc.composition.as_ref() {
            for rect in layout.rects_for_range(composition_range.clone()) {
                piet.fill(rect, &COMPOSITION_BG_COLOR);
            }
        }
        if !doc.selection.is_caret() {
            for rect in layout.rects_for_range(doc.selection.range()) {
                piet.fill(rect, &SELECTION_BG_COLOR);
            }
        }
        piet.draw_text(layout, (0.0, 0.0));

        // draw caret
        let caret_x = layout.hit_test_text_position(doc.selection.active).point.x;
        piet.fill(
            Rect::new(caret_x - 1.0, 0.0, caret_x + 1.0, FONT_SIZE),
            &CARET_COLOR,
        );
    }

    fn command(&mut self, id: u32) {
        match id {
            0x100 => {
                self.handle.close();
                Application::global().quit()
            }
            _ => println!("unexpected id {id}"),
        }
    }

    fn key_down(&mut self, event: KeyEvent) -> bool {
        if event.key == Key::Character("c".to_string()) {
            // custom hotkey for pressing "c"
            println!("user pressed c! wow! setting selection to 0");

            // update internal selection state
            self.document.borrow_mut().selection = Selection::caret(0);

            // notify the OS that we've updated the selection
            self.handle
                .update_text_field(self.text_input_token.unwrap(), Event::SelectionChanged);

            // repaint window
            self.handle.request_anim_frame();

            // return true prevents the keypress event from being handled as text input
            return true;
        }
        false
    }

    fn acquire_input_lock(
        &mut self,
        _token: TextFieldToken,
        _mutable: bool,
    ) -> Box<dyn InputHandler> {
        Box::new(AppInputHandler {
            state: self.document.clone(),
            window_size: self.size,
            window_handle: self.handle.clone(),
        })
    }

    fn release_input_lock(&mut self, _token: TextFieldToken) {
        // no action required; this example is simple enough that this
        // state is not actually shared.
    }

    fn size(&mut self, size: Size) {
        self.size = size;
    }

    fn request_close(&mut self) {
        self.handle.close();
    }

    fn destroy(&mut self) {
        Application::global().quit()
    }

    fn as_any(&mut self) -> &mut dyn Any {
        self
    }
}

struct AppInputHandler {
    state: Rc<RefCell<DocumentState>>,
    window_size: Size,
    window_handle: WindowHandle,
}

impl InputHandler for AppInputHandler {
    fn selection(&self) -> Selection {
        self.state.borrow().selection
    }
    fn composition_range(&self) -> Option<Range<usize>> {
        self.state.borrow().composition.clone()
    }
    fn set_selection(&mut self, range: Selection) {
        self.state.borrow_mut().selection = range;
        self.window_handle.request_anim_frame();
    }
    fn set_composition_range(&mut self, range: Option<Range<usize>>) {
        self.state.borrow_mut().composition = range;
        self.window_handle.request_anim_frame();
    }
    fn replace_range(&mut self, range: Range<usize>, text: &str) {
        let mut doc = self.state.borrow_mut();
        doc.text.replace_range(range.clone(), text);
        if doc.selection.anchor < range.start && doc.selection.active < range.start {
            // no need to update selection
        } else if doc.selection.anchor > range.end && doc.selection.active > range.end {
            doc.selection.anchor -= range.len();
            doc.selection.active -= range.len();
            doc.selection.anchor += text.len();
            doc.selection.active += text.len();
        } else {
            doc.selection.anchor = range.start + text.len();
            doc.selection.active = range.start + text.len();
        }
        doc.refresh_layout();
        doc.composition = None;
        self.window_handle.request_anim_frame();
    }
    fn slice(&self, range: Range<usize>) -> Cow<str> {
        self.state.borrow().text[range].to_string().into()
    }
    fn is_char_boundary(&self, i: usize) -> bool {
        self.state.borrow().text.is_char_boundary(i)
    }
    fn len(&self) -> usize {
        self.state.borrow().text.len()
    }
    fn hit_test_point(&self, point: Point) -> HitTestPoint {
        self.state
            .borrow()
            .layout
            .as_ref()
            .unwrap()
            .hit_test_point(point)
    }
    fn bounding_box(&self) -> Option<Rect> {
        Some(Rect::new(
            0.0,
            0.0,
            self.window_size.width,
            self.window_size.height,
        ))
    }
    fn slice_bounding_box(&self, range: Range<usize>) -> Option<Rect> {
        let doc = self.state.borrow();
        let layout = doc.layout.as_ref().unwrap();
        let range_start_x = layout.hit_test_text_position(range.start).point.x;
        let range_end_x = layout.hit_test_text_position(range.end).point.x;
        Some(Rect::new(range_start_x, 0.0, range_end_x, FONT_SIZE))
    }
    fn line_range(&self, _char_index: usize, _affinity: text::Affinity) -> Range<usize> {
        // we don't have multiple lines, so no matter the input, output is the whole document
        0..self.state.borrow().text.len()
    }

    fn handle_action(&mut self, action: Action) {
        let handled = apply_default_behavior(self, action);
        println!("action: {action:?} handled: {handled:?}");
    }
}

fn apply_default_behavior(handler: &mut AppInputHandler, action: Action) -> bool {
    let is_caret = handler.selection().is_caret();
    match action {
        Action::Move(movement) => {
            let selection = handler.selection();
            let index = if movement_goes_downstream(movement) {
                selection.max()
            } else {
                selection.min()
            };
            let updated_index = if let (false, text::Movement::Grapheme(_)) = (is_caret, movement) {
                // handle special cases of pressing left/right when the selection is not a caret
                index
            } else {
                match apply_movement(handler, movement, index) {
                    Some(v) => v,
                    None => return false,
                }
            };
            handler.set_selection(Selection::caret(updated_index));
        }
        Action::MoveSelecting(movement) => {
            let mut selection = handler.selection();
            selection.active = match apply_movement(handler, movement, selection.active) {
                Some(v) => v,
                None => return false,
            };
            handler.set_selection(selection);
        }
        Action::SelectAll => {
            let len = handler.len();
            let selection = Selection::new(0, len);
            handler.set_selection(selection);
        }
        Action::Delete(_) if !is_caret => {
            // movement is ignored for non-caret selections
            let selection = handler.selection();
            handler.replace_range(selection.range(), "");
        }
        Action::Delete(movement) => {
            let mut selection = handler.selection();
            selection.active = match apply_movement(handler, movement, selection.active) {
                Some(v) => v,
                None => return false,
            };
            handler.replace_range(selection.range(), "");
        }
        _ => return false,
    }
    true
}

Trait Implementations

impl Clone for Selection

fn clone(&self) -> Selection

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Selection

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Selection

fn default() -> Selection

Returns the “default value” for a type.

impl PartialEq for Selection

fn eq(&self, other: &Selection) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Selection

impl StructuralPartialEq for Selection