Multi-line Editor preserves CRLF carriage returns from Windows clipboard

[yuexiliuli]

Multi-line Editor Preserves CRLF Carriage Returns From Windows Clipboard

Summary

gpui-component multi-line EditorState preserves \r from Windows CRLF clipboard text. This can make the first N-1 pasted lines render as blank or disappear visually, while the underlying text is still present.

The final line usually renders normally because it has no trailing \r.

Environment

• Windows
• Clipboard source: VS Code

• gpui = { git = "https://github.com/zed-industries/zed" }
  gpui-component = { git = "https://github.com/longbridge/gpui-component" }
  

Reproduction

1. Create a multi-line gpui_component::input::Editor.

2. Paste the following text from VS Code:

   use std::cell::RefCell;
   use std::collections::HashMap;
   use std::ops::Range;
   use std::rc::Rc;

3. Select and copy the first line.

4. Move the caret to the end of that first line.

5. Paste three times with Ctrl+V.

Actual Behavior

• The first line, and generally all pasted lines except the final logical line, can become visually blank.
• Typing on those lines also appears blank.
• Ctrl+A, then Ctrl+C, then pasting into another application shows the text is still present.
• The copied text reveals that the content was inserted as separate lines.
• If five lines are initially pasted, the first four can fail while the last line renders normally.
• Copying through Notepad++ avoids the issue, likely because it converts clipboard line endings to LF.

Expected Behavior

All pasted lines should remain visible and editable, independent of whether the clipboard source uses LF or CRLF.

Root Cause

Windows clipboard content from VS Code uses CRLF:

line1\r\nline2\r\nline3\r\nline4

The multi-line input path in gpui-component preserves \r.

The relevant flow is:

Paste
-> replace_text_in_range_silent
-> replace_text_in_range
-> normalize_input

In crates/base/src/input/base/state.rs, normalize_input currently removes \r and \n only for single-line inputs. Multi-line editors retain \r.

As a result, \r is treated as a normal shaped character at the end of every line except the last. This produces the predictable "first N-1 lines fail, final line works" behavior.

Proposed Fix

Normalize all multi-line input to LF before inserting text:

fn normalize_input<'a>(&self, new_text: &'a str) -> Cow<'a, str> {
    let normalized = if matches!(self.mask_pattern, MaskPattern::Number { .. }) {
        normalize_number_input(new_text)
    } else {
        Cow::Borrowed(new_text)
    };

    if self.is_single_line() && normalized.contains(['\n', '\r']) {
        Cow::Owned(normalized.replace(['\n', '\r'], ""))
    } else if self.is_multi_line() && normalized.contains('\r') {
        Cow::Owned(normalized.replace("\r\n", "\n").replace('\r', "\n"))
    } else {
        normalized
    }
}

This preserves the internal LF-only line model and prevents \r from reaching shaping, layout, cursor hit testing, and display-map code.

Application Workaround

As a temporary workaround, the application can override the component paste action after gpui_component::init(cx):

gpui_component::init(cx);

cx.bind_keys([KeyBinding::new(
    "ctrl-v",
    PasteNormalized,
    Some("Input"),
)]);

The custom action reads clipboard text, converts CRLF/CR to LF, then calls EditorState::replace.

The order is important: registering before gpui_component::init(cx) does not work because component initialization installs its default key bindings afterward.

[yuexiliuli]

Below is the code after adding the normalization function.

use gpui::*;
use gpui_component::{
    button::Button,
    input::{Editor, EditorState, InputEvent, TabSize},
    ActiveTheme as _, Root, Sizable as _, StyledExt as _,
};

actions!(code_editor, [PasteNormalized]);

const INITIAL_CODE: &str = r#"fn main() {
    println!("Hello from GPUI Editor!");
}
"#;

pub struct CodeEditor {
    editor: Entity<EditorState>,
    status: SharedString,
    dirty: bool,
    _subscription: Subscription,
}

impl CodeEditor {
    fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
        let editor = cx.new(|cx| {
            EditorState::new(window, cx)
                .default_value(INITIAL_CODE)
                .placeholder("Write code here...")
                .tab_size(TabSize {
                    tab_size: 4,
                    hard_tabs: false,
                })
                .soft_wrap(false)
        });

        let _subscription =
            cx.subscribe_in(&editor, window, |this, _, event: &InputEvent, _, cx| {
                if matches!(event, InputEvent::Change) && !this.dirty {
                    this.dirty = true;
                    this.status = "Modified".into();
                    cx.notify();
                }
            });

        Self {
            editor,
            status: "Ready".into(),
            dirty: false,
            _subscription,
        }
    }

    fn reset(&mut self, _: &ClickEvent, window: &mut Window, cx: &mut Context<Self>) {
        self.editor
            .update(cx, |editor, cx| editor.set_value(INITIAL_CODE, window, cx));
        self.dirty = false;
        self.status = "Restored example".into();
        window.focus(&self.editor.read(cx).focus_handle(cx), cx);
        cx.notify();
    }

    fn paste_normalized(
        &mut self,
        _: &PasteNormalized,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) {
        let Some(clipboard) = cx.read_from_clipboard() else {
            return;
        };
        let Some(text) = clipboard.text() else {
            return;
        };

        self.editor.update(cx, |editor, cx| {
            editor.replace(normalize_newlines(&text), window, cx);
        });
        window.focus(&self.editor.read(cx).focus_handle(cx), cx);
    }
}

/// GPUI component's editor uses LF internally. Normalize Windows clipboard
/// text so CR is never shaped as an end-of-line character.
fn normalize_newlines(text: &str) -> String {
    text.replace("\r\n", "\n").replace('\r', "\n")
}

impl Render for CodeEditor {
    fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
        let theme = cx.theme();
        let cursor = self.editor.read(cx).cursor_position();

        div()
            .v_flex()
            .size_full()
            .bg(theme.background)
            .text_color(theme.foreground)
            .on_action(cx.listener(Self::paste_normalized))
            .child(
                div()
                    .h(px(48.))
                    .px_4()
                    .flex()
                    .items_center()
                    .gap_3()
                    .border_b_1()
                    .border_color(theme.border)
                    .child(
                        div()
                            .font_weight(FontWeight::BOLD)
                            .child("GPUI Code Editor"),
                    )
                    .child(
                        Button::new("reset-code")
                            .small()
                            .label("Reset")
                            .on_click(cx.listener(Self::reset)),
                    )
                    .child(div().flex_1())
                    .child(
                        div()
                            .font_family(theme.mono_font_family.clone())
                            .text_sm()
                            .text_color(theme.muted_foreground)
                            .child("main.rs"),
                    ),
            )
            .child(
                div()
                    .h(px(34.))
                    .px_4()
                    .flex()
                    .items_center()
                    .bg(theme.secondary)
                    .border_b_1()
                    .border_color(theme.border)
                    .font_family(theme.mono_font_family.clone())
                    .text_sm()
                    .child(format!("main.rs{}", if self.dirty { " *" } else { "" })),
            )
            .child(
                div()
                    .flex_1()
                    .min_h_0()
                    .p_2()
                    .child(Editor::new(&self.editor).bordered(false).h(relative(1.))),
            )
            .child(
                div()
                    .h(px(28.))
                    .px_4()
                    .flex()
                    .items_center()
                    .justify_between()
                    .bg(theme.secondary)
                    .border_t_1()
                    .border_color(theme.border)
                    .text_xs()
                    .text_color(theme.muted_foreground)
                    .child(self.status.clone())
                    .child(format!(
                        "Ln {}, Col {}",
                        cursor.line + 1,
                        cursor.character + 1
                    )),
            )
    }
}

fn main() {
    let app = gpui_platform::application().with_assets(gpui_component_assets::Assets);

    app.run(move |cx| {
        gpui_component::init(cx);
        // gpui-component installs its default Ctrl+V binding during init.
        // Register after it so the editor dispatches PasteNormalized instead.
        cx.bind_keys([KeyBinding::new("ctrl-v", PasteNormalized, Some("Input"))]);

        cx.spawn(async move |cx| {
            cx.open_window(WindowOptions::default(), |window, cx| {
                let view = cx.new(|cx| CodeEditor::new(window, cx));
                cx.new(|cx| Root::new(view, window, cx))
            })
            .expect("Failed to open window");
        })
        .detach();
    });
}

#[cfg(test)]
mod tests {
    use super::normalize_newlines;

    #[test]
    fn normalizes_windows_clipboard_newlines() {
        assert_eq!(normalize_newlines("a\r\nb\r\nc"), "a\nb\nc");
        assert_eq!(normalize_newlines("a\r\nb\r\n"), "a\nb\n");
        assert_eq!(normalize_newlines("a\rb"), "a\nb");
    }

    #[test]
    fn preserves_lf_only_text() {
        assert_eq!(normalize_newlines("a\nb\nc"), "a\nb\nc");
    }
}