Struct EditorElement 

pub struct EditorElement { /* private fields */ }

A GPUI Element that renders an Editor

Implementations

impl EditorElement

pub fn new(editor: Editor) -> Self

Create a new EditorElement from an Editor

Examples found in repository

examples/editor_demo.rs (line 344)

    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
        let _current_theme = &self.available_themes[self.current_theme_index];
        let (current_language, _, _) = &self.available_languages[self.current_language_index];

        let language = match current_language.as_str() {
            "Rust" => Language::Rust,
            _ => Language::PlainText,
        };

        let cursor_position = self.editor.cursor_position();
        let cursor_point = Point::new(cursor_position.col, cursor_position.row);

        let selection = if self.editor.has_selection() {
            let selected_text = self.get_selected_text();
            Some(Selection {
                lines: selected_text.matches('\n').count(),
                chars: selected_text.len(),
            })
        } else {
            None
        };

        div()
            .key_context("editor")
            .size_full()
            .flex()
            .flex_col()
            .child(
                div()
                    .flex_grow()
                    .track_focus(&self.focus_handle)
                    .on_action(cx.listener(Self::move_up))
                    .on_action(cx.listener(Self::move_down))
                    .on_action(cx.listener(Self::move_left))
                    .on_action(cx.listener(Self::move_right))
                    .on_action(cx.listener(Self::move_up_with_shift))
                    .on_action(cx.listener(Self::move_down_with_shift))
                    .on_action(cx.listener(Self::move_left_with_shift))
                    .on_action(cx.listener(Self::move_right_with_shift))
                    .on_action(cx.listener(Self::backspace))
                    .on_action(cx.listener(Self::delete))
                    .on_action(cx.listener(Self::insert_newline))
                    .on_action(cx.listener(Self::select_all))
                    .on_action(cx.listener(Self::escape))
                    .on_action(cx.listener(Self::copy))
                    .on_action(cx.listener(Self::cut))
                    .on_action(cx.listener(Self::paste))
                    .on_action(cx.listener(Self::next_theme))
                    .on_action(cx.listener(Self::previous_theme))
                    .on_action(cx.listener(Self::next_language))
                    .on_action(cx.listener(Self::previous_language))
                    .on_key_down(cx.listener(
                        |this: &mut Self, event: &KeyDownEvent, _window, cx| {
                            // Handle character input
                            if let Some(text) = &event.keystroke.key_char {
                                if !event.keystroke.modifiers.platform
                                    && !event.keystroke.modifiers.control
                                    && !event.keystroke.modifiers.function
                                {
                                    for ch in text.chars() {
                                        this.editor.insert_char(ch);
                                    }
                                    cx.notify();
                                }
                            }
                        },
                    ))
                    .child(EditorElement::new(self.editor.clone())),
            )
            .child(MetaLine::new(cursor_point, language, selection))
    }

pub fn editor(&self) -> &Editor

Get a reference to the underlying Editor

pub fn editor_mut(&mut self) -> &mut Editor

Get a mutable reference to the underlying Editor

Trait Implementations

impl Element for EditorElement

type RequestLayoutState = ()

The type of state returned from Element::request_layout. A mutable reference to this state is subsequently provided to Element::prepaint and Element::paint.

type PrepaintState = ()

The type of state returned from Element::prepaint. A mutable reference to this state is subsequently provided to Element::paint.

fn id(&self) -> Option<ElementId>

If this element has a unique identifier, return it here. This is used to track elements across frames, and will cause a GlobalElementId to be passed to the request_layout, prepaint, and paint methods.

fn source_location(&self) -> Option<&'static Location<'static>>

Source location where this element was constructed, used to disambiguate elements in the inspector and navigate to their source code.

fn request_layout( &mut self, _: Option<&GlobalElementId>, _: Option<&InspectorElementId>, window: &mut Window, cx: &mut App, ) -> (LayoutId, Self::RequestLayoutState)

Before an element can be painted, we need to know where it’s going to be and how big it is. Use this method to request a layout from Taffy and initialize the element’s state.

fn prepaint( &mut self, _: Option<&GlobalElementId>, _: Option<&InspectorElementId>, _: Bounds<Pixels>, _: &mut Self::RequestLayoutState, _window: &mut Window, _cx: &mut App, ) -> Self::PrepaintState

After laying out an element, we need to commit its bounds to the current frame for hitbox purposes. The state argument is the same state that was returned from Element::request_layout().

fn paint( &mut self, _: Option<&GlobalElementId>, _: Option<&InspectorElementId>, bounds: Bounds<Pixels>, _: &mut Self::RequestLayoutState, _: &mut Self::PrepaintState, window: &mut Window, cx: &mut App, )

Once layout has been completed, this method will be called to paint the element to the screen. The state argument is the same state that was returned from Element::request_layout().

fn into_any(self) -> AnyElement

Convert this element into a dynamically-typed AnyElement.

impl IntoElement for EditorElement

type Element = EditorElement

The specific type of element into which the implementing type is converted. Useful for converting other types into elements automatically, like Strings

fn into_element(self) -> Self::Element

Convert self into a type that implements Element.

fn into_any_element(self) -> AnyElement

Convert self into a dynamically-typed AnyElement.