EdTUI

https://docs.rs/edtui/0.11.2
Admin
EdTUI is a text editor widget for the Ratatui ecosystem with Vim and Emacs keybindings, syntax...
Tokens:136,117
Snippets:1,002
Trust Score:9.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### Start Search

Source: https://docs.rs/edtui/0.11.2/src/edtui/events/key.rs.html

Use '/' in normal mode to start a new search and enter search mode.

```Rust
(
            KeyEventRegister::n(vec![KeyInput::new('/')]),
            StartSearch.chain(SwitchMode(EditorMode::Search)).into(),
        )
```

--------------------------------

### Create EditorView with Default Settings

Source: https://docs.rs/edtui/0.11.2/edtui/struct.EditorView.html

Initializes an EditorView with default settings. Use this as a starting point for further configuration.

```rust
use edtui::EditorState;
use edtui::EditorTheme;
use edtui::EditorView;

let theme = EditorTheme::default();
let mut state = EditorState::default();

EditorView::new(&mut state)
    .wrap(true)
    .theme(theme);
```

--------------------------------

### Custom Global Clipboard Example

Source: https://docs.rs/edtui/0.11.2/src/edtui/clipboard.rs.html

Demonstrates how to implement and use a custom global clipboard with edtui, integrating with external systems or custom logic.

```APIDOC
## Example: Custom Global Clipboard

`EdTUI` allows you to set a custom clipboard. This is useful if you want to define a global clipboard for example:

```ignore
use once_cell::sync::Lazy;
use std::sync::Mutex;

static CLIPBOARD: Lazy<GlobalClipboard> = Lazy::new(|| GlobalClipboard::new());

struct GlobalClipboard(Mutex<Clipboard>);

impl GlobalClipboard {
    pub fn new() -> Self {
        Self(Mutex::new(arboard::Clipboard::new().unwrap()))
    }
}

impl ClipboardTrait for &GlobalClipboard {
    fn set_text(&mut self, text: String) {
        if let Ok(mut clipboard) = self.0.lock() {
            let _ = clipboard.set_text(text);
        }
    }

    fn get_text(&mut self) -> String {
        if let Ok(mut clipboard) = self.0.lock() {
            return clipboard.get_text().unwrap_or_default();
        }
        String::new()
    }
}

let mut state = EditorState::default();
state.set_clipboard(Lazy::force(&CLIPBOARD));
```
```

--------------------------------

### Custom Global Clipboard Example

Source: https://docs.rs/edtui/0.11.2/src/edtui/clipboard.rs.html

Demonstrates how to set up a custom global clipboard using `once_cell::sync::Lazy` and `arboard::Clipboard`. This allows for a shared clipboard instance across the application.

```rust
use once_cell::sync::Lazy;
use std::sync::Mutex;

static CLIPBOARD: Lazy<GlobalClipboard> = Lazy::new(|| GlobalClipboard::new());

struct GlobalClipboard(Mutex<Clipboard>);

impl GlobalClipboard {
    pub fn new() -> Self {
        Self(Mutex::new(arboard::Clipboard::new().unwrap()))
    }
}

impl ClipboardTrait for &GlobalClipboard {
    fn set_text(&mut self, text: String) {
        if let Ok(mut clipboard) = self.0.lock() {
            let _ = clipboard.set_text(text);
        }
    }

    fn get_text(&mut self) -> String {
        if let Ok(mut clipboard) = self.0.lock() {
            return clipboard.get_text().unwrap_or_default();
        }
        String::new()
    }
}

let mut state = EditorState::default();
state.set_clipboard(Lazy::force(&CLIPBOARD));
```

--------------------------------

### Get Normalized Start Position

Source: https://docs.rs/edtui/0.11.2/src/edtui/state/highlight.rs.html

Returns the effective start position of the highlight, ensuring it's the chronologically earlier point.

```rust
pub fn start(&self) -> Index2 {
    if self.is_reversed() {
        self.end
    } else {
        self.start
    }
}
```

--------------------------------

### StartSearch Struct

Source: https://docs.rs/edtui/0.11.2/edtui/actions/search/struct.StartSearch.html

Represents a command to clear to the start of the search and switch into search mode.

```APIDOC
## Struct StartSearch

### Summary
```rust
pub struct StartSearch;
```

### Description
Command to clear to the start of the search and switch into search mode.
```

--------------------------------

### StartSearch

Source: https://docs.rs/edtui/0.11.2/src/edtui/actions/search.rs.html

Clears to the start of the search and switches into search mode.

```APIDOC
## StartSearch

### Description
Initiates the search state, clearing the search buffer and setting the starting cursor position.

### Method
Not applicable (struct implementation)

### Endpoint
Not applicable

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
None

#### Response Example
None
```

--------------------------------

### Create New Highlight

Source: https://docs.rs/edtui/0.11.2/src/edtui/state/highlight.rs.html

Constructor for the Highlight struct. Initializes a new highlight with specified start and end positions and a style.

```rust
pub fn new(start: Index2, end: Index2, style: Style) -> Self {
    Self { start, end, style }
}
```

--------------------------------

### Start Search Mode

Source: https://docs.rs/edtui/0.11.2/src/edtui/actions/search.rs.html

Clears the search buffer and switches the editor into search mode, positioning the cursor for input. Use to begin a new search.

```rust
/// Command to clear to start of the search and switch into search mode.
#[derive(Clone, Debug)]
pub struct StartSearch;

impl Execute for StartSearch {
    /// Executes the command, starting the search state.
    fn execute(&mut self, state: &mut EditorState) {
        state.search.start(state.cursor);
    }
}
```

--------------------------------

### Configure Beginning/End of Line and Document Navigation

Source: https://docs.rs/edtui/0.11.2/src/edtui/events/key.rs.html

Maps keys to navigate to the start or end of the current line, or to the first/last row of the document. Uses Home, End, Ctrl, and Alt modifiers.

```Rust
KeyEventRegister::i(vec![KeyInput::alt('<')]),
MoveToFirstRow().into(),
```

```Rust
KeyEventRegister::i(vec![KeyInput::alt('>')]),
MoveToLastRow().into(),
```

```Rust
KeyEventRegister::i(vec![KeyInput::ctrl('a')]),
MoveToStartOfLine().into(),
```

```Rust
KeyEventRegister::i(vec![KeyInput::new(KeyCode::Home)]),
MoveToStartOfLine().into(),
```

```Rust
KeyEventRegister::i(vec![KeyInput::new(KeyCode::End)]),
MoveToEndOfLine().into(),
```

```Rust
KeyEventRegister::i(vec![KeyInput::ctrl('e')]),
MoveToEndOfLine().into(),
```

--------------------------------

### Navigate Search Matches

Source: https://docs.rs/edtui/0.11.2/src/edtui/state/search.rs.html

Provides methods to find the first match at or after the current cursor, get the current match, move to the next match, and move to the previous match. It updates the `selected_index` accordingly.

```rust
    pub(crate) fn first(&mut self) -> Option<&Index2> {
        for (i, index) in self.matches.iter().enumerate() {
            if index >= &self.start_cursor {
                self.selected_index = Some(i);
                return Some(index);
            }
        }
        match self.matches.first() {
            Some(index) => {
                self.selected_index = Some(0);
                Some(index)
            }
            None => None,
        }
    }

    pub(crate) fn current(&self) -> Option<&Index2> {
        self.selected_index.and_then(|i| self.matches.get(i))
    }

    pub(crate) fn next(&mut self) -> Option<&Index2> {
        if let Some(selected) = self.selected_index {
            let new_selected = if selected + 1 >= self.matches.len() {
                0
            } else {
                selected + 1
            };
            self.selected_index = Some(new_selected);
            return self.matches.get(new_selected);
        }
        None
    }

    pub(crate) fn previous(&mut self) -> Option<&Index2> {
        let len = self.matches.len();
        if len == 0 {
            return None;
        }

        let new_selected = match self.selected_index {
            Some(0) | None => len - 1,
            Some(i) => i - 1,
        };

        self.selected_index = Some(new_selected);
        self.matches.get(new_selected)
    }
}

```

--------------------------------

### EditorView Creation and Configuration

Source: https://docs.rs/edtui/0.11.2/edtui/struct.EditorView.html

Demonstrates how to create an EditorView instance and configure its various properties like theme, syntax highlighting, line wrapping, and line numbers.

```APIDOC
## EditorView

### Description
Creates the view for the editor. `EditorView` and `EditorState` are the core classes of edtui.

### Method
`EditorView::new(state: &'a mut EditorState) -> Self`

### Endpoint
N/A (Struct method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
use edtui::EditorState;
use edtui::EditorTheme;
use edtui::EditorView;

let theme = EditorTheme::default();
let mut state = EditorState::default();

let editor_view = EditorView::new(&mut state)
    .wrap(true)
    .theme(theme);
```

## Configuration Methods

### `theme(self, theme: EditorTheme<'b>) -> Self`
Set the theme for the `EditorView`. See `EditorTheme` for the customizable parameters.

### `syntax_highlighter(self, syntax_highlighter: Option<SyntaxHighlighter>) -> Self`
Set the syntax highlighter for the `EditorView`. See `SyntaxHighlighter` for more information.

#### Example
```rust
use edtui::EditorState;
use edtui::EditorView;
use edtui::SyntaxHighlighter;

let mut state = EditorState::default();
let syntax_highlighter = SyntaxHighlighter::new("dracula", "rs").unwrap();

let editor_view = EditorView::new(&mut state).syntax_highlighter(Some(syntax_highlighter));
```

### `single_line(self, single_line: bool) -> Self`
Enables single-line mode, which blocks newline insertion. When enabled, pressing Enter, Ctrl+J, Ctrl+M, or any other key combination that would insert a newline will be ignored. This is useful for search boxes, single-line input fields, and similar use cases.

#### Example
```rust
use edtui::{EditorState, EditorView};

let mut state = EditorState::default();

// Create a single-line input field
let editor_view = EditorView::new(&mut state).single_line(true);
```

### `wrap(self, wrap: bool) -> Self`
Sets whether overflowing lines should wrap onto the next line.

#### Note
Line wrapping currently has issues when used with mouse events.

### `tab_width(self, tab_width: usize) -> Self`
Sets the number of spaces used for rendering tabs.

### `line_numbers(self, line_numbers: LineNumbers) -> Self`
Configures line numbers. Disabled by default.

#### Example
```rust
use edtui::{EditorState, EditorView, LineNumbers};

let mut state = EditorState::default();

// Enable absolute line numbers
let editor_view_abs = EditorView::new(&mut state).line_numbers(LineNumbers::Absolute);

// Enable relative line numbers
let editor_view_rel = EditorView::new(&mut state).line_numbers(LineNumbers::Relative);
```

### `get_state(&'a self) -> &'a EditorState`
Returns a reference to the `EditorState`.

### `get_state_mut(&'a mut self) -> &'a mut EditorState`
Returns a mutable reference to the `EditorState`.
```

--------------------------------

### Get Column Range for a Specific Row

Source: https://docs.rs/edtui/0.11.2/src/edtui/state/highlight.rs.html

Calculates the start and end columns that are part of the highlight within a given row. Accounts for row length to prevent out-of-bounds.

```rust
pub fn get_columns_in_row(&self, row: usize, row_len: usize) -> Option<(usize, usize)> {
    let (start, end) = (self.start(), self.end());

    if row < start.row || row > end.row {
        return None;
    }

    let start_col = if row == start.row {
        start.col.min(row_len)
    } else {
        0
    };

    let end_col = if row == end.row {
        end.col.min(row_len)
    } else {
        row_len
    };

    Some((start_col, end_col))
}
```

--------------------------------

### Create SyntaxHighlighter with theme and extension

Source: https://docs.rs/edtui/0.11.2/edtui/struct.SyntaxHighlighter.html

Use this function to create a new SyntaxHighlighter with a specified theme and file extension. Syntax highlighting is experimental and subject to change. Available themes are listed in `Self::theme`.

```rust
use edtui::SyntaxHighlighter;

let syntax_highlighter = SyntaxHighlighter::new("dracula", "rs");
```

--------------------------------

### Get EditorMode Name

Source: https://docs.rs/edtui/0.11.2/src/edtui/state/mode.rs.html

Provides a method to get the string representation of the current EditorMode. This is useful for displaying the mode to the user. The method returns a String.

```rust
11impl EditorMode {
12    /// Returns the name of the [`EditorMode`] as a string.
13    #[must_use]
14    pub fn name(&self) -> String {
15        match self {
16            Self::Normal => "Normal".to_string(),
17            Self::Insert => "Insert".to_string(),
18            Self::Visual => "Visual".to_string(),
19            Self::Search => "Search".to_string(),
20        }
21    }
22}
```

--------------------------------

### SyntaxHighlighter::new

Source: https://docs.rs/edtui/0.11.2/src/edtui/view/syntax_higlighting.rs.html

Creates a new SyntaxHighlighter instance using a predefined theme name and file extension.

```APIDOC
## SyntaxHighlighter::new

### Description
Initializes a new SyntaxHighlighter with a specific theme and syntax reference based on the provided file extension.

### Parameters
- **theme** (str) - Required - The name of the theme (e.g., "dracula").
- **extension** (str) - Required - The file extension to determine syntax (e.g., "rs").

### Response
- **Result<Self, SyntaxHighlighterError>** - Returns the configured SyntaxHighlighter or an error if the theme or extension is not found.
```

--------------------------------

### EditorState::cursor_screen_position

Source: https://docs.rs/edtui/0.11.2/src/edtui/state.rs.html

Gets the cursor's position on the terminal screen.

```APIDOC
## EditorState::cursor_screen_position

### Description
Returns the calculated screen position of the cursor. This position accounts for scrolling, line wrapping, tab expansion, and the editor's viewport. It's computed during the last rendering cycle.

### Method

```rust
#[must_use]
pub fn cursor_screen_position(&self) -> Option<Position>
```

### Parameters
None

### Response
#### Success Response (200)
- **Option<Position>** - The cursor's screen position (`Position { x, y }`), or `None` if the editor hasn't been rendered yet.

#### Response Example
```rust
let screen_pos = state.cursor_screen_position();
// screen_pos might be Some(Position { x: 10, y: 5 })
```
```

--------------------------------

### Initialize and render the editor

Source: https://docs.rs/edtui/0.11.2/edtui/index.html

Create an EditorState and render it using EditorView with custom theme and syntax settings.

```rust
use edtui::{EditorState, EditorTheme, EditorView};
use ratatui::widgets::Widget;

let mut state = EditorState::default();
EditorView::new(&mut state)
        .theme(EditorTheme::default())
        .wrap(true)
        .syntax_highlighter(None)
        .tab_width(2)
        .render(area, buf);
```

--------------------------------

### DeleteLine

Source: https://docs.rs/edtui/0.11.2/src/edtui/actions/delete.rs.html

Deletes a specified number of lines starting from the current cursor position.

```APIDOC
## DeleteLine

### Description
Deletes the current line or a specified number of lines.

### Method
`execute`

### Parameters
- `state` (*EditorState*) - The current editor state.
- `usize` - The number of lines to delete.

### Request Example
```rust
// Assuming 'state' is a mutable reference to an EditorState
let delete_line_cmd = DeleteLine(1); // Delete current line
delete_line_cmd.execute(&mut state);
```

### Response
Modifies the `EditorState` in place by deleting lines and updating the cursor position. Deleted lines are added to the clipboard.
```

--------------------------------

### Get stack length

Source: https://docs.rs/edtui/0.11.2/src/edtui/state/undo.rs.html

Returns the current number of elements in the undo stack.

```rust
fn len(&mut self) -> usize {
        self.inner.len()
    }
```

--------------------------------

### SyntaxHighlighter - Creation and Configuration

Source: https://docs.rs/edtui/0.11.2/edtui/struct.SyntaxHighlighter.html

This section covers the creation and configuration of the SyntaxHighlighter struct, including methods for setting themes and syntax.

```APIDOC
## Struct SyntaxHighlighter

Syntax highlighter settings including theme and syntax.

### Methods

#### `new<'c>(theme: &'c str, extension: &'c str) -> Result<Self, SyntaxHighlighterError<'c>>`

Creates a new `SyntaxHighlighter` with a given theme (e.g. “base16-ocean.dark”) and an extension (e.g. “json”).

**Parameters:**
- `theme` (str): The name of the theme to use (e.g., "dracula").
- `extension` (str): The file extension to determine the syntax (e.g., "rs").

**Returns:**
- `Result<Self, SyntaxHighlighterError>`: A `SyntaxHighlighter` instance on success, or an error if the theme or syntax is invalid.

**Example:**
```rust
use edtui::SyntaxHighlighter;

let syntax_highlighter = SyntaxHighlighter::new("dracula", "rs");
```

#### `with_sets(theme: Theme, theme_set: Arc<ThemeSet>, syntax_ref: SyntaxReference, syntax_set: Arc<SyntaxSet>) -> SyntaxHighlighter`

Creates a new `SyntaxHighlighter` with custom theme, theme set, syntax reference, and syntax set.

**Parameters:**
- `theme` (Theme): A custom `syntect::highlighting::Theme`.
- `theme_set` (Arc<ThemeSet>): An `Arc` containing the `ThemeSet`.
- `syntax_ref` (SyntaxReference): A `syntect::parsing::SyntaxReference` for the desired syntax.
- `syntax_set` (Arc<SyntaxSet>): An `Arc` containing the `SyntaxSet`.

**Returns:**
- `SyntaxHighlighter`: A new `SyntaxHighlighter` instance.

**Example:**
```rust
use syntect::highlighting::Theme;
use syntect::parsing::{SyntaxDefinition, SyntaxSetBuilder};
use edtui::SyntaxHighlighter;
use edtui::{THEME_SET, SYNTAX_SET};

let theme = Theme::default(); // My custom theme
let mut syntax_set_builder = SyntaxSetBuilder::new(); // My custom syntax set builder
syntax_set_builder.add_plain_text_syntax(); // Add your syntax
let syntax_set = syntax_set_builder.build(); // My custom syntax set
let syntax_ref = syntax_set.syntaxes().first().unwrap().clone(); // My custom syntax reference
let syntax_highlighter = SyntaxHighlighter::with_sets(theme, THEME_SET.clone(), syntax_ref, SYNTAX_SET.clone());
```

#### `custom_theme(self, theme: Theme) -> Self`

Sets a custom theme for the `SyntaxHighlighter`. Use `theme_by_name` for predefined themes.

**Parameters:**
- `theme` (Theme): The custom `Theme` to apply.

**Returns:**
- `Self`: The modified `SyntaxHighlighter` instance.

#### `custom_syntax_ref(self, syntax_ref: SyntaxReference) -> Self`

Sets a custom syntax reference for the `SyntaxHighlighter`. Use `theme_by_name` for predefined themes.

**Parameters:**
- `syntax_ref` (SyntaxReference): The custom `SyntaxReference` to apply.

**Returns:**
- `Self`: The modified `SyntaxHighlighter` instance.

#### `theme(self, theme: &str) -> Result<Self, SyntaxHighlighterError<'_>>`

Sets a theme by its name (e.g., “base16-ocean.dark”).

**Parameters:**
- `theme` (str): The name of the theme to set.

**Returns:**
- `Result<Self, SyntaxHighlighterError>`: The modified `SyntaxHighlighter` instance on success, or an error if the theme name is invalid.

**Available themes:**
“`1337`” “`OneHalfDark`” “`OneHalfLight`” “`Tomorrow`” “`agola-dark`” “`ascetic-white`” “`axar`” “`ayu-dark`” “`ayu-light`” “`ayu-mirage`” “`base16-atelierdune-light`” “`base16-ocean-dark`” “`base16-ocean-light`” “`bbedit`” “`boron`” “`charcoal`” “`cheerfully-light`” “`classic-modified`” “`demain`” “`dimmed-fluid`” “`dracula`” “`gray-matter-dark`” “`green`” “`gruvbox-dark`” “`gruvbox-light`” “`idle`” “`inspired-github`” “`ir-white`” “`kronuz`” “`material-dark`” “`material-light`” “`monokai`” “`nord`” “`nyx-bold`” “`one-dark`” “`railsbase16-green-screen-dark`” “`solarized-dark`” “`solarized-light`” “`subway-madrid`” “`subway-moscow`” “`two-dark`” “`visual-studio-dark`” “`zenburn`”
```

--------------------------------

### Viewport Management

Source: https://docs.rs/edtui/0.11.2/src/edtui/state.rs.html

Methods for getting and setting the editor's viewport offset and height.

```APIDOC
## Get Viewport Offset

### Description
Retrieves the current viewport offset, representing the top-left corner of the visible area in editor coordinates.

### Method
GET

### Endpoint
/editor/viewport/offset

### Response
#### Success Response (200)
- **x** (usize) - The horizontal offset (column).
- **y** (usize) - The vertical offset (row).

#### Response Example
```json
{
  "x": 10,
  "y": 5
}
```

## Set Viewport Offset

### Description
Sets the viewport offset to a specified (x, y) position, allowing manual control of the scroll position.

### Method
PUT

### Endpoint
/editor/viewport/offset

### Parameters
#### Request Body
- **x** (usize) - Required - The horizontal offset (column).
- **y** (usize) - Required - The vertical offset (row).

### Request Example
```json
{
  "x": 15,
  "y": 8
}
```

## Set Viewport Height

### Description
Sets the viewport height, which is the number of visible rows. This is typically set automatically during rendering.

### Method
PUT

### Endpoint
/editor/viewport/height

### Parameters
#### Request Body
- **height** (usize) - Required - The desired viewport height in rows.

### Request Example
```json
{
  "height": 20
}
```
```

--------------------------------

### Clipboard::new

Source: https://docs.rs/edtui/0.11.2/edtui/clipboard/struct.Clipboard.html

Creates a new Clipboard instance with a provided implementation.

```APIDOC
## Clipboard::new

### Description
Creates a new `Clipboard` instance with a provided clipboard implementation that must implement `ClipboardTrait`.

### Parameters
- **clipboard** (impl ClipboardTrait + 'static) - Required - The clipboard implementation to wrap.

### Request Example
```rust
use edtui::clipboard::{Clipboard, ClipboardTrait};

struct MyClipboard(String);

impl ClipboardTrait for MyClipboard {
    fn set_text(&mut self, text: String) {
        self.0 = text;
    }

    fn get_text(&mut self) -> String {
        self.0.clone()
    }
}

let clipboard = MyClipboard(String::new());
let clipboard_wrapper = Clipboard::new(clipboard);
```
```

--------------------------------

### DeleteWordBackward

Source: https://docs.rs/edtui/0.11.2/src/edtui/actions/delete.rs.html

Deletes from the cursor backward to the start of the previous word. This is analogous to Emacs' Alt+Backspace functionality.

```APIDOC
## DeleteWordBackward

### Description
Deletes from the cursor backward to the start of the previous word (Emacs Alt+Backspace).

### Method
`execute`

### Parameters
- `state` (*EditorState*) - The current editor state.

### Request Example
```rust
// Assuming 'state' is a mutable reference to an EditorState
let delete_word_cmd = DeleteWordBackward(1);
delete_word_cmd.execute(&mut state);
```

### Response
Modifies the `EditorState` in place by deleting text and updating the cursor position.
```

--------------------------------

### Theme Configuration

Source: https://docs.rs/edtui/0.11.2/src/edtui/view/syntax_higlighting.rs.html

Allows setting a specific theme for syntax highlighting. Available themes include 'classic-modified', 'demain', 'dimmed-fluid', 'dracula', 'gray-matter-dark', 'green', 'gruvbox-dark', 'gruvbox-light', 'idle', 'inspired-github', 'ir-white', 'kronuz', 'material-dark', 'material-light', 'monokai', 'nord', 'nyx-bold', 'one-dark', 'railsbase16-green-screen-dark', 'solarized-dark', 'solarized-light', 'subway-madrid', 'subway-moscow', 'two-dark', 'visual-studio-dark', and 'zenburn'.

```APIDOC
## POST /api/syntax-highlighter/theme

### Description
Sets the syntax highlighting theme.

### Method
POST

### Endpoint
/api/syntax-highlighter/theme

### Parameters
#### Query Parameters
- **theme** (string) - Required - The name of the theme to apply. See the description for a list of available themes.

### Request Example
```json
{
  "theme": "dracula"
}
```

### Response
#### Success Response (200)
- **message** (string) - Indicates the theme was successfully set.

#### Response Example
```json
{
  "message": "Theme 'dracula' applied successfully."
}
```
```

--------------------------------

### SyntaxHighlighter::with_sets

Source: https://docs.rs/edtui/0.11.2/src/edtui/view/syntax_higlighting.rs.html

Creates a new SyntaxHighlighter instance using custom Theme and SyntaxReference objects.

```APIDOC
## SyntaxHighlighter::with_sets

### Description
Allows manual configuration of the SyntaxHighlighter by providing explicit Theme and SyntaxReference objects along with their respective sets.

### Parameters
- **theme** (Theme) - Required - The custom theme object.
- **theme_set** (Arc<ThemeSet>) - Required - The set containing the theme.
- **syntax_ref** (SyntaxReference) - Required - The specific syntax reference.
- **syntax_set** (Arc<SyntaxSet>) - Required - The set containing the syntax reference.

### Response
- **SyntaxHighlighter** - The initialized SyntaxHighlighter instance.
```

--------------------------------

### Configure Word and Page Navigation Key Bindings

Source: https://docs.rs/edtui/0.11.2/src/edtui/events/key.rs.html

Sets up shortcuts for moving the cursor by words or pages. Uses Alt and Ctrl modifiers for word navigation, and PageUp/PageDown keys for page navigation.

```Rust
KeyEventRegister::i(vec![KeyInput::alt('f')]),
MoveWordForward(1).into(),
```

```Rust
KeyEventRegister::i(vec![KeyInput::alt('b')]),
MoveWordBackward(1).into(),
```

```Rust
KeyEventRegister::i(vec![KeyInput::ctrl(KeyCode::Right)]),
MoveWordForward(1).into(),
```

```Rust
KeyEventRegister::i(vec![KeyInput::ctrl(KeyCode::Left)]),
MoveWordBackward(1).into(),
```

```Rust
KeyEventRegister::i(vec![KeyInput::ctrl('v')]),
MoveHalfPageDown().into(),
```

```Rust
KeyEventRegister::i(vec![KeyInput::alt('v')]),
MoveHalfPageUp().into(),
```

```Rust
KeyEventRegister::i(vec![KeyInput::new(KeyCode::PageDown)]),
MovePageDown().into(),
```

```Rust
KeyEventRegister::i(vec![KeyInput::new(KeyCode::PageUp)]),
MovePageUp().into(),
```

--------------------------------

### Get Editor Base Style

Source: https://docs.rs/edtui/0.11.2/src/edtui/view/theme.rs.html

Retrieves the current base style configuration for the editor's text.

```rust
/// Returns the base style.
///
/// # Example
///
/// ```rust
/// use edtui::EditorTheme;
///
/// let theme = EditorTheme::default();
/// let base_style = theme.base_style();
/// ```
#[must_use]
pub fn base_style(&self) -> Style {
    self.base
}
```

--------------------------------

### Get TypeId of a Generic Type

Source: https://docs.rs/edtui/0.11.2/edtui/actions/delete/struct.DeleteLine.html

Implementation of the Any trait for generic types. This method returns the TypeId of the instance.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### Instantiate Arboard Clipboard

Source: https://docs.rs/edtui/0.11.2/src/edtui/clipboard/arboard.rs.html

Creates a new arboard clipboard instance. This may fail if the platform is not supported.

```rust
pub fn new() -> Result<Self, Box<dyn Error>> {
        let inner = arboard::Clipboard::new()?;
        Ok(Self { inner })
    }
```

--------------------------------

### Action Conversion Methods

Source: https://docs.rs/edtui/0.11.2/edtui/actions/enum.Action.html

Overview of the From and TryInto implementations for the Action type, enabling type conversion between generic Actions and specific command types.

```APIDOC
## Action Conversion API

### Description
This API provides conversion methods for the `Action` type. It supports infallible conversions using `From` and fallible conversions using `TryInto` for various editor actions.

### Methods
- **From**: Infallible conversion from specific action types to `Action`.
- **TryInto**: Fallible conversion from `Action` to specific action types.

### Supported Conversions (From)
- MoveWordBackward -> Action
- MoveWordForward -> Action
- MoveWordForwardToEndOfWord -> Action
- Paste -> Action
- PasteOverSelection -> Action
- Redo -> Action
- RemoveChar -> Action
- RemoveCharFromSearch -> Action
- ReplaceChar -> Action
- SelectCurrentSearch -> Action
- SelectInnerBetween -> Action
- SelectInnerWord -> Action
- SelectLine -> Action
- StartSearch -> Action
- StopSearch -> Action
- SwitchMode -> Action
- Undo -> Action

### Supported Conversions (TryInto)
- Action -> AppendCharToSearch
- Action -> AppendNewline
- Action -> ChangeInnerBetween
- Action -> ChangeInnerWord
- Action -> ChangeSelection
- Action -> Composed
- Action -> CopyLine
- Action -> CopySelection
- Action -> DeleteChar
- Action -> DeleteCharForward

### Error Handling
For `TryInto` implementations, the error type is defined as `&'static str`.
```

--------------------------------

### Check if Highlight is Reversed

Source: https://docs.rs/edtui/0.11.2/src/edtui/state/highlight.rs.html

Internal helper to determine if the highlight's start position is chronologically after its end position.

```rust
fn is_reversed(&self) -> bool {
    self.start.row > self.end.row
        || (self.start.row == self.end.row && self.start.col > self.end.col)
}
```

--------------------------------

### Default Clipboard creation

Source: https://docs.rs/edtui/0.11.2/edtui/clipboard/struct.Clipboard.html

Creates a Clipboard instance using `ArboardClipboard` which captures the system clipboard. It falls back to an internal clipboard if `ArboardClipboard` cannot be instantiated.

```rust
let clipboard = Clipboard::default();
```

--------------------------------

### Get EditorState Search Pattern

Source: https://docs.rs/edtui/0.11.2/src/edtui/state.rs.html

Retrieves the current search pattern string. Used to access the pattern being searched for.

```rust
impl EditorState {
    /// Returns the current search pattern.
    #[must_use]
    pub fn search_pattern(&self) -> String {
        self.search.pattern.clone()
    }
}
```

--------------------------------

### Configure Syntax Highlighter for EditorView

Source: https://docs.rs/edtui/0.11.2/edtui/struct.EditorView.html

Sets a syntax highlighter for the EditorView. Ensure the highlighter is correctly initialized with a theme and language.

```rust
use edtui::EditorState;
use edtui::EditorView;
use edtui::SyntaxHighlighter;

let mut state = EditorState::default();
let syntax_highlighter = SyntaxHighlighter::new("dracula", "rs").unwrap();

EditorView::new(&mut state).syntax_highlighter(Some(syntax_highlighter));
```

--------------------------------

### Configure Syntax Highlighter Extension

Source: https://docs.rs/edtui/0.11.2/src/edtui/view/syntax_higlighting.rs.html

Sets the file extension for syntax highlighting. Returns an error if the extension is not supported.

```rust
pub(crate) fn extension(
        mut self,
        extension: &'_ str,
    ) -> Result<Self, SyntaxHighlighterError<'_>> {
        let syntax_ref = match self.syntax_set.find_syntax_by_extension(extension) {
            Some(v) => v.clone(),
            None => return Err(ExtensionNotFound(extension)),
        };

        self.syntax_ref = syntax_ref;

        Ok(self)
    }
```

--------------------------------

### Get Normalized End Position

Source: https://docs.rs/edtui/0.11.2/src/edtui/state/highlight.rs.html

Returns the effective end position of the highlight, ensuring it's the chronologically later point.

```rust
pub fn end(&self) -> Index2 {
    if self.is_reversed() {
        self.start
    } else {
        self.end
    }
}
```

--------------------------------

### KeyInput Constructors and Methods

Source: https://docs.rs/edtui/0.11.2/edtui/events/struct.KeyInput.html

Provides methods for creating KeyInput instances with various key codes and modifiers.

```APIDOC
## KeyInput Implementations

### `pub fn new<K: Into<KeyCode>>(key: K) -> Self`

**Description**: Create a key input without any modifiers.

**Example**:
```rust
use edtui::events::KeyInput;

let input = KeyInput::new('s');
```

### `pub fn ctrl<K: Into<KeyCode>>(key: K) -> Self`

**Description**: Create a key input with the ctrl modifier.

**Example**:
```rust
use edtui::events::KeyInput;
use crossterm::event::KeyCode;

let input = KeyInput::ctrl(KeyCode::Esc);
```

### `pub fn alt<K: Into<KeyCode>>(key: K) -> Self`

**Description**: Create a key input with the alt modifier.

### `pub fn shift<K: Into<KeyCode>>(key: K) -> Self`

**Description**: Create a key input with the shift modifier.

### `pub fn with_modifiers<K: Into<KeyCode>, M: Into<Modifiers>>(key: K, modifiers: M) -> Self`

**Description**: Create a key input with a set of modifiers. Supports shift, ctrl and alt.

**Example**:
```rust
use edtui::events::KeyInput;
use crossterm::event::KeyModifiers;

let input = KeyInput::with_modifiers('k', KeyModifiers::CONTROL | KeyModifiers::SHIFT);
```

### `pub fn normalize_altgr(self) -> Self`

**Description**: Normalize AltGr key events for international keyboard support. Strips Ctrl+Alt modifiers from non-alphabetic characters, allowing symbols like `[`, `]`, `{`, `}`, `\`, `@` to be typed on keyboards where these require AltGr (e.g., German, Swiss German).
```

--------------------------------

### Arboard Clipboard Get Text

Source: https://docs.rs/edtui/0.11.2/src/edtui/clipboard/arboard.rs.html

Retrieves text from the clipboard using arboard. Returns an empty string if retrieval fails.

```rust
fn get_text(&mut self) -> String {
        self.inner.get_text().unwrap_or_default()
    }
```

--------------------------------

### impl TryInto<JoinLineWithLineBelow> for Action

Source: https://docs.rs/edtui/0.11.2/edtui/actions/delete/struct.JoinLineWithLineBelow.html

Implementation for attempting to convert an Action into JoinLineWithLineBelow.

```APIDOC
## impl TryInto<JoinLineWithLineBelow> for Action

### type Error = &'static str

### fn try_into( self, ) -> Result<JoinLineWithLineBelow, <Self as TryInto<JoinLineWithLineBelow>>::Error>
Attempts to convert an Action into a JoinLineWithLineBelow struct.
```

--------------------------------

### Skip Whitespace Backward

Source: https://docs.rs/edtui/0.11.2/src/edtui/helper.rs.html

Moves the column index backward past any whitespace characters. This is useful for finding the start of a word or token.

```rust
fn skip_whitespace_rev(lines: &Lines, index: &mut Index2) {
    while index.col > 0 {
        let line = lines.get(index.row);
        if line.is_none() {
            break;
        }
        let line = line.unwrap();
        if index.col > line.len() {
            index.col = line.len();
        }
        while index.col > 0 && line.chars().nth(index.col - 1).map_or(false, |c| c.is_whitespace()) {
            index.col -= 1;
        }
        if index.col > 0 {
            break;
        }
        if index.row == 0 {
            break;
        }
        index.row -= 1;
        index.col = lines.get(index.row).map_or(0, |l| l.len());
    }
}
```

--------------------------------

### Test Inserting Hello World

Source: https://docs.rs/edtui/0.11.2/src/edtui/events/key.rs.html

Tests the editor's ability to insert text, including spaces, capitalization, and newlines, using a sequence of key inputs.

```rust
    #[test]
    fn test_insert_hello_world() {
        use crate::EditorState;

        let mut state = EditorState::default();
        state.mode = EditorMode::Insert;

        let mut handler = KeyEventHandler::default();

        let inputs = vec![
            KeyInput::shift('H'),
            KeyInput::new('e'),
            KeyInput::new('l'),
            KeyInput::new('l'),
            KeyInput::new('o'),
            KeyInput::new(' '),
            KeyInput::shift('W'),
            KeyInput::new('o'),
            KeyInput::new('r'),
            KeyInput::new('l'),
            KeyInput::new('d'),
            KeyInput::shift('!'),
            KeyInput::new(KeyCode::Enter),
            KeyInput::shift('H'),
            KeyInput::new('i'),
            KeyInput::shift('!'),
        ];

        for input in inputs {
            handler.on_event(input, &mut state);
        }

        assert_eq!(state.lines.to_string(), String::from("Hello World!\nHi!"));
    }
```

--------------------------------

### Execute backward word deletion in EditorState

Source: https://docs.rs/edtui/0.11.2/src/edtui/actions/delete.rs.html

Verifies that DeleteWordBackward removes the preceding word and whitespace, resetting the cursor to the start of the line.

```rust
// On "W" of World, should delete "Hello " (previous word + whitespace)
let mut state = EditorState::new(Lines::from("Hello World"));
state.mode = EditorMode::Insert;
state.cursor = Index2::new(0, 6);

DeleteWordBackward(1).execute(&mut state);
assert_eq!(state.lines.to_string(), "World");
assert_eq!(state.cursor, Index2::new(0, 0));
}
```

--------------------------------

### Create SyntaxHighlighter with custom theme and syntax sets

Source: https://docs.rs/edtui/0.11.2/edtui/struct.SyntaxHighlighter.html

This function allows for the creation of a SyntaxHighlighter using custom theme and syntax configurations. It requires a Theme, ThemeSet, SyntaxReference, and SyntaxSet. This is useful for advanced customization beyond predefined themes and syntaxes.

```rust
use syntect::highlighting::Theme;
use syntect::parsing::{SyntaxDefinition, SyntaxSetBuilder};
use edtui::SyntaxHighlighter;
use edtui::{THEME_SET, SYNTAX_SET};

let theme = Theme::default(); // My custom theme
let mut syntax_set_builder = SyntaxSetBuilder::new(); // My custom syntax set builder
syntax_set_builder.add_plain_text_syntax(); // Add your syntax
let syntax_set = syntax_set_builder.build(); // My custom syntax set
let syntax_ref = syntax_set.syntaxes().first().unwrap().clone(); // My custom syntax reference
let syntax_highlighter = SyntaxHighlighter::with_sets(theme, THEME_SET.clone(), syntax_ref, SYNTAX_SET.clone());
```

--------------------------------

### Highlight Struct API

Source: https://docs.rs/edtui/0.11.2/src/edtui/state/highlight.rs.html

The Highlight struct represents a range of text in an editor defined by start and end coordinates, with an associated style.

```APIDOC
## Highlight Struct

### Description
A highlighted range in the editor with a custom style.

### Fields
- **start** (Index2) - Start position (row, column).
- **end** (Index2) - End position (row, column), inclusive.
- **style** (Style) - Style to apply to the highlighted range.

## Methods

### new
Creates a new Highlight instance.
- **Parameters**: start (Index2), end (Index2), style (Style)

### contains
Checks if a specific position (Index2) is contained within the highlight range.
- **Parameters**: pos (Index2)
- **Returns**: bool

### get_columns_in_row
Retrieves the start and end column indices for a given row within the highlight range.
- **Parameters**: row (usize), row_len (usize)
- **Returns**: Option<(usize, usize)>
```

--------------------------------

### Test Get Columns in Row

Source: https://docs.rs/edtui/0.11.2/src/edtui/state/highlight.rs.html

Tests the `get_columns_in_row` method for a multi-line highlight, verifying the correct column ranges for different rows.

```rust
#[test]
fn test_highlight_columns_in_row() {
    let highlight = Highlight::new(
        Index2::new(1, 3),
        Index2::new(3, 7),
        Style::default().bg(Color::Yellow),
    );

    assert_eq!(highlight.get_columns_in_row(0, 10), None);
    assert_eq!(highlight.get_columns_in_row(1, 10), Some((3, 10)));
    assert_eq!(highlight.get_columns_in_row(2, 10), Some((0, 10)));
    assert_eq!(highlight.get_columns_in_row(3, 10), Some((0, 7)));
    assert_eq!(highlight.get_columns_in_row(4, 10), None);
}
```

--------------------------------

### Create New EditorState

Source: https://docs.rs/edtui/0.11.2/edtui/struct.EditorState.html

Initializes a new EditorState with the provided lines of text. Use this to set up the editor with initial content.

```rust
use edtui::{EditorState, Lines};

let state = EditorState::new(Lines::from("First line\nSecond Line"));
```

--------------------------------

### From<StartSearch> for Action Trait Implementation

Source: https://docs.rs/edtui/0.11.2/edtui/actions/search/struct.StartSearch.html

Provides a way to convert a StartSearch command into an Action.

```APIDOC
### impl From<StartSearch> for Action

#### fn from(v: StartSearch) -> Action
Converts to this type from the input type.
```

--------------------------------

### Test Backward Cursor Movement

Source: https://docs.rs/edtui/0.11.2/src/edtui/actions/motion.rs.html

Verifies that the MoveBackward command correctly updates the cursor position, including boundary checks at the start of a line.

```rust
    #[test]
    fn test_move_backward() {
        let mut state = test_state();
        state.cursor = Index2::new(0, 11);

        MoveBackward(1).execute(&mut state);
        assert_eq!(state.cursor, Index2::new(0, 10));

        MoveBackward(10).execute(&mut state);
        assert_eq!(state.cursor, Index2::new(0, 0));

        MoveBackward(1).execute(&mut state);
        assert_eq!(state.cursor, Index2::new(0, 0));
    }
```

--------------------------------

### ClipboardTrait Definition

Source: https://docs.rs/edtui/0.11.2/src/edtui/clipboard.rs.html

Defines the essential methods for clipboard operations: setting and getting text. Any custom clipboard implementation must adhere to this trait.

```APIDOC
## Trait: ClipboardTrait

### Description
Trait defining clipboard operations.

### Methods
- `set_text(&mut self, text: String)`: Sets text to the clipboard.
- `get_text(&mut self) -> String`: Retrieves text from the clipboard.
```

--------------------------------

### TryInto<StartSearch> for Action Trait Implementation

Source: https://docs.rs/edtui/0.11.2/edtui/actions/search/struct.StartSearch.html

Provides a way to attempt conversion from an Action into a StartSearch command.

```APIDOC
### impl TryInto<StartSearch> for Action

#### type Error = &'static str
The type returned in the event of a conversion error.

#### fn try_into(self) -> Result<StartSearch, <Self as TryInto<StartSearch>>::Error>
Performs the conversion.
```

--------------------------------

### Create a new Clipboard instance

Source: https://docs.rs/edtui/0.11.2/edtui/clipboard/struct.Clipboard.html

Use this function to create a new Clipboard instance. It requires a type that implements the ClipboardTrait.

```rust
use edtui::clipboard::{Clipboard, ClipboardTrait};

struct MyClipboard(String);

impl ClipboardTrait for MyClipboard {
    fn set_text(&mut self, text: String) {
        self.0 = text;
    }

    fn get_text(&mut self) -> String {
        self.0.clone()
    }
}

let clipboard = MyClipboard(String::new());
let clipboard_wrapper = Clipboard::new(clipboard);
```

--------------------------------

### Define Highlight Struct

Source: https://docs.rs/edtui/0.11.2/src/edtui/state/highlight.rs.html

Defines a highlighted range with start and end positions and a style. Use this to mark specific text areas with custom formatting.

```rust
pub struct Highlight {
    /// Start position (row, column).
    pub start: Index2,
    /// End position (row, column), inclusive.
    pub end: Index2,
    /// Style to apply to the highlighted range.
    pub style: Style,
}
```

--------------------------------

### Configure Syntax Highlighter Theme

Source: https://docs.rs/edtui/0.11.2/src/edtui/view/syntax_higlighting.rs.html

Sets the theme for the highlighter. Returns an error if the specified theme is not found in the theme set.

```rust
pub fn theme(mut self, theme: &'_ str) -> Result<Self, SyntaxHighlighterError<'_>> {
        let theme = match self.theme_set.themes.get(theme) {
            Some(v) => v.clone(),
            None => return Err(ThemeNotFound(theme)),
        };

        self.theme = theme;

        Ok(self)
    }
```

--------------------------------

### Configure Basic Text Navigation Key Bindings

Source: https://docs.rs/edtui/0.11.2/src/edtui/events/key.rs.html

Maps common keyboard shortcuts for moving the cursor backward, forward, up, and down. Includes single key presses and Ctrl/Alt modifiers.

```Rust
KeyEventRegister::i(vec![KeyInput::ctrl('b')]),
MoveBackward(1).into(),
```

```Rust
KeyEventRegister::i(vec![KeyInput::new(KeyCode::Left)]),
MoveBackward(1).into(),
```

```Rust
KeyEventRegister::i(vec![KeyInput::ctrl('p')]),
MoveUp(1).into(),
```

```Rust
KeyEventRegister::i(vec![KeyInput::new(KeyCode::Up)]),
MoveUp(1).into(),
```

```Rust
KeyEventRegister::i(vec![KeyInput::ctrl('n')]),
MoveDown(1).into(),
```

```Rust
KeyEventRegister::i(vec![KeyInput::new(KeyCode::Down)]),
MoveDown(1).into(),
```

--------------------------------

### Manage Editor State Viewport and Highlights

Source: https://docs.rs/edtui/0.11.2/src/edtui/state.rs.html

Methods for interacting with editor highlights and viewport configuration.

```rust
#[must_use]
pub fn is_single_line(&self) -> bool {
    self.view.single_line
}

/// Add a custom highlight range.
pub fn add_highlight(&mut self, highlight: Highlight) {
    self.highlights.push(highlight);
}

/// Clear all custom highlights.
pub fn clear_highlights(&mut self) {
    self.highlights.clear();
}

/// Set all highlights, replacing any existing ones.
pub fn set_highlights(&mut self, highlights: Vec<Highlight>) {
    self.highlights = highlights;
}

/// Returns the current viewport offset as (x, y).
///
/// The viewport offset represents the top-left corner of the visible area
/// in editor coordinates. This is useful for implementing custom scroll
/// behavior.
///
/// - `x` is the horizontal offset (column)
/// - `y` is the vertical offset (row)
#[must_use]
pub fn viewport_offset(&self) -> (usize, usize) {
    (self.view.viewport.x, self.view.viewport.y)
}

/// Sets the viewport offset to the specified (x, y) position.
///
/// This allows manual control of the scroll position. The viewport offset
/// represents the top-left corner of the visible area in editor coordinates.
///
/// - `x` is the horizontal offset (column)
/// - `y` is the vertical offset (row)
///
/// Note: The viewport may be adjusted during the next render to keep the
/// cursor visible, depending on the cursor position.
pub fn set_viewport_offset(&mut self, x: usize, y: usize) {
    self.view.viewport.x = x;
    self.view.viewport.y = y;
}

/// Sets the viewport height (number of visible rows).
///
/// This is set automatically during render, so there is usually no need
/// to call this manually.
pub fn set_viewport_height(&mut self, height: usize) {
    self.view.update_num_rows(height);
}
```

--------------------------------

### Execute Action on EditorState

Source: https://docs.rs/edtui/0.11.2/edtui/struct.EditorState.html

Executes a given action on the editor state. Requires the action to implement the Execute trait. Example shows deleting a line.

```rust
use edtui::{EditorState, Lines};
use edtui::actions::DeleteLine;

let mut state = EditorState::new(Lines::from("Hello wold!"));
state.execute(DeleteLine(1))
```
Tokens:
Raw