Struct TextBuffer

pub struct TextBuffer { /* private fields */ }

Wraps a text buffer. The buffer is automatically cleaned up when the last reference is dropped.

Implementations

impl TextBuffer

pub unsafe fn delete(buf: Self)

Deletes the TextBuffer

Safety

The buffer shouldn’t be deleted while the Display widget still needs it

pub unsafe fn delete_buffer(buf: Self)

Deletes the TextBuffer

Safety

The buffer shouldn’t be deleted while the Display widget still needs it

pub unsafe fn from_ptr(ptr: *mut Fl_Text_Buffer) -> Self

Initializes a text buffer from a pointer

Safety

The pointer must be valid and this TextBuffer will take ownership of it

pub fn as_ptr(&self) -> *mut Fl_Text_Buffer

Returns the inner pointer from a text buffer

Safety

The returned pointer is valid as long as this TextBuffer or any of its clones exist

pub fn set_text(&mut self, txt: &str)

Sets the text of the buffer

Examples found in repository

examples/editor.rs (line 203)

fn menu_cb(m: &mut impl MenuExt) {
    if let Ok(mpath) = m.item_pathname(None) {
        let ed: text::TextEditor = app::widget_from_id("ed").unwrap();
        match mpath.as_str() {
            "&File/&New...\t" => {
                STATE.with(|s| {
                    if !s.buf.text().is_empty() {
                        let c = dialog::choice(
                            "Are you sure you want to clear the buffer?",
                            "&Yes",
                            "&No",
                            "",
                        );
                        if c == Some(0) {
                            s.buf.set_text("");
                            s.saved = false;
                        }
                    }
                });
            }
            "&File/&Open...\t" => {
                if let Some(c) = nfc_get_file(dialog::NativeFileChooserType::BrowseFile) {
                    if let Ok(text) = std::fs::read_to_string(&c) {
                        STATE.with(move |s| {
                            s.buf.set_text(&text);
                            s.saved = false;
                            s.current_file = c.clone();
                        });
                    }
                }
            }
            "&File/&Save\t" => {
                STATE.with(|s| {
                    if !s.saved && s.current_file.exists() {
                        std::fs::write(&s.current_file, s.buf.text()).ok();
                    }
                });
            }
            "&File/Save &as...\t" => {
                if let Some(c) = nfc_get_file(dialog::NativeFileChooserType::BrowseSaveFile) {
                    STATE.with(move |s| {
                        std::fs::write(&c, s.buf.text()).ok();
                        s.saved = true;
                        s.current_file = c.clone();
                    });
                }
            }
            "&File/&Quit\t" => quit_cb(),
            "&Edit/Cu&t\t" => ed.cut(),
            "&Edit/&Copy\t" => ed.copy(),
            "&Edit/&Paste\t" => ed.paste(),
            "&Help/&About\t" => dialog::message("A minimal text editor written using fltk-rs!"),
            _ => unreachable!(),
        }
    }
}

examples/editor2.rs (line 400)

    pub fn launch(&mut self) {
        while self.app.wait() {
            use Message::*;
            if let Some(msg) = self.r.recv() {
                match msg {
                    Changed => {
                        if !self.modified {
                            self.modified = true;
                            self.menu
                                .menu
                                .find_item("&File/&Save\t")
                                .unwrap()
                                .activate();
                            self.menu
                                .menu
                                .find_item("&File/&Quit\t")
                                .unwrap()
                                .set_label_color(Color::Red);
                            let name = match &self.filename {
                                Some(f) => f.to_string_lossy().to_string(),
                                None => "(Untitled)".to_string(),
                            };
                            self.main_win.set_label(&format!("* {name} - RustyEd"));
                        }
                    }
                    New => {
                        if self.buf.text() != "" {
                            let clear = if let Some(x) = dialog::choice(
                                "File unsaved, Do you wish to continue?",
                                "&Yes",
                                "&No!",
                                "",
                            ) {
                                x == 0
                            } else {
                                false
                            };
                            if clear {
                                self.buf.set_text("");
                            }
                        }
                    }
                    Open => {
                        if let Some(c) = nfc_get_file(dialog::NativeFileChooserType::BrowseFile) {
                            if c.exists() {
                                match self.buf.load_file(&c) {
                                    Ok(_) => self.filename = Some(c),
                                    Err(e) => dialog::alert(&format!(
                                        "An issue occured while loading the file: {e}"
                                    )),
                                }
                            } else {
                                dialog::alert("File does not exist!")
                            }
                        }
                    }
                    Save => {
                        self.save_file().unwrap();
                    }
                    SaveAs => {
                        self.save_file_as().unwrap();
                    }
                    Print => {
                        let mut printer = printer::Printer::default();
                        if printer.begin_job(0).is_ok() {
                            let (w, h) = printer.printable_rect();
                            self.printable.resize(
                                self.printable.x(),
                                self.printable.y(),
                                w - 40,
                                h - 40,
                            );
                            // Needs cleanup
                            let line_count = self.printable.count_lines(
                                0,
                                self.printable.buffer().unwrap().length(),
                                true,
                            ) / 45;
                            for i in 0..=line_count {
                                self.printable.scroll(45 * i, 0);
                                printer.begin_page().ok();
                                printer.print_widget(&self.printable, 20, 20);
                                printer.end_page().ok();
                            }
                            printer.end_job();
                        }
                    }
                    Quit => {
                        if self.modified {
                            match dialog::choice(
                                "Would you like to save your work?",
                                "&Yes",
                                "&No",
                                "",
                            ) {
                                Some(0) => {
                                    if self.save_file().unwrap() {
                                        self.app.quit();
                                    }
                                }
                                Some(1) => self.app.quit(),
                                Some(_) | None => (),
                            }
                        } else {
                            self.app.quit();
                        }
                    }
                    Cut => self.editor.cut(),
                    Copy => self.editor.copy(),
                    Paste => self.editor.paste(),
                    About => dialog::message(
                        "This is an example application written in Rust and using the FLTK Gui library.",
                    ),
                }
            }
        }
    }

pub fn text(&self) -> String

Returns the text of the buffer

Examples found in repository

examples/editor.rs (line 195)

fn menu_cb(m: &mut impl MenuExt) {
    if let Ok(mpath) = m.item_pathname(None) {
        let ed: text::TextEditor = app::widget_from_id("ed").unwrap();
        match mpath.as_str() {
            "&File/&New...\t" => {
                STATE.with(|s| {
                    if !s.buf.text().is_empty() {
                        let c = dialog::choice(
                            "Are you sure you want to clear the buffer?",
                            "&Yes",
                            "&No",
                            "",
                        );
                        if c == Some(0) {
                            s.buf.set_text("");
                            s.saved = false;
                        }
                    }
                });
            }
            "&File/&Open...\t" => {
                if let Some(c) = nfc_get_file(dialog::NativeFileChooserType::BrowseFile) {
                    if let Ok(text) = std::fs::read_to_string(&c) {
                        STATE.with(move |s| {
                            s.buf.set_text(&text);
                            s.saved = false;
                            s.current_file = c.clone();
                        });
                    }
                }
            }
            "&File/&Save\t" => {
                STATE.with(|s| {
                    if !s.saved && s.current_file.exists() {
                        std::fs::write(&s.current_file, s.buf.text()).ok();
                    }
                });
            }
            "&File/Save &as...\t" => {
                if let Some(c) = nfc_get_file(dialog::NativeFileChooserType::BrowseSaveFile) {
                    STATE.with(move |s| {
                        std::fs::write(&c, s.buf.text()).ok();
                        s.saved = true;
                        s.current_file = c.clone();
                    });
                }
            }
            "&File/&Quit\t" => quit_cb(),
            "&Edit/Cu&t\t" => ed.cut(),
            "&Edit/&Copy\t" => ed.copy(),
            "&Edit/&Paste\t" => ed.paste(),
            "&Help/&About\t" => dialog::message("A minimal text editor written using fltk-rs!"),
            _ => unreachable!(),
        }
    }
}

examples/editor2.rs (line 388)

    pub fn launch(&mut self) {
        while self.app.wait() {
            use Message::*;
            if let Some(msg) = self.r.recv() {
                match msg {
                    Changed => {
                        if !self.modified {
                            self.modified = true;
                            self.menu
                                .menu
                                .find_item("&File/&Save\t")
                                .unwrap()
                                .activate();
                            self.menu
                                .menu
                                .find_item("&File/&Quit\t")
                                .unwrap()
                                .set_label_color(Color::Red);
                            let name = match &self.filename {
                                Some(f) => f.to_string_lossy().to_string(),
                                None => "(Untitled)".to_string(),
                            };
                            self.main_win.set_label(&format!("* {name} - RustyEd"));
                        }
                    }
                    New => {
                        if self.buf.text() != "" {
                            let clear = if let Some(x) = dialog::choice(
                                "File unsaved, Do you wish to continue?",
                                "&Yes",
                                "&No!",
                                "",
                            ) {
                                x == 0
                            } else {
                                false
                            };
                            if clear {
                                self.buf.set_text("");
                            }
                        }
                    }
                    Open => {
                        if let Some(c) = nfc_get_file(dialog::NativeFileChooserType::BrowseFile) {
                            if c.exists() {
                                match self.buf.load_file(&c) {
                                    Ok(_) => self.filename = Some(c),
                                    Err(e) => dialog::alert(&format!(
                                        "An issue occured while loading the file: {e}"
                                    )),
                                }
                            } else {
                                dialog::alert("File does not exist!")
                            }
                        }
                    }
                    Save => {
                        self.save_file().unwrap();
                    }
                    SaveAs => {
                        self.save_file_as().unwrap();
                    }
                    Print => {
                        let mut printer = printer::Printer::default();
                        if printer.begin_job(0).is_ok() {
                            let (w, h) = printer.printable_rect();
                            self.printable.resize(
                                self.printable.x(),
                                self.printable.y(),
                                w - 40,
                                h - 40,
                            );
                            // Needs cleanup
                            let line_count = self.printable.count_lines(
                                0,
                                self.printable.buffer().unwrap().length(),
                                true,
                            ) / 45;
                            for i in 0..=line_count {
                                self.printable.scroll(45 * i, 0);
                                printer.begin_page().ok();
                                printer.print_widget(&self.printable, 20, 20);
                                printer.end_page().ok();
                            }
                            printer.end_job();
                        }
                    }
                    Quit => {
                        if self.modified {
                            match dialog::choice(
                                "Would you like to save your work?",
                                "&Yes",
                                "&No",
                                "",
                            ) {
                                Some(0) => {
                                    if self.save_file().unwrap() {
                                        self.app.quit();
                                    }
                                }
                                Some(1) => self.app.quit(),
                                Some(_) | None => (),
                            }
                        } else {
                            self.app.quit();
                        }
                    }
                    Cut => self.editor.cut(),
                    Copy => self.editor.copy(),
                    Paste => self.editor.paste(),
                    About => dialog::message(
                        "This is an example application written in Rust and using the FLTK Gui library.",
                    ),
                }
            }
        }
    }

pub fn append(&mut self, text: &str)

Appends to the buffer. To append and scroll to the end of the buffer:

use fltk::{prelude::*, *};
let txt = "Some long text!";
let buf = text::TextBuffer::default();
let mut disp = text::TextDisplay::default();
disp.set_buffer(Some(buf));
disp.buffer().unwrap().append(txt);
disp.set_insert_position(disp.buffer().unwrap().length());
disp.scroll(
    disp.count_lines(0, disp.buffer().unwrap().length(), true),
    0,
);

pub fn append_bytes(&mut self, text: &[u8])

Append bytes to the buffer

pub fn length(&self) -> i32

Get the length of the buffer

Examples found in repository

examples/editor2.rs (line 437)

    pub fn launch(&mut self) {
        while self.app.wait() {
            use Message::*;
            if let Some(msg) = self.r.recv() {
                match msg {
                    Changed => {
                        if !self.modified {
                            self.modified = true;
                            self.menu
                                .menu
                                .find_item("&File/&Save\t")
                                .unwrap()
                                .activate();
                            self.menu
                                .menu
                                .find_item("&File/&Quit\t")
                                .unwrap()
                                .set_label_color(Color::Red);
                            let name = match &self.filename {
                                Some(f) => f.to_string_lossy().to_string(),
                                None => "(Untitled)".to_string(),
                            };
                            self.main_win.set_label(&format!("* {name} - RustyEd"));
                        }
                    }
                    New => {
                        if self.buf.text() != "" {
                            let clear = if let Some(x) = dialog::choice(
                                "File unsaved, Do you wish to continue?",
                                "&Yes",
                                "&No!",
                                "",
                            ) {
                                x == 0
                            } else {
                                false
                            };
                            if clear {
                                self.buf.set_text("");
                            }
                        }
                    }
                    Open => {
                        if let Some(c) = nfc_get_file(dialog::NativeFileChooserType::BrowseFile) {
                            if c.exists() {
                                match self.buf.load_file(&c) {
                                    Ok(_) => self.filename = Some(c),
                                    Err(e) => dialog::alert(&format!(
                                        "An issue occured while loading the file: {e}"
                                    )),
                                }
                            } else {
                                dialog::alert("File does not exist!")
                            }
                        }
                    }
                    Save => {
                        self.save_file().unwrap();
                    }
                    SaveAs => {
                        self.save_file_as().unwrap();
                    }
                    Print => {
                        let mut printer = printer::Printer::default();
                        if printer.begin_job(0).is_ok() {
                            let (w, h) = printer.printable_rect();
                            self.printable.resize(
                                self.printable.x(),
                                self.printable.y(),
                                w - 40,
                                h - 40,
                            );
                            // Needs cleanup
                            let line_count = self.printable.count_lines(
                                0,
                                self.printable.buffer().unwrap().length(),
                                true,
                            ) / 45;
                            for i in 0..=line_count {
                                self.printable.scroll(45 * i, 0);
                                printer.begin_page().ok();
                                printer.print_widget(&self.printable, 20, 20);
                                printer.end_page().ok();
                            }
                            printer.end_job();
                        }
                    }
                    Quit => {
                        if self.modified {
                            match dialog::choice(
                                "Would you like to save your work?",
                                "&Yes",
                                "&No",
                                "",
                            ) {
                                Some(0) => {
                                    if self.save_file().unwrap() {
                                        self.app.quit();
                                    }
                                }
                                Some(1) => self.app.quit(),
                                Some(_) | None => (),
                            }
                        } else {
                            self.app.quit();
                        }
                    }
                    Cut => self.editor.cut(),
                    Copy => self.editor.copy(),
                    Paste => self.editor.paste(),
                    About => dialog::message(
                        "This is an example application written in Rust and using the FLTK Gui library.",
                    ),
                }
            }
        }
    }

pub fn remove(&mut self, start: i32, end: i32)

Removes from the buffer

pub fn text_range(&self, start: i32, end: i32) -> Option<String>

Returns the text within the range

pub fn insert(&mut self, pos: i32, text: &str)

Inserts text into a position

pub fn replace(&mut self, start: i32, end: i32, text: &str)

Replaces text from position start to end

pub fn copy_from( &mut self, source_buf: &TextBuffer, start: i32, end: i32, to: i32, )

Copies text from a source buffer into the current buffer

pub fn copy(&self) -> TextBuffer

Copies whole text from a source buffer into a new buffer

pub fn undo(&mut self) -> Result<(), FltkError>

Performs an undo operation on the buffer

Errors

Errors on failure to undo

pub fn redo(&mut self) -> Result<i32, FltkError>

Performs a redo operation on the buffer. Returns the cursor position.

Errors

Errors on failure to undo

pub fn can_undo(&mut self, flag: bool)

Sets whether the buffer can undo

pub fn get_can_undo(&mut self) -> bool

Gets whether the buffer can undo

pub fn can_redo(&mut self) -> bool

Gets whether the buffer can redo

pub fn load_file<P: AsRef<Path>>(&mut self, path: P) -> Result<(), FltkError>

Loads a file into the buffer

Errors

Errors on failure to load file

Examples found in repository

examples/editor.rs (line 164)

fn handle_drag_drop(editor: &mut text::TextEditor) {
    editor.handle({
        let mut dnd = false;
        let mut released = false;
        let buf = editor.buffer().unwrap();
        move |_, ev| match ev {
            Event::DndEnter => {
                dnd = true;
                true
            }
            Event::DndDrag => true,
            Event::DndRelease => {
                released = true;
                true
            }
            Event::Paste => {
                if dnd && released {
                    let path = app::event_text().unwrap();
                    let path = path.trim();
                    let path = path.replace("file://", "");
                    let path = std::path::PathBuf::from(&path);
                    if path.exists() {
                        // we use a timeout to avoid pasting the path into the buffer
                        app::add_timeout(0.0, {
                            let mut buf = buf.clone();
                            move |_| match buf.load_file(&path) {
                                Ok(_) => (),
                                Err(e) => dialog::alert(&format!(
                                    "An issue occured while loading the file: {e}"
                                )),
                            }
                        });
                    }
                    dnd = false;
                    released = false;
                    true
                } else {
                    false
                }
            }
            Event::DndLeave => {
                dnd = false;
                released = false;
                true
            }
            _ => false,
        }
    });
}

examples/editor2.rs (line 230)

    pub fn new(args: Vec<String>) -> Self {
        let app = app::App::default().with_scheme(app::Scheme::Gtk);
        app::background(211, 211, 211);
        let (s, r) = app::channel::<Message>();
        let mut buf = text::TextBuffer::default();
        buf.set_tab_distance(4);
        let mut main_win = window::Window::default()
            .with_size(800, 600)
            .with_label("RustyEd");
        main_win.set_center_screen();
        let menu = MyMenu::new(&s);
        let modified = false;
        menu.menu.find_item("&File/&Save\t").unwrap().deactivate();
        let mut editor = MyEditor::new(buf.clone());
        editor.emit(s, Message::Changed);
        main_win.make_resizable(true);
        // only resize editor, not the menu bar
        main_win.resizable(&*editor);
        main_win.end();
        main_win.show();
        main_win.set_callback(move |_| {
            if app::event() == Event::Close {
                s.send(Message::Quit);
            }
        });
        let filename = if args.len() > 1 {
            let file = path::Path::new(&args[1]);
            assert!(
                file.exists() && file.is_file(),
                "An error occurred while opening the file!"
            );
            match buf.load_file(&args[1]) {
                Ok(_) => Some(PathBuf::from(args[1].clone())),
                Err(e) => {
                    dialog::alert(&format!("An issue occured while loading the file: {e}"));
                    None
                }
            }
        } else {
            None
        };

        // Handle drag and drop
        editor.handle({
            let mut dnd = false;
            let mut released = false;
            let buf = buf.clone();
            move |_, ev| match ev {
                Event::DndEnter => {
                    dnd = true;
                    true
                }
                Event::DndDrag => true,
                Event::DndRelease => {
                    released = true;
                    true
                }
                Event::Paste => {
                    if dnd && released {
                        let path = app::event_text().unwrap();
                        let path = path.trim();
                        let path = path.replace("file://", "");
                        let path = std::path::PathBuf::from(&path);
                        if path.exists() {
                            // we use a timeout to avoid pasting the path into the buffer
                            app::add_timeout(0.0, {
                                let mut buf = buf.clone();
                                move |_| match buf.load_file(&path) {
                                    Ok(_) => (),
                                    Err(e) => dialog::alert(&format!(
                                        "An issue occured while loading the file: {e}"
                                    )),
                                }
                            });
                        }
                        dnd = false;
                        released = false;
                        true
                    } else {
                        false
                    }
                }
                Event::DndLeave => {
                    dnd = false;
                    released = false;
                    true
                }
                _ => false,
            }
        });

        // What shows when we attempt to print
        let mut printable = text::TextDisplay::default();
        printable.set_frame(FrameType::NoBox);
        printable.set_scrollbar_size(0);
        printable.set_buffer(Some(buf.clone()));

        Self {
            app,
            modified,
            filename,
            r,
            main_win,
            menu,
            buf,
            editor,
            printable,
        }
    }

    /** Called by "Save", test if file can be written, otherwise call save_file_as()
     * afterwards. Will return true if the file is succesfully saved. */
    pub fn save_file(&mut self) -> Result<bool, Box<dyn error::Error>> {
        match &self.filename {
            Some(f) => {
                self.buf.save_file(f)?;
                self.modified = false;
                self.menu
                    .menu
                    .find_item("&File/&Save\t")
                    .unwrap()
                    .deactivate();
                self.menu
                    .menu
                    .find_item("&File/&Quit\t")
                    .unwrap()
                    .set_label_color(Color::Black);
                let name = match &self.filename {
                    Some(f) => f.to_string_lossy().to_string(),
                    None => "(Untitled)".to_string(),
                };
                self.main_win.set_label(&format!("{name} - RustyEd"));
                Ok(true)
            }
            None => self.save_file_as(),
        }
    }

    /** Called by "Save As..." or by "Save" in case no file was set yet.
     * Returns true if the file was succesfully saved. */
    pub fn save_file_as(&mut self) -> Result<bool, Box<dyn error::Error>> {
        if let Some(c) = nfc_get_file(dialog::NativeFileChooserType::BrowseSaveFile) {
            self.buf.save_file(&c)?;
            self.modified = false;
            self.menu
                .menu
                .find_item("&File/&Save\t")
                .unwrap()
                .deactivate();
            self.menu
                .menu
                .find_item("&File/&Quit\t")
                .unwrap()
                .set_label_color(Color::Black);
            self.filename = Some(c);
            self.main_win
                .set_label(&format!("{:?} - RustyEd", self.filename.as_ref().unwrap()));
            Ok(true)
        } else {
            Ok(false)
        }
    }

    pub fn launch(&mut self) {
        while self.app.wait() {
            use Message::*;
            if let Some(msg) = self.r.recv() {
                match msg {
                    Changed => {
                        if !self.modified {
                            self.modified = true;
                            self.menu
                                .menu
                                .find_item("&File/&Save\t")
                                .unwrap()
                                .activate();
                            self.menu
                                .menu
                                .find_item("&File/&Quit\t")
                                .unwrap()
                                .set_label_color(Color::Red);
                            let name = match &self.filename {
                                Some(f) => f.to_string_lossy().to_string(),
                                None => "(Untitled)".to_string(),
                            };
                            self.main_win.set_label(&format!("* {name} - RustyEd"));
                        }
                    }
                    New => {
                        if self.buf.text() != "" {
                            let clear = if let Some(x) = dialog::choice(
                                "File unsaved, Do you wish to continue?",
                                "&Yes",
                                "&No!",
                                "",
                            ) {
                                x == 0
                            } else {
                                false
                            };
                            if clear {
                                self.buf.set_text("");
                            }
                        }
                    }
                    Open => {
                        if let Some(c) = nfc_get_file(dialog::NativeFileChooserType::BrowseFile) {
                            if c.exists() {
                                match self.buf.load_file(&c) {
                                    Ok(_) => self.filename = Some(c),
                                    Err(e) => dialog::alert(&format!(
                                        "An issue occured while loading the file: {e}"
                                    )),
                                }
                            } else {
                                dialog::alert("File does not exist!")
                            }
                        }
                    }
                    Save => {
                        self.save_file().unwrap();
                    }
                    SaveAs => {
                        self.save_file_as().unwrap();
                    }
                    Print => {
                        let mut printer = printer::Printer::default();
                        if printer.begin_job(0).is_ok() {
                            let (w, h) = printer.printable_rect();
                            self.printable.resize(
                                self.printable.x(),
                                self.printable.y(),
                                w - 40,
                                h - 40,
                            );
                            // Needs cleanup
                            let line_count = self.printable.count_lines(
                                0,
                                self.printable.buffer().unwrap().length(),
                                true,
                            ) / 45;
                            for i in 0..=line_count {
                                self.printable.scroll(45 * i, 0);
                                printer.begin_page().ok();
                                printer.print_widget(&self.printable, 20, 20);
                                printer.end_page().ok();
                            }
                            printer.end_job();
                        }
                    }
                    Quit => {
                        if self.modified {
                            match dialog::choice(
                                "Would you like to save your work?",
                                "&Yes",
                                "&No",
                                "",
                            ) {
                                Some(0) => {
                                    if self.save_file().unwrap() {
                                        self.app.quit();
                                    }
                                }
                                Some(1) => self.app.quit(),
                                Some(_) | None => (),
                            }
                        } else {
                            self.app.quit();
                        }
                    }
                    Cut => self.editor.cut(),
                    Copy => self.editor.copy(),
                    Paste => self.editor.paste(),
                    About => dialog::message(
                        "This is an example application written in Rust and using the FLTK Gui library.",
                    ),
                }
            }
        }
    }

pub fn save_file<P: AsRef<Path>>(&mut self, path: P) -> Result<(), FltkError>

Saves a buffer into a file

Errors

Errors on failure to save file

Examples found in repository

examples/editor2.rs (line 314)

    pub fn save_file(&mut self) -> Result<bool, Box<dyn error::Error>> {
        match &self.filename {
            Some(f) => {
                self.buf.save_file(f)?;
                self.modified = false;
                self.menu
                    .menu
                    .find_item("&File/&Save\t")
                    .unwrap()
                    .deactivate();
                self.menu
                    .menu
                    .find_item("&File/&Quit\t")
                    .unwrap()
                    .set_label_color(Color::Black);
                let name = match &self.filename {
                    Some(f) => f.to_string_lossy().to_string(),
                    None => "(Untitled)".to_string(),
                };
                self.main_win.set_label(&format!("{name} - RustyEd"));
                Ok(true)
            }
            None => self.save_file_as(),
        }
    }

    /** Called by "Save As..." or by "Save" in case no file was set yet.
     * Returns true if the file was succesfully saved. */
    pub fn save_file_as(&mut self) -> Result<bool, Box<dyn error::Error>> {
        if let Some(c) = nfc_get_file(dialog::NativeFileChooserType::BrowseSaveFile) {
            self.buf.save_file(&c)?;
            self.modified = false;
            self.menu
                .menu
                .find_item("&File/&Save\t")
                .unwrap()
                .deactivate();
            self.menu
                .menu
                .find_item("&File/&Quit\t")
                .unwrap()
                .set_label_color(Color::Black);
            self.filename = Some(c);
            self.main_win
                .set_label(&format!("{:?} - RustyEd", self.filename.as_ref().unwrap()));
            Ok(true)
        } else {
            Ok(false)
        }
    }

pub fn tab_distance(&self) -> i32

Returns the tab distance for the buffer

pub fn set_tab_distance(&mut self, tab_dist: i32)

Sets the tab distance

Examples found in repository

examples/editor.rs (line 251)

fn main() {
    let a = app::App::default().with_scheme(app::Scheme::Oxy);
    app::get_system_colors();

    let mut buf = text::TextBuffer::default();
    buf.set_tab_distance(4);

    let state = State::new(buf.clone());
    app::GlobalState::new(state);

    let mut w = window::Window::default()
        .with_size(WIDTH, HEIGHT)
        .with_label("Ted");
    w.set_xclass("ted");
    {
        let mut col = group::Flex::default_fill().column();
        col.set_pad(0);
        let mut m = menu::SysMenuBar::default();
        init_menu(&mut m);
        let mut ed = text::TextEditor::default().with_id("ed");
        ed.set_buffer(buf);
        ed.set_linenumber_width(40);
        ed.set_text_font(Font::Courier);
        ed.set_when(When::Changed);
        ed.set_callback(editor_cb);
        handle_drag_drop(&mut ed);
        w.resizable(&col);
        col.fixed(&m, 30);
        col.end();
    }
    w.end();
    w.show();
    w.set_callback(win_cb);
    a.run().unwrap();
}

examples/editor2.rs (line 204)

    pub fn new(args: Vec<String>) -> Self {
        let app = app::App::default().with_scheme(app::Scheme::Gtk);
        app::background(211, 211, 211);
        let (s, r) = app::channel::<Message>();
        let mut buf = text::TextBuffer::default();
        buf.set_tab_distance(4);
        let mut main_win = window::Window::default()
            .with_size(800, 600)
            .with_label("RustyEd");
        main_win.set_center_screen();
        let menu = MyMenu::new(&s);
        let modified = false;
        menu.menu.find_item("&File/&Save\t").unwrap().deactivate();
        let mut editor = MyEditor::new(buf.clone());
        editor.emit(s, Message::Changed);
        main_win.make_resizable(true);
        // only resize editor, not the menu bar
        main_win.resizable(&*editor);
        main_win.end();
        main_win.show();
        main_win.set_callback(move |_| {
            if app::event() == Event::Close {
                s.send(Message::Quit);
            }
        });
        let filename = if args.len() > 1 {
            let file = path::Path::new(&args[1]);
            assert!(
                file.exists() && file.is_file(),
                "An error occurred while opening the file!"
            );
            match buf.load_file(&args[1]) {
                Ok(_) => Some(PathBuf::from(args[1].clone())),
                Err(e) => {
                    dialog::alert(&format!("An issue occured while loading the file: {e}"));
                    None
                }
            }
        } else {
            None
        };

        // Handle drag and drop
        editor.handle({
            let mut dnd = false;
            let mut released = false;
            let buf = buf.clone();
            move |_, ev| match ev {
                Event::DndEnter => {
                    dnd = true;
                    true
                }
                Event::DndDrag => true,
                Event::DndRelease => {
                    released = true;
                    true
                }
                Event::Paste => {
                    if dnd && released {
                        let path = app::event_text().unwrap();
                        let path = path.trim();
                        let path = path.replace("file://", "");
                        let path = std::path::PathBuf::from(&path);
                        if path.exists() {
                            // we use a timeout to avoid pasting the path into the buffer
                            app::add_timeout(0.0, {
                                let mut buf = buf.clone();
                                move |_| match buf.load_file(&path) {
                                    Ok(_) => (),
                                    Err(e) => dialog::alert(&format!(
                                        "An issue occured while loading the file: {e}"
                                    )),
                                }
                            });
                        }
                        dnd = false;
                        released = false;
                        true
                    } else {
                        false
                    }
                }
                Event::DndLeave => {
                    dnd = false;
                    released = false;
                    true
                }
                _ => false,
            }
        });

        // What shows when we attempt to print
        let mut printable = text::TextDisplay::default();
        printable.set_frame(FrameType::NoBox);
        printable.set_scrollbar_size(0);
        printable.set_buffer(Some(buf.clone()));

        Self {
            app,
            modified,
            filename,
            r,
            main_win,
            menu,
            buf,
            editor,
            printable,
        }
    }

pub fn select(&mut self, start: i32, end: i32)

Selects the text from start to end

pub fn selected(&self) -> bool

Returns whether text is selected

pub fn unselect(&mut self)

Unselects text

pub fn selection_position(&self) -> Option<(i32, i32)>

Returns the selection position

pub fn selection_text(&self) -> String

Returns the selection text

pub fn remove_selection(&mut self)

Removes the selection

pub fn replace_selection(&mut self, text: &str)

Replaces selection

pub fn secondary_select(&mut self, start: i32, end: i32)

Secondary selects the text from start to end

pub fn secondary_selected(&self) -> bool

Returns whether text is secondary selected

pub fn secondary_unselect(&mut self)

Unselects text (secondary selection)

pub fn secondary_selection_position(&self) -> Option<(i32, i32)>

Returns the secondary selection position

pub fn secondary_selection_text(&self) -> String

Returns the secondary selection text

pub fn remove_secondary_selection(&mut self)

Removes the secondary selection

pub fn replace_secondary_selection(&mut self, text: &str)

Replaces the secondary selection

pub fn highlight(&mut self, start: i32, end: i32)

Highlights selection

pub fn is_highlighted(&self) -> bool

Returns whether text is highlighted

pub fn unhighlight(&mut self)

Unhighlights text

pub fn highlight_position(&self) -> Option<(i32, i32)>

Returns the highlight position

pub fn highlight_text(&self) -> String

Returns the highlighted text

pub fn line_text(&self, pos: i32) -> String

Returns the line at pos

pub fn line_start(&self, pos: i32) -> i32

Returns the index of the line’s start position at pos

pub fn word_start(&self, pos: i32) -> i32

Returns the index of the first character of a word at pos

pub fn word_end(&self, pos: i32) -> i32

Returns the index of the last character of a word at pos

pub fn count_lines(&self, start: i32, end: i32) -> i32

Counts the lines from start to end

pub fn call_modify_callbacks(&mut self)

Calls the modify callbacks

pub fn add_modify_callback<F: FnMut(i32, i32, i32, i32, &str) + 'static>( &mut self, cb: F, )

Adds a modify callback. callback args: pos: i32, inserted items: i32, deleted items: i32, restyled items: i32, deleted_text

pub fn remove_modify_callback<F: FnMut(i32, i32, i32, i32, &str) + 'static>( &mut self, cb: F, )

Removes a modify callback. callback args: pos: i32, inserted items: i32, deleted items: i32, restyled items: i32, deleted_text

pub fn search_forward( &self, start_pos: i32, search_string: &str, match_case: bool, ) -> Option<i32>

Forward search for a string

pub fn search_backward( &self, start_pos: i32, search_string: &str, match_case: bool, ) -> Option<i32>

Backward search for a string

pub fn find_char_forward( &self, start_pos: i32, search_char: char, ) -> Option<i32>

Forward search for a char

pub fn find_char_backward( &self, start_pos: i32, search_char: char, ) -> Option<i32>

Backward search for a char

Trait Implementations

impl Clone for TextBuffer

fn clone(&self) -> TextBuffer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TextBuffer

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

Formats the value using the given formatter.

impl Default for TextBuffer

fn default() -> TextBuffer

Initialized a default text buffer

impl Drop for TextBuffer

fn drop(&mut self)

Executes the destructor for this type.

impl PartialEq for TextBuffer

fn eq(&self, other: &Self) -> 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 Eq for TextBuffer

impl Send for TextBuffer

Available on non-crate feature single-threaded only.

impl Sync for TextBuffer

Available on non-crate feature single-threaded only.