Struct CodeEditor 

pub struct CodeEditor { /* private fields */ }

Canvas-based high-performance text editor.

Implementations

impl CodeEditor

pub fn update(&mut self, message: &Message) -> Task<Message>

Updates the editor state based on messages and returns scroll commands.

Arguments

• message - The message to process

Returns

A Task that may contain scroll commands to keep cursor visible

impl CodeEditor

pub fn view(&self) -> Element<'_, Message>

Creates the view element with scrollable wrapper.

The backgrounds (editor and gutter) are handled by container styles to ensure proper clipping when the pane is resized.

impl CodeEditor

pub fn new(content: &str, syntax: &str) -> Self

Creates a new canvas-based text editor.

Arguments

• content - Initial text content
• syntax - Syntax highlighting language (e.g., “py”, “lua”, “rs”)

Returns

A new CodeEditor instance

pub fn content(&self) -> String

Returns the current text content as a string.

Returns

The complete text content of the editor

pub fn with_viewport_height(self, height: f32) -> Self

Sets the viewport height for the editor.

This determines the minimum height of the canvas, ensuring proper background rendering even when content is smaller than the viewport.

Arguments

• height - The viewport height in pixels

Returns

Self for method chaining

Example

use iced_code_editor::CodeEditor;

let editor = CodeEditor::new("fn main() {}", "rs")
    .with_viewport_height(500.0);

pub fn set_theme(&mut self, style: Style)

Sets the theme style for the editor.

Arguments

• style - The style to apply to the editor

Example

use iced_code_editor::{CodeEditor, theme};

let mut editor = CodeEditor::new("fn main() {}", "rs");
editor.set_theme(theme::from_iced_theme(&iced::Theme::TokyoNightStorm));

pub fn set_language(&mut self, language: Language)

Sets the language for UI translations.

This changes the language used for all UI text elements in the editor, including search dialog tooltips, placeholders, and labels.

Arguments

• language - The language to use for UI text

Example

use iced_code_editor::{CodeEditor, Language};

let mut editor = CodeEditor::new("fn main() {}", "rs");
editor.set_language(Language::French);

pub fn language(&self) -> Language

Returns the current UI language.

Returns

The currently active language for UI text

Example

use iced_code_editor::{CodeEditor, Language};

let editor = CodeEditor::new("fn main() {}", "rs");
let current_lang = editor.language();

pub fn request_focus(&self)

Requests focus for this editor.

This method programmatically sets the focus to this editor instance, allowing it to receive keyboard events. Other editors will automatically lose focus.

Example

use iced_code_editor::CodeEditor;

let mut editor1 = CodeEditor::new("fn main() {}", "rs");
let mut editor2 = CodeEditor::new("fn test() {}", "rs");

// Give focus to editor2
editor2.request_focus();

pub fn is_focused(&self) -> bool

Checks if this editor currently has focus.

Returns true if this editor will receive keyboard events, false otherwise.

Returns

true if focused, false otherwise

Example

use iced_code_editor::CodeEditor;

let editor = CodeEditor::new("fn main() {}", "rs");
if editor.is_focused() {
    println!("Editor has focus");
}

pub fn reset(&mut self, content: &str) -> Task<Message>

Resets the editor with new content.

This method replaces the buffer content and resets all editor state (cursor position, selection, scroll, history) to initial values. Use this instead of creating a new CodeEditor instance to ensure proper widget tree updates in iced.

Returns a Task that scrolls the editor to the top, which also forces a redraw of the canvas.

Arguments

• content - The new text content

Returns

A Task<Message> that should be returned from your update function

Example

use iced_code_editor::CodeEditor;

let mut editor = CodeEditor::new("initial content", "lua");
// Later, reset with new content and get the task
let task = editor.reset("new content");
// Return task.map(YourMessage::Editor) from your update function

pub fn is_modified(&self) -> bool

Returns whether the editor has unsaved changes.

Returns

true if there are unsaved modifications, false otherwise

pub fn mark_saved(&mut self)

Marks the current state as saved.

Call this after successfully saving the file to reset the modified state.

pub fn can_undo(&self) -> bool

Returns whether undo is available.

pub fn can_redo(&self) -> bool

Returns whether redo is available.

pub fn set_wrap_enabled(&mut self, enabled: bool)

Sets whether line wrapping is enabled.

When enabled, long lines will wrap at the viewport width or at a configured column width.

Arguments

• enabled - Whether to enable line wrapping

Example

use iced_code_editor::CodeEditor;

let mut editor = CodeEditor::new("fn main() {}", "rs");
editor.set_wrap_enabled(false); // Disable wrapping

pub fn wrap_enabled(&self) -> bool

Returns whether line wrapping is enabled.

Returns

true if line wrapping is enabled, false otherwise

pub fn set_search_replace_enabled(&mut self, enabled: bool)

Enables or disables the search/replace functionality.

When disabled, search/replace keyboard shortcuts (Ctrl+F, Ctrl+H, F3) will be ignored. If the search dialog is currently open, it will be closed.

Arguments

• enabled - Whether to enable search/replace functionality

Example

use iced_code_editor::CodeEditor;

let mut editor = CodeEditor::new("fn main() {}", "rs");
editor.set_search_replace_enabled(false); // Disable search/replace

pub fn search_replace_enabled(&self) -> bool

Returns whether search/replace functionality is enabled.

Returns

true if search/replace is enabled, false otherwise

pub fn with_wrap_enabled(self, enabled: bool) -> Self

Sets the line wrapping with builder pattern.

Arguments

• enabled - Whether to enable line wrapping

Returns

Self for method chaining

Example

use iced_code_editor::CodeEditor;

let editor = CodeEditor::new("fn main() {}", "rs")
    .with_wrap_enabled(false);

pub fn with_wrap_column(self, column: Option<usize>) -> Self

Sets the wrap column (fixed width wrapping).

When set to Some(n), lines will wrap at column n. When set to None, lines will wrap at the viewport width.

Arguments

• column - The column to wrap at, or None for viewport-based wrapping

Example

use iced_code_editor::CodeEditor;

let editor = CodeEditor::new("fn main() {}", "rs")
    .with_wrap_column(Some(80)); // Wrap at 80 characters

Trait Implementations

impl Program<Message> for CodeEditor

type State = ()

The internal state mutated by the Program.

fn draw( &self, _state: &Self::State, renderer: &Renderer, _theme: &Theme, bounds: Rectangle, _cursor: Cursor, ) -> Vec<Geometry>

Draws the state of the Program, producing a bunch of Geometry.

fn update( &self, _state: &mut Self::State, event: &Event, bounds: Rectangle, cursor: Cursor, ) -> Option<Action<Message>>

Updates the State of the Program.

fn mouse_interaction( &self, _state: &Self::State, _bounds: Rectangle, _cursor: Cursor, ) -> Interaction

Returns the current mouse interaction of the Program.