Struct Text

Source

pub struct Text { /* private fields */ }

Expand description

The text in a given Area

Implementations§

Source §

impl Text

Source

pub fn search_fwd<R: RegexPattern>( &mut self, pat: R, range: impl TextRange, ) -> Result<impl Iterator<Item = R::Match> + '_, Box<Error>>

Source

pub fn search_rev<R: RegexPattern>( &mut self, pat: R, range: impl TextRange, ) -> Result<impl Iterator<Item = R::Match> + '_, Box<Error>>

Returns an iterator over the reverse matches of the regex

Source

pub fn matches( &mut self, pat: impl RegexPattern, range: impl TextRange, ) -> Result<bool, Box<Error>>

Returns true if the pattern is found in the given range

This is unanchored by default, if you want an anchored search, use the "^$" characters.

Source §

impl Text

Source

pub fn new() -> Self

Returns a new empty Text

Source

pub fn new_with_cursors() -> Self

Source

pub fn len(&self) -> Point

The Point at the end of the text

Source

pub fn is_empty(&self) -> bool

Whether or not there are any characters in the Text

§Note

This does not check for tags, so with a Tag::GhostText, there could actually be a “string” of characters on the Text, it just wouldn’t be considered real “text”.

Source

pub fn char_at(&self, point: Point) -> Option<char>

The char at the Point’s position

Source

pub fn strs(&self) -> [&str; 2]

The two &strs that compose the buffer

In order to iterate over them, I recommend using the flat_map method:

let text = Text::new();
text.strs().into_iter().flat_map(str::chars);

Do note that you should avoid iterators like str::lines, as they will separate the line that is partially owned by each &str:

let broken_up_line = [
    "This is line 1, business as usual This is line 2, but it",
    "is broken into two separate strings So 4 lines would be counted, \
     instead of 3",
];

If you want the two &strs in a range, see strs_in

Source

pub fn strs_in(&self, range: impl TextRange) -> IntoIter<&str, 2>

Returns 2 &strs in the given range

§Note

The reason why this function returns two strings is that the contents of the text are stored in a GapBuffer, which works with two strings.

If you want to iterate over them, you can do the following:

let text = Text::new();
text.strs_in((p1, p2)).flat_map(str::bytes);

Do note that you should avoid iterators like str::lines, as they will separate the line that is partially owned by each &str:

let broken_up_line = [
    "This is line 1, business as usual.\nThis is line 2, but it",
    "is broken into two separate strings.\nSo 4 lines would be counted, \
     instead of 3",
];

§`TextRange` behavior:

If you give a single usize/Point, it will be interpreted as a range from.

If you want the two full &strs, see strs

Source

pub fn lines_in( &mut self, range: impl TextRange, ) -> impl DoubleEndedIterator<Item = (usize, &str)>

Returns an iterator over the lines in a given range

The lines are inclusive, that is, it will iterate over the whole line, not just the parts within the range.

Source

pub fn ts_parser(&self) -> Option<&TsParser>

Returns the TsParser, if there is one

This parser uses tree-sitter internally for things like syntax highlighing and indentation, but it have all sorts of utilities in user code as well.

Source

pub fn ts_indent_on(&mut self, p: Point, cfg: PrintCfg) -> Option<usize>

Gets the indentation on a given Point

Will either return the required indentation (in spaces) or None, in which case the caller will have to decide how to proceed. This usually means “keep previous level of indentation”.

Source

pub fn point_at(&self, at: usize) -> Point

The Point corresponding to the byte position, 0 indexed

If the byte position would fall in between two characters (because the first one comprises more than one byte), the first character is chosen as the Point where the byte is located.

§Panics

Will panic if at is greater than the length of the text

Source

pub fn point_at_char(&self, at: usize) -> Point

The Point associated with a char position, 0 indexed

§Panics

Will panic if at is greater than the number of chars in the text.

Source

pub fn point_at_line(&self, at: usize) -> Point

The Point where the atth line starts, 0 indexed

If at == number_of_lines, returns the last point of the text.

§Panics

Will panic if the number at is greater than the number of lines on the text

Source

pub fn points_of_line(&self, at: usize) -> (Point, Point)

The start and end Points for a given at line

If at == number_of_lines, these points will be the same.

§Panics

Will panic if the number at is greater than the number of lines on the text

Source

pub fn len_points(&self) -> (Point, Option<Point>)

The points at the end of the text

This will essentially return the last point of the text, alongside the last possible Point of any Tag::GhostText at the end of the text.

Source

pub fn last_point(&self) -> Option<Point>

The last Point associated with a char

This will give the Point of the last char of the text. The difference between this method and len is that it will return a Point one position earlier than it. If the text is completely empty, it will return None.

Source

pub fn ghost_max_points_at(&self, at: usize) -> (Point, Option<Point>)

The maximum points in the atth byte

This point is essentially the point at that byte, plus the last possible Point of any Tag::GhostTexts in that position.

Source

pub fn points_after(&self, tp: impl TwoPoints) -> Option<(Point, Option<Point>)>

Points visually after the TwoPoints

If the TwoPoints in question is concealed, treats the next visible character as the first character, and returns the points of the next visible character.

This method is useful if you want to iterator reversibly right after a certain point, thus including the character of said point.

Source

pub fn visual_line_start(&self, p: impl TwoPoints) -> (Point, Option<Point>)

The visual start of the line

This point is defined not by where the line actually begins, but by where the last ‘\n’ was located. For example, if Tags create ghost text or omit text from multiple different lines, this point may differ from where in the Text the physical line actually begins.

Source

pub fn replace_range(&mut self, range: impl TextRange, edit: impl ToString)

Replaces a range in the Text

§`TextRange` behavior:

If you give a single usize/Point, it will be interpreted as a range from.

Source

pub fn apply_change( &mut self, guess_i: Option<usize>, change: Change<String>, ) -> Option<usize>

Source

pub fn update_range(&mut self, range: (Point, Point))

This is used by Areas in order to update visible text

In order to not update too much, an Area will request that a region of the Text (usually roughly what is shown on screen) to be updated, rather than the whole Text.

This should be done within the Area::print and Area::print_with functions.

Source

pub fn needs_update(&self) -> bool

Source

pub fn undo(&mut self, area: &impl Area, cfg: PrintCfg)

Undoes the last moment, if there was one

Source

pub fn redo(&mut self, area: &impl Area, cfg: PrintCfg)

Redoes the last moment in the history, if there is one

Source

pub fn apply_and_process_changes( &mut self, changes: &[Change<&str>], cursors_to_remake: Option<(&impl Area, &mut Cursors, PrintCfg)>, )

Source

pub fn new_moment(&mut self)

Finishes the current moment and adds a new one to the history

Source

pub fn to_string(&self) -> String

Clones the inner GapBuffer as a String

This function will also cut out a final ‘\n’ from the string.

Source

pub fn write_to(&self, writer: impl Write) -> Result<usize>

Writes the contents of this Text to a writer

Source

pub fn has_unsaved_changes(&self) -> bool

Wether or not the content has changed since the last write

Returns true only if the actual bytes of the Text have been changed, ignoring Tags and all the other things, since those are not written to the filesystem.

Source

pub fn insert_tag(&mut self, at: usize, tag: Tag, key: Key)

Inserts a Tag at the given position

Source

pub fn remove_tags(&mut self, range: impl TextRange, keys: impl Keys)

Removes the Tags of a key from a region

§Caution

While it is fine to do this on your own widgets, you should refrain from using this function in a Files Text, as it must iterate over all tags in the file, so if there are a lot of other tags, this operation may be slow.