Struct TextEditor

pub struct TextEditor { /* private fields */ }

Creates an editable text display widget

Implementations

impl TextEditor

pub fn new<'a, T: Into<Option<&'a str>>>( x: i32, y: i32, width: i32, height: i32, title: T, ) -> TextEditor

Creates a new widget, takes an x, y coordinates, as well as a width and height, plus a title

Arguments

• x - The x coordinate in the screen
• y - The y coordinate in the screen
• width - The width of the widget
• heigth - The height of the widget
• title - The title or label of the widget

To use dynamic strings use with_label(self, &str) or set_label(&mut self, &str). labels support special symbols preceded by an @ sign and for the associated formatting.

Examples found in repository

examples/editor2.rs (line 64)

    pub fn new(buf: text::TextBuffer) -> Self {
        let mut editor = text::TextEditor::new(5, 35, 790, 560, "");
        editor.set_buffer(Some(buf));

        #[cfg(target_os = "macos")]
        editor.resize(5, 5, 790, 590);

        editor.set_scrollbar_size(15);
        editor.set_text_font(Font::Courier);
        editor.set_linenumber_width(32);
        editor.set_linenumber_fgcolor(Color::from_u32(0x008b_8386));
        editor.set_when(When::Changed);

        Self { editor }
    }

pub fn default_fill() -> Self

Constructs a widget with the size of its parent

impl TextEditor

pub const AnyState: Shortcut

Any state/shortcut

pub fn set_insert_mode(&mut self, b: bool)

Set to insert mode

pub fn insert_mode(&self) -> bool

Returns whether insert mode is set

pub fn set_tab_nav(&mut self, val: bool)

Set tab navigation

pub fn tab_nav(&self) -> bool

Returns whether tab navigation is set

pub fn copy(&self)

Copies the text within the TextEditor widget

Examples found in repository

examples/editor.rs (line 238)

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 470)

    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 cut(&self)

Cuts the text within the TextEditor widget

Examples found in repository

examples/editor.rs (line 237)

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 469)

    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 paste(&self)

Pastes text from the clipboard into the TextEditor widget

Examples found in repository

examples/editor.rs (line 239)

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 471)

    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 undo(&self)

Undo changes in the TextEditor widget

pub fn redo(&self)

Undo changes in the TextEditor widget

pub fn kf_default(&mut self, c: Key)

Inserts the text associated with key ‘c’

pub fn kf_ignore(&mut self, c: Key)

Ignores the key ‘c’ in editor

pub fn kf_backspace(&mut self)

Does a backspace

pub fn kf_enter(&mut self)

Inserts a new line

pub fn kf_move(&mut self, c: Key)

Moves the cursor in the direction indicated by the key

pub fn kf_shift_move(&mut self, c: Key)

Extends the current selection in the direction of key ‘c’

pub fn kf_ctrl_move(&mut self, c: Key)

Moves the current text cursor in the direction indicated by control key ‘c’

pub fn kf_c_s_move(&mut self, c: Key)

Extends the current selection in the direction indicated by control key ‘c’

pub fn kf_meta_move(&mut self, c: Key)

Moves the current text cursor in the direction indicated by meta key ‘c’

pub fn kf_m_s_move(&mut self, c: Key)

Extends the current selection in the direction indicated by meta key ‘c’

pub fn kf_home(&mut self)

Moves the text cursor to the beginning of the current line

pub fn kf_end(&mut self)

Moves the text cursor to the end of the current line

pub fn kf_left(&mut self)

Moves the text cursor one character to the left

pub fn kf_up(&mut self)

Moves the text cursor one line up

pub fn kf_right(&mut self)

Moves the text cursor one character to the right

pub fn kf_down(&mut self)

Moves the text cursor one line down

pub fn kf_page_up(&mut self)

Moves the text cursor up one page

pub fn kf_page_down(&mut self)

Moves the text cursor down one page

pub fn kf_insert(&mut self)

Toggles the insert mode for the editor

pub fn kf_delete(&mut self)

Does a delete of selected text or the current character in the current buffer

pub fn kf_select_all(&mut self)

Selects all text in the associated buffer

pub fn add_key_binding( &mut self, key: Key, shortcut: Shortcut, cb: fn(key: Key, editor: TextEditorPtr) -> i32, )

Add a key binding

pub fn remove_key_binding(&mut self, key: Key, shortcut: Shortcut)

Remove a key binding

Trait Implementations

impl Clone for TextEditor

fn clone(&self) -> TextEditor

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TextEditor

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

Formats the value using the given formatter.

impl Default for TextEditor

fn default() -> Self

Returns the “default value” for a type.

impl DisplayExt for TextEditor

fn buffer(&self) -> Option<TextBuffer>

Get the associated TextBuffer

fn set_buffer<B: Into<Option<TextBuffer>>>(&mut self, buffer: B)

Sets the associated TextBuffer. Since the widget is long-lived, the lifetime of the buffer is prolonged to the lifetime of the program

fn style_buffer(&self) -> Option<TextBuffer>

Get the associated style TextBuffer

fn text_font(&self) -> Font

Return the text font

fn set_text_font(&mut self, font: Font)

Sets the text font

fn text_color(&self) -> Color

Return the text color

fn set_text_color(&mut self, color: Color)

Sets the text color

fn text_size(&self) -> i32

Return the text size

fn set_text_size(&mut self, sz: i32)

Sets the text size

fn scroll(&mut self, top_line_num: i32, h_offset: i32)

Scroll down the Display widget

fn insert(&self, text: &str)

Insert into Display widget

fn set_insert_position(&mut self, new_pos: i32)

Set the insert position

fn insert_position(&self) -> i32

Return the insert position

fn position_to_xy(&self, pos: i32) -> (i32, i32)

Gets the x and y positions of the cursor

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

Counts the lines from start to end

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

Moves the cursor right

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

Moves the cursor left

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

Moves the cursor up

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

Moves the cursor down

fn show_cursor(&mut self, val: bool)

Shows/hides the cursor

fn set_highlight_data<B: Into<Option<TextBuffer>>, E: Into<Vec<StyleTableEntry>>>( &mut self, style_buffer: B, entries: E, )

Sets the style of the text widget

fn unset_highlight_data<B: Into<Option<TextBuffer>>>(&mut self, style_buffer: B)

Unset the style of the text widget

fn set_cursor_style(&mut self, style: Cursor)

Sets the cursor style

fn set_cursor_color(&mut self, color: Color)

Sets the cursor color

fn set_scrollbar_size(&mut self, size: i32)

Sets the scrollbar size in pixels

fn set_scrollbar_align(&mut self, align: Align)

Sets the scrollbar alignment

fn cursor_style(&self) -> Cursor

Returns the cursor style

fn cursor_color(&self) -> Color

Returns the cursor color

fn scrollbar_size(&self) -> i32

Returns the scrollbar size in pixels

fn scrollbar_align(&self) -> Align

Returns the scrollbar alignment

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

Returns the beginning of the line from the current position. Returns new position as index

fn line_end(&self, start_pos: i32, is_line_start: bool) -> i32

Returns the ending of the line from the current position. Returns new position as index

fn skip_lines(&mut self, start_pos: i32, lines: i32, is_line_start: bool) -> i32

Skips lines from start_pos

fn rewind_lines(&mut self, start_pos: i32, lines: i32) -> i32

Rewinds the lines

fn next_word(&mut self)

Goes to the next word

fn previous_word(&mut self)

Goes to the previous word

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

Returns the position of the start of the word, relative to the current position

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

Returns the position of the end of the word, relative to the current position

fn x_to_col(&self, x: f64) -> f64

Convert an x pixel position into a column number.

fn col_to_x(&self, col: f64) -> f64

Convert a column number into an x pixel position

fn set_linenumber_width(&mut self, w: i32)

Sets the linenumber width

fn linenumber_width(&self) -> i32

Gets the linenumber width

fn set_linenumber_font(&mut self, font: Font)

Sets the linenumber font

fn linenumber_font(&self) -> Font

Gets the linenumber font

fn set_linenumber_size(&mut self, size: i32)

Sets the linenumber size

fn linenumber_size(&self) -> i32

Gets the linenumber size

fn set_linenumber_fgcolor(&mut self, color: Color)

Sets the linenumber foreground color

fn linenumber_fgcolor(&self) -> Color

Gets the linenumber foreground color

fn set_linenumber_bgcolor(&mut self, color: Color)

Sets the linenumber background color

fn linenumber_bgcolor(&self) -> Color

Gets the linenumber background color

fn set_linenumber_align(&mut self, align: Align)

Sets the linenumber alignment

fn linenumber_align(&self) -> Align

Gets the linenumber alignment

fn in_selection(&self, x: i32, y: i32) -> bool

Checks whether a pixel is within a text selection

fn wrap_mode(&mut self, wrap: WrapMode, wrap_margin: i32)

Sets the wrap mode of the Display widget. If the wrap mode is AtColumn, wrap margin is the column. If the wrap mode is AtPixel, wrap margin is the pixel. For more info

fn wrapped_column(&self, row: i32, column: i32) -> i32

Correct a column number based on an unconstrained position

fn wrapped_row(&self, row: i32) -> i32

Correct a row number from an unconstrained position

fn set_grammar_underline_color(&mut self, color: Color)

Set the grammar underline color

fn grammar_underline_color(&self) -> Color

Get the grammar underline color

fn set_spelling_underline_color(&mut self, color: Color)

Set the spelling underline color

fn spelling_underline_color(&self) -> Color

Get the spelling underline color

fn set_secondary_selection_color(&mut self, color: Color)

Set the secondary selection color

fn secondary_selection_color(&self) -> Color

Get the secondary selection color

fn show_insert_position(&mut self)

Scrolls the text buffer to show the current insert position

impl PartialEq for TextEditor

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 WidgetBase for TextEditor

fn delete(wid: Self)

Deletes widgets and their children.

unsafe fn from_widget_ptr(ptr: *mut Fl_Widget) -> Self

transforms a widget pointer to a Widget, for internal use

unsafe fn from_widget<W: WidgetExt>(w: W) -> Self

Get a widget from base widget

fn handle<F: FnMut(&mut Self, Event) -> bool + 'static>(&mut self, cb: F)

Set a custom handler, where events are managed manually, akin to Fl_Widget::handle(int). Handled or ignored events should return true, unhandled events should return false. takes the widget as a closure argument. The ability to handle an event might depend on handling other events, as explained here

fn draw<F: FnMut(&mut Self) + 'static>(&mut self, cb: F)

Set a custom draw method. takes the widget as a closure argument. macOS requires that WidgetBase::draw actually calls drawing functions

fn resize_callback<F: FnMut(&mut Self, i32, i32, i32, i32) + 'static>( &mut self, cb: F, )

Perform a callback on resize. Avoid resizing the parent or the same widget to avoid infinite recursion

unsafe fn assume_derived(&mut self)

Makes the widget derived

fn from_dyn_widget<W: WidgetExt>(w: &W) -> Option<Self>

Cast a type-erased widget back to its original widget

fn from_dyn_widget_ptr(w: *mut Fl_Widget) -> Option<Self>

Cast a type-erased widget pointer back to its original widget

impl WidgetExt for TextEditor

fn set_label(&mut self, title: &str)

Sets the widget’s label. labels support special symbols preceded by an @ sign. and for the associated formatting.

fn unset_label(&mut self)

Unset a widget’s label

fn redraw(&mut self)

Redraws a widget, necessary for resizing and changing positions

fn show(&mut self)

Shows the widget

fn hide(&mut self)

Hides the widget

fn x(&self) -> i32

Returns the x coordinate of the widget

fn y(&self) -> i32

Returns the y coordinate of the widget

fn w(&self) -> i32

Returns the width of the widget

fn h(&self) -> i32

Returns the height of the widget

fn label(&self) -> Option<String>

Returns the label of the widget

fn measure_label(&self) -> (i32, i32)

Measures the label’s width and height

fn as_widget_ptr(&self) -> *mut Fl_Widget

transforms a widget to a base Fl_Widget, for internal use

fn activate(&mut self)

Activates the widget

fn deactivate(&mut self)

Deactivates the widget

fn redraw_label(&mut self)

Redraws the label of the widget

fn resize(&mut self, x: i32, y: i32, width: i32, height: i32)

Resizes and/or moves the widget, takes x, y, width and height

fn widget_resize(&mut self, x: i32, y: i32, width: i32, height: i32)

Does a simple resize ignoring class-specific resize functionality

fn tooltip(&self) -> Option<String>

Returns the tooltip text

fn set_tooltip(&mut self, txt: &str)

Sets the tooltip text

fn color(&self) -> Color

Returns the widget color

fn set_color(&mut self, color: Color)

Sets the widget’s color

fn label_color(&self) -> Color

Returns the widget label’s color

fn set_label_color(&mut self, color: Color)

Sets the widget label’s color

fn label_font(&self) -> Font

Returns the widget label’s font

fn set_label_font(&mut self, font: Font)

Sets the widget label’s font

fn label_size(&self) -> i32

Returns the widget label’s size

fn set_label_size(&mut self, sz: i32)

Sets the widget label’s size

fn label_type(&self) -> LabelType

Returns the widget label’s type

fn set_label_type(&mut self, typ: LabelType)

Sets the widget label’s type

fn frame(&self) -> FrameType

Returns the widget’s frame type

fn set_frame(&mut self, typ: FrameType)

Sets the widget’s frame type

fn changed(&self) -> bool

Returns whether the widget was changed

fn set_changed(&mut self)

Mark the widget as changed

fn clear_changed(&mut self)

Clears the changed status of the widget

fn align(&self) -> Align

Returns the alignment of the widget

fn set_align(&mut self, align: Align)

Sets the alignment of the widget

fn set_when(&mut self, trigger: When)

Sets the default callback trigger for a widget, equivalent to when()

fn when(&self) -> When

Return the callback trigger, equivalent to when()

fn parent(&self) -> Option<Group>

Returns the parent of the widget

fn selection_color(&self) -> Color

Gets the selection color of the widget

fn set_selection_color(&mut self, color: Color)

Sets the selection color of the widget

fn do_callback(&mut self)

Runs the already registered callback

fn window(&self) -> Option<Box<dyn WindowExt>>

Returns the direct window holding the widget

fn top_window(&self) -> Option<Box<dyn WindowExt>>

Returns the topmost window holding the widget

fn takes_events(&self) -> bool

Checks whether a widget is capable of taking events

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

Make the widget take focus

fn set_visible_focus(&mut self)

Set the widget to have visible focus

fn clear_visible_focus(&mut self)

Clear visible focus

fn visible_focus(&mut self, v: bool)

Set the visible focus using a flag

fn has_visible_focus(&self) -> bool

Return whether the widget has visible focus

fn has_focus(&self) -> bool

Return whether the widget has focus

fn was_deleted(&self) -> bool

Check if a widget was deleted

fn damage(&self) -> bool

Return whether the widget was damaged

fn set_damage(&mut self, flag: bool)

Signal the widget as damaged and it should be redrawn in the next event loop cycle

fn damage_type(&self) -> Damage

Return the damage mask

fn set_damage_type(&mut self, mask: Damage)

Signal the type of damage a widget received

fn set_damage_area(&mut self, mask: Damage, x: i32, y: i32, w: i32, h: i32)

Signal damage for an area inside the widget

fn clear_damage(&mut self)

Clear the damaged flag

fn as_window(&self) -> Option<Box<dyn WindowExt>>

Return the widget as a window if it’s a window

fn as_group(&self) -> Option<Group>

Return the widget as a group widget if it’s a group widget

fn inside<W: WidgetExt>(&self, wid: &W) -> bool

Checks whether the self widget is inside another widget

fn get_type<T: WidgetType>(&self) -> T

Returns the widget type when applicable

fn set_type<T: WidgetType>(&mut self, typ: T)

Sets the widget type

fn set_image<I: ImageExt>(&mut self, image: Option<I>)

Sets the image of the widget

fn set_image_scaled<I: ImageExt>(&mut self, image: Option<I>)

Sets the image of the widget scaled to the widget’s size

fn image(&self) -> Option<Box<dyn ImageExt>>

Gets the image associated with the widget

fn set_deimage<I: ImageExt>(&mut self, image: Option<I>)

Sets the deactivated image of the widget

fn set_deimage_scaled<I: ImageExt>(&mut self, image: Option<I>)

Sets the deactivated image of the widget scaled to the widget’s size

fn deimage(&self) -> Option<Box<dyn ImageExt>>

Gets the deactivated image associated with the widget

fn set_callback<F: FnMut(&mut Self) + 'static>(&mut self, cb: F)

Sets the callback when the widget is triggered (clicks for example) takes the widget as a closure argument

fn emit<T: 'static + Clone + Send + Sync>(&mut self, sender: Sender<T>, msg: T)

Emits a message on callback using a sender

unsafe fn as_widget<W: WidgetBase>(&self) -> W

Upcast a WidgetExt to some widget type

fn visible(&self) -> bool

Returns whether a widget is visible

fn visible_r(&self) -> bool

Returns whether a widget or any of its parents are visible (recursively)

fn is_same<W: WidgetExt>(&self, other: &W) -> bool

Return whether two widgets object point to the same widget

fn active(&self) -> bool

Returns whether a widget is active

fn active_r(&self) -> bool

Returns whether a widget or any of its parents are active (recursively)

fn handle_event(&mut self, event: Event) -> bool

Handle a specific event

fn is_derived(&self) -> bool

Check whether a widget is derived

fn as_base_widget(&self) -> Widget

where Self: Sized,

Upcast a WidgetExt to a Widget

impl WidgetProps for TextEditor

fn with_pos(self, x: i32, y: i32) -> Self

Initialize to position x, y

fn with_size(self, width: i32, height: i32) -> Self

Initialize to size width, height

fn with_label(self, title: &str) -> Self

Initialize with a label

fn with_align(self, align: Align) -> Self

Initialize with alignment

fn with_type<T: WidgetType>(self, typ: T) -> Self

Initialize with type

fn below_of<W: WidgetExt>(self, wid: &W, padding: i32) -> Self

Initialize at bottom of another widget

fn above_of<W: WidgetExt>(self, wid: &W, padding: i32) -> Self

Initialize above of another widget

fn right_of<W: WidgetExt>(self, wid: &W, padding: i32) -> Self

Initialize right of another widget

fn left_of<W: WidgetExt>(self, wid: &W, padding: i32) -> Self

Initialize left of another widget

fn center_of<W: WidgetExt>(self, w: &W) -> Self

Initialize center of another widget

fn center_x<W: WidgetExt>(self, w: &W) -> Self

Initialize center of another widget on the x axis

fn center_y<W: WidgetExt>(self, w: &W) -> Self

Initialize center of another widget on the y axis

fn center_of_parent(self) -> Self

Initialize center of parent

fn size_of<W: WidgetExt>(self, w: &W) -> Self

Initialize to the size of another widget

fn size_of_parent(self) -> Self

Initialize to the size of the parent

impl Eq for TextEditor

impl Send for TextEditor

Available on non-crate feature single-threaded only.

impl Sync for TextEditor

Available on non-crate feature single-threaded only.