Struct Text

pub struct Text(/* private fields */);

The text of a given Widget

The Text is the backbone of Duat. It is the thing responsible for everything that shows up on screen.

You can build a Text manually, by using Text::new, or with some convenience, by using the txt! macro, making use of a Builder.

Implementations

impl Text

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

Searches forward for a RegexPattern in a range

A RegexPattern can either be a single regex string, an array of strings, or a slice of strings. When there are more than one pattern, The return value will include which pattern matched.

The patterns will also automatically be cached, so you don’t need to do that.

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

Searches in reverse for a RegexPattern in a range

A RegexPattern can either be a single regex string, an array of strings, or a slice of strings. When there are more than one pattern, The return value will include which pattern matched.

The patterns will also automatically be cached, so you don’t need to do that.

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.

impl Text

pub fn new() -> Self

Returns a new empty Text

pub fn new_with_selections() -> Self

Returns a new empty Text with Selections enabled

pub fn builder() -> Builder

Returns a Builder for Text

This builder can be used to iteratively create text, by assuming that the user wants no* Tag overlap, and that they want to construct the Text in Tag/content pairs.

use duat_core::prelude::*;
let mut builder = Text::builder();

pub fn len(&self) -> Point

The Point at the end of the text

pub fn is_empty(&self) -> bool

Whether or not there are any characters in the Text

This ignores the last '\n' in the Text, since it is always there no matter what.

This does not check for tags, so with a Ghost, there could actually be a “string” of characters on the Text, it just wouldn’t be considered real “text”. If you want to make sure it is indeed empty, see is_empty_empty.

pub fn is_empty_empty(&self) -> bool

Whether the Bytes and Tags are empty

This ignores the last '\n' in the Text, since it is always there no matter what.

If you only want to check for the Bytes, ignoring possible Ghosts, see is_empty.

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

The char at the Point’s position

pub fn buffers(&self, range: impl TextRange) -> Buffers<'_>

An Iterator over the bytes of the Text

pub fn strs(&self, range: impl TextRange) -> Strs<'_>

An Iterator over the &strs of the Text

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(p1..p2).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.\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.

pub fn lines(&self, range: impl TextRange) -> Lines<'_>

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.

pub fn bytes(&self) -> &Bytes

The inner bytes of the Text

pub fn bytes_mut(&mut self) -> &mut Bytes

The inner bytes of the Text, mutably

Do note that this mutability isn’t actually for modifying the Bytes themselves, but instead it is used by some methods to read said bytes, like make_contiguous or lines

pub fn bytes_and_tags(&mut self) -> (&mut Bytes, MutTags<'_>)

The &mut Bytes and MutTags

pub fn indent(&self, p: Point, area: &impl RawArea, cfg: PrintCfg) -> usize

Gets the indentation level on the current line

pub fn point_at(&self, b: 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 b is greater than the length of the text

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

The Point associated with a char position, 0 indexed

Panics

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

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

The Point where the lth line starts, 0 indexed

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

Panics

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

pub fn points_of_line(&self, l: usize) -> [Point; 2]

The start and end Points for a given l line

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

Panics

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

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 Ghost at the end of the text.

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.

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 Ghosts in that position.

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.

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.

pub fn get_ghost(&self, id: GhostId) -> Option<&Text>

Gets the Ghost of a given GhostId

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.

pub fn update_bounds(&mut self)

Updates bounds, so that Tag ranges can visibly cross the screen

This is used in order to allow for very long Tag ranges (say, a Form being applied on the range 3..999) to show up properly without having to lookback a bazillion Tags which could be in the way.

pub fn insert_text(&mut self, p: Point, text: Text)

Inserts a Text into this Text, in a specific Point

pub fn undo(&mut self)

Undoes the last moment, if there was one

pub fn redo(&mut self)

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

pub fn new_moment(&mut self)

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

pub fn last_unprocessed_moment(&mut self) -> Option<Vec<Moment>>

Returns a Moment containing all Changes since the last call to this function

This is useful if you want to figure out what has changed after a certain period of time has passed.

pub fn to_string(&self) -> String

Clones the inner Bytes as a String

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

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

Writes the contents of this Text to a writer

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.

pub fn insert_tag<R>(&mut self, tagger: Tagger, r: R, tag: impl Tag<R>)

Inserts a Tag at the given position

pub fn remove_tags(&mut self, keys: impl Taggers, range: impl TextRangeOrPoint)

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.

TextRange behavior

If you give it a Point or usize, it will be treated as a one byte range.

pub fn clear_tags(&mut self)

Removes all Tags

Refrain from using this function on Files, as there may be other Tag providers, and you should avoid messing with their tags.

pub fn enable_selections(&mut self)

Enables the usage of Selections in this Text

This is automatically done whenever you use the cursor editing functions of a Handle.

pub fn no_selections(self) -> Selectionless

Returns a Text without Selections

You should use this if you want to send the Text across threads.

pub fn iter_fwd(&self, at: impl TwoPoints) -> FwdIter<'_>

A forward iterator of the chars and tags of the Text

pub fn iter_rev(&self, at: impl TwoPoints) -> RevIter<'_>

A reverse iterator of the chars and tags of the Text

pub fn chars_fwd(&self, p: Point) -> impl Iterator<Item = (Point, char)> + '_

A forward iterator of the chars of the Text

Each char will be accompanied by a Point, which is the position where said character starts, e.g. Point::default() for the first character

pub fn chars_rev(&self, p: Point) -> impl Iterator<Item = (Point, char)> + '_

A reverse iterator of the chars of the Text

Each char will be accompanied by a Point, which is the position where said character starts, e.g. Point::default() for the first character

pub fn tags_fwd( &self, b: usize, ) -> Peekable<impl Iterator<Item = (usize, RawTag)> + Clone + 'a>

A forward iterator over the Tags of the Text

This iterator will consider some Tags before b, since their ranges may overlap with b

Note

Duat works fine with Tags in the middle of a codepoint, but external utilizers may not, so keep that in mind.

pub fn tags_rev( &self, b: usize, ) -> Peekable<impl Iterator<Item = (usize, RawTag)> + Clone + 'a>

An reverse iterator over the Tags of the Text

This iterator will consider some Tags ahead of b, since their ranges may overlap with b

Note

Duat works fine with Tags in the middle of a codepoint, but external utilizers may not, so keep that in mind.

pub fn raw_tags_fwd(&self, b: usize) -> impl Iterator<Item = (usize, RawTag)>

A forward Iterator over the RawTags

This Iterator does not take into account Tag ranges that intersect with the starting point, unlike Text::tags_fwd

pub fn raw_tags_rev(&self, b: usize) -> impl Iterator<Item = (usize, RawTag)>

A reverse Iterator over the RawTags

This Iterator does not take into account Tag ranges that intersect with the starting point, unlike Text::tags_rev

pub fn selections(&self) -> Option<&Selections>

The Selections printed to this Text, if they exist

pub fn selections_mut(&mut self) -> Option<&mut Selections>

A mut reference to this Text’s Selections if they exist

pub fn contiguous(&mut self, range: impl TextRange) -> &str

Gets a single &str from a given range

This is the equivalent of calling Bytes::make_contiguous and Bytes::get_contiguous. While this takes less space in code, calling the other two functions means that you won’t be mutably borrowing the Bytes anymore, so if that matters to you, you should do that.

pub fn make_contiguous(&mut self, range: impl TextRange)

Moves the GapBuffer’s gap, so that the range is whole

The return value is the value of the gap, if the second &str is the contiguous one.

pub fn get_contiguous(&self, range: impl TextRange) -> Option<&str>

Assumes that the range given is contiguous in self

You MUST call make_contiguous before using this function. The sole purpose of this function is to not keep the Bytes mutably borrowed.

Trait Implementations

impl Clone for Text

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Text

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

Formats the value using the given formatter.

impl Default for Text

fn default() -> Self

Returns the “default value” for a type.

impl From<&PathBuf> for Text

fn from(value: &PathBuf) -> Self

Converts to this type from the input type.

impl From<&str> for Text

fn from(value: &str) -> Self

Converts to this type from the input type.

impl From<Arc<str>> for Text

fn from(value: Arc<str>) -> Self

Converts to this type from the input type.

impl From<Box<dyn Error>> for Text

fn from(value: Box<dyn Error>) -> Self

Converts to this type from the input type.

impl From<Box<str>> for Text

fn from(value: Box<str>) -> Self

Converts to this type from the input type.

impl From<Builder> for Text

fn from(value: Builder) -> Self

Converts to this type from the input type.

impl From<Error> for Text

fn from(value: Error) -> Self

Converts to this type from the input type.

impl From<Rc<str>> for Text

fn from(value: Rc<str>) -> Self

Converts to this type from the input type.

impl From<Selectionless> for Text

fn from(value: Selectionless) -> Self

Converts to this type from the input type.

impl From<String> for Text

fn from(value: String) -> Self

Converts to this type from the input type.

impl From<Text> for BuilderPart

fn from(value: Text) -> Self

Converts to this type from the input type.

impl From<char> for Text

fn from(value: char) -> Self

Converts to this type from the input type.

impl From<f32> for Text

fn from(value: f32) -> Self

Converts to this type from the input type.

impl From<f64> for Text

fn from(value: f64) -> Self

Converts to this type from the input type.

impl From<i128> for Text

fn from(value: i128) -> Self

Converts to this type from the input type.

impl From<i16> for Text

fn from(value: i16) -> Self

Converts to this type from the input type.

impl From<i32> for Text

fn from(value: i32) -> Self

Converts to this type from the input type.

impl From<i64> for Text

fn from(value: i64) -> Self

Converts to this type from the input type.

impl From<i8> for Text

fn from(value: i8) -> Self

Converts to this type from the input type.

impl From<isize> for Text

fn from(value: isize) -> Self

Converts to this type from the input type.

impl From<u128> for Text

fn from(value: u128) -> Self

Converts to this type from the input type.

impl From<u16> for Text

fn from(value: u16) -> Self

Converts to this type from the input type.

impl From<u32> for Text

fn from(value: u32) -> Self

Converts to this type from the input type.

impl From<u64> for Text

fn from(value: u64) -> Self

Converts to this type from the input type.

impl From<u8> for Text

fn from(value: u8) -> Self

Converts to this type from the input type.

impl From<usize> for Text

fn from(value: usize) -> Self

Converts to this type from the input type.

impl PartialEq<&str> for Text

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

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

const 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 PartialEq<String> for Text

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

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

const 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 PartialEq for Text

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

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

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

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