Struct BufferUpdated 

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

Hookable: Triggers when a Buffer updates

This is triggered after a batch of writing calls to the Buffer, once per frame. This can happen after typing a key, calling a command, triggering hooks, or any other action with access to a Pass, which could be used to write to the Buffer.

Think of this is as a “last pass” on the Buffer, right before printing, where it can be adjusted given the modifications to it, like Changes and such.

As an example, here’s a hook that will highlight every non ascii character:

use duat::{
    prelude::*,
    text::{Bytes, Tags},
};

static TRACKER: BufferTracker = BufferTracker::new();

fn setup() {
    let tagger = Tagger::new();
    let tag = form::id_of!("non_ascii_char").to_tag(50);

    let highlight_non_ascii = move |tags: &mut Tags, bytes: &Bytes, range| {
        for (b, char) in bytes.strs(range).unwrap().char_indices() {
            if !char.is_ascii() {
                tags.insert(tagger, b..b + char.len_utf8(), tag);
            }
        }
    };

    hook::add::<BufferOpened>(move |pa, handle| {
        TRACKER.register_buffer(handle.write(pa));

        let mut parts = handle.text_parts(pa);
        let range = Point::default()..parts.bytes.len();
        highlight_non_ascii(&mut parts.tags, parts.bytes, range);
    });

    hook::add::<BufferUpdated>(move |pa, handle| {
        let mut parts = TRACKER.parts(handle.write(pa)).unwrap();

        for change in parts.changes {
            parts.tags.remove(tagger, change.added_range());
            highlight_non_ascii(&mut parts.tags, parts.bytes, change.added_range())
        }
    });
}

The BufferTracker will keep track of each registered Buffer, telling you about every new Change that took place since the last call to BufferTracker::parts. The BufferTracker::parts function works much like Text::parts, by separating the Bytes, Tags and Selections, letting you modify the tags, without permitting further edits to the Text.

This is a nice way to automatically keep track of the changes, and it will work even if the function isn’t called frequently.

Arguments

• The Buffer’s Handle

Trait Implementations

impl Hookable for BufferUpdated

type Input<'h> = &'h Handle

The arguments that are passed to each hook.

fn get_input<'h>(&'h mut self, _: &mut Pass) -> Self::Input<'h>

How to get the arguments from the Hookable

impl PartialEq<Handle> for BufferUpdated

fn eq(&self, other: &Handle) -> 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.