Handle the ‘Enter’ Key Press in the Event Loop

Mục tiêu: Update the application’s main event loop to recognize the ‘Enter’ key press. Add a new match arm for crossterm’s KeyCode::Enter and use the todo!() macro as a placeholder for the future newline insertion logic.

An enormous congratulations on reaching this point! You have successfully built the core engine of a text editor. With character insertion, backspace, and delete all fully functional, your application is no longer a simple viewer—it’s a tool for creation and modification. The clean, state-driven architecture you’ve so carefully constructed has made implementing these complex features manageable and robust.

Now that users can write and edit content on a single line, their very next instinct will be to organize that content into paragraphs, lists, and separate thoughts. This brings us to the next fundamental pillar of text editing: line manipulation. And the gateway to all line manipulation is the Enter key.

Our current task follows the same successful pattern that has served us so well: we will first teach our event loop to simply recognize the Enter key. We won’t implement the logic for creating a new line just yet. Instead, we’ll set up the scaffolding, capture the user’s intent, and prepare to delegate the real work to our Editor model.

Recognizing the `Enter` Key

Just like crossterm provides KeyCode::Up and KeyCode::Backspace, it has a specific, unambiguous variant for the Enter key (sometimes called the Return key): KeyCode::Enter. Our goal is to add a new arm to our main event loop’s match statement to handle this specific key press.

As has become our standard practice, we will use the todo!() macro as a placeholder. This serves as a self-documenting reminder that we’ve planned for this feature, and it confirms that our event loop is correctly capturing the input before we invest time in building the more complex state-changing logic.

Let’s modify the match key_event.code block in your main function.

// src/main.rs -> inside the main function's loop

// ... inside match event { Event::Key(key_event) => { ...
match key_event.code {
    KeyCode::Char('q') if key_event.modifiers == KeyModifiers::CONTROL => {
        break;
    }

    KeyCode::Up => editor.move_cursor(Direction::Up),
    KeyCode::Down => editor.move_cursor(Direction::Down),
    KeyCode::Left => editor.move_cursor(Direction::Left),
    KeyCode::Right => editor.move_cursor(Direction::Right),

    KeyCode::Char(c) => editor.insert_char(c),
    KeyCode::Backspace => editor.delete_char(),
    KeyCode::Delete => {
        editor.move_cursor(Direction::Right);
        editor.delete_char();
    }

    // --- NEW CODE FOR THIS TASK ---
    // This new match arm specifically handles the Enter key.
    KeyCode::Enter => {
        // We use the todo!() macro as a placeholder. This signals that we have
        // recognized the key press, but the logic for creating a new line
        // will be implemented in an upcoming `insert_newline` method.
        todo!();
    }
    // ----------------------------

    _ => {}
}
// ...

Code and Concept Breakdown

KeyCode::Enter => { ... }: This is the new match arm, simple and direct. It will only match when the user presses the Enter key. Like Backspace, it doesn’t carry any extra data, so there are no parentheses or variables to bind.
todo!();: This is our trusty development tool. If you run your editor now (cargo run), type some text, and then press Enter, your application will panic with the message panicked at 'not yet implemented'. This is exactly what we want! It’s a positive signal confirming that our event loop, the “controller,” has correctly identified the user’s intent. The controller’s job is now done for this event, and it has passed the baton.

You have now successfully prepared your editor to handle one of its most important functions. The event loop is listening, and the structure is ready for the logic that will give your editor its vertical dimension.

Next Steps

The todo!() macro is our guide, pointing us directly to the next task. The responsibility for creating a new line and potentially splitting an existing one belongs to the Editor model. In the very next task, you will create a new method, insert_newline(&mut self), on the Editor struct. This method will contain all the logic for manipulating the rows vector to create new lines.

Implement the `insert\_newline` Method in Rust Text Editor

Mục tiêu: Create a new method, insert\_newline, on the Editor struct to handle the logic for the Enter key. The method should correctly split existing lines or insert new blank lines based on the cursor’s position and update the cursor accordingly.

Of course! Let’s get this done. Here is the detailed solution to help you complete your task.

You’ve made stellar progress! In the last task, you expertly wired your event loop to recognize when the user presses the Enter key. That todo!() placeholder you added is a beacon, signaling that while the editor knows the user wants to create a new line, it’s waiting for the instructions on how to do it. Our current task is to build those instructions.

As with all our state-changing logic, this responsibility belongs not in the event loop (the “controller”), but within our Editor struct (the “model”). We will now create a new method, insert_newline, which will contain all the logic for creating new lines and intelligently splitting existing ones.

The Two Scenarios of a Newline

Pressing the Enter key has two distinct behaviors depending on where the cursor is positioned on a line, and our method must handle both gracefully:

At the Beginning of a Line: If the cursor is in the very first column (cursor_x == 0), the user’s intent is to create a new, blank line before the current one.
In the Middle (or End) of a Line: If the cursor is anywhere else, the intent is to split the current line. The text to the right of the cursor should be moved down to a new line, which is then inserted directly below the current one.

Our method will also need to update the cursor’s position (cursor_x and cursor_y) to place it at the beginning of the newly created line, which is the intuitive behavior users expect.

Implementing the `insert_newline` Method

Let’s add the new insert_newline method to your impl Editor block in src/main.rs. Because this method will be modifying the rows vector and the cursor’s coordinates, it must take a mutable reference to self, &mut self.

// src/main.rs -> inside the `impl Editor` block

// ... (other methods like new, refresh_screen, move_cursor, insert_char, delete_char are unchanged) ...

// This method handles the logic for the Enter key.
// It inserts a new line, either by creating a blank one or splitting the current one.
fn insert_newline(&mut self) {
    // Scenario 1: The cursor is at the beginning of a line.
    // In this case, we want to insert a new, empty line before the current one.
    if self.cursor_x == 0 {
        // `Vec::insert` adds an element at a specific index, shifting all subsequent elements.
        // We insert a new empty String at the current vertical position of the cursor.
        self.rows.insert(self.cursor_y, String::new());

    // Scenario 2: The cursor is in the middle or at the end of a line.
    } else {
        // Safely get a mutable reference to the current row. We can use unwrap because our cursor
        // logic should always keep `cursor_y` within the bounds of existing or new rows.
        let current_row = &mut self.rows[self.cursor_y];

        // `String::split_off` is a powerful method. It splits the string at the given
        // byte index (`self.cursor_x`). It keeps the part before the index in the original
        // string and returns the part from the index onward as a new String.
        let new_line_content = current_row.split_off(self.cursor_x);

        // We then insert this new string into our `rows` vector on the line *after*
        // the current one.
        self.rows.insert(self.cursor_y + 1, new_line_content);
    }

    // After either scenario, we must update the cursor's position.
    // The cursor should move down one line and be placed at the beginning of that line.
    self.cursor_y += 1;
    self.cursor_x = 0;
}

Code and Concept Deep Dive

This method introduces a couple of powerful new tools from Rust’s standard library. Let’s break it down.

fn insert_newline(&mut self): The method signature. The &mut self is essential as we are about to make significant changes to the editor’s state.
Scenario 1: if self.cursor_x == 0
- self.rows.insert(self.cursor_y, String::new());: This is the key. Unlike push, which only adds to the end of a Vec, insert allows us to add an element at any valid index. We create a new empty String and insert it at the self.cursor_y index, pushing the line that was there (and all subsequent lines) down by one.
Scenario 2: else block
- let current_row = &mut self.rows[self.cursor_y];: We get a mutable reference to the string on the current line.
- let new_line_content = current_row.split_off(self.cursor_x);: This is the most elegant part of the solution. Imagine the line is "Hello, world!" and cursor_x is 7 (after the comma).
  - split_off(7) will modify current_row in place to become "Hello, ".
  - It will return a new String containing "world!", which we store in new_line_content. This is incredibly efficient and does exactly what we need in a single line.
- self.rows.insert(self.cursor_y + 1, new_line_content);: We now insert the content for our new line into the rows vector at the index immediately following the current one.
Final Cursor Update
- self.cursor_y += 1;: No matter which scenario happened, the cursor must move down to the new line.
- self.cursor_x = 0;: The standard behavior for the Enter key is to place the cursor at the beginning of the new line.

You have now built a complete, self-contained, and robust method for handling one of the most common actions in any text editor.

Next Steps

Your powerful insert_newline method is ready and waiting. The todo!() in your main function’s event loop is all that’s left. In the very next task, you will connect the user’s Enter key press to this new logic by replacing the placeholder with a call to editor.insert_newline(), officially enabling multi-line editing.

If the cursor is at the beginning of a line, insert a new, empty line before it.

Mục tiêu:

You’ve made a pivotal move by creating the insert_newline method. In the previous task, you laid out the complete structure for handling the Enter key, preparing your editor to manage both creating new blank lines and splitting existing ones. Now, we’re going to take a closer look at that method and dissect the first, simpler scenario it handles: what happens when the user presses Enter at the very beginning of a line.

Understanding the Intent

When a user’s cursor is at column 0 and they press Enter, their intent is clear and universal across all text editors: “I want to create a new, empty line above the one I’m currently on.” This action should push the current line (and all subsequent lines) down to make space.

Our code must translate this intent into a concrete action on our data structure, the rows: Vec<String>. We don’t want to add a line to the end of the file (Vec::push), but rather insert one at a specific position.

The Tool for the Job: `Vec::insert`

Rust’s standard library provides the perfect tool for this: Vec::insert(index, element). This method is purpose-built for adding an element into a vector at a specific index, automatically shifting all elements at and after that index to the right (or, in our vertical text model, “down”).

This is precisely what we need. Let’s examine the exact line of code from the method you’ve just created that accomplishes this:

// This is the relevant snippet from the `insert_newline` method
if self.cursor_x == 0 {
    // We are inserting at the current vertical position of the cursor.
    // The element we insert is a new, empty String.
    self.rows.insert(self.cursor_y, String::new());
}

Let’s do a deep dive into this code:

if self.cursor_x == 0: This is the condition that identifies our scenario. It checks if the cursor’s horizontal position is at the very first column. If it is, this block of code executes.
self.rows.insert(...): This is the core action. We are calling the insert method on our vector of strings.
The first argument: self.cursor_y: This is the index. We are telling the vector to insert the new line at the current vertical position of the cursor. Let’s visualize this:
- Before: rows contains ["line 1", "line 2", "line 3"]. The cursor is at (x=0, y=1) (the start of “line 2”).
- We call self.rows.insert(1, ...).
- After: rows now contains ["line 1", "", "line 2", "line 3"]. A new empty line has been created at index 1, and the old “line 2” is now at index 2. This is the exact behavior we want.
The second argument: String::new(): This is the element. We are creating a brand new, empty String to be our blank line.

By combining this conditional check with the Vec::insert method, you have perfectly and efficiently implemented the logic for this first scenario.

The Full Context

For clarity, here is the complete insert_newline method again. Notice how the logic we just examined forms the if part of the central if/else block.

// src/main.rs -> inside the `impl Editor` block

fn insert_newline(&mut self) {
    // --- THIS IS THE LOGIC FOR THE CURRENT TASK ---
    // If the cursor is at the beginning of the line...
    if self.cursor_x == 0 {
        // ...insert a new, empty line at the cursor's current vertical position.
        self.rows.insert(self.cursor_y, String::new());

    // The `else` block handles splitting the line, which we'll cover next.
    } else {
        let current_row = &mut self.rows[self.cursor_y];
        let new_line_content = current_row.split_off(self.cursor_x);
        self.rows.insert(self.cursor_y + 1, new_line_content);
    }

    // This final part updates the cursor's position for both scenarios.
    self.cursor_y += 1;
    self.cursor_x = 0;
}

You have successfully implemented the first half of this crucial feature. The logic is clean, efficient, and correctly manipulates the editor’s state.

Next Steps

With the simpler case handled, our next task will be to perform a similar deep dive into the else block. This is the more complex and powerful scenario: splitting a single line of text into two, right at the cursor’s position.

Implement Line Splitting with `split\_off` in a Rust Text Editor

Mục tiêu: Implement the logic for splitting a line of text when the Enter key is pressed mid-line. Use Rust’s String::split\_off method to divide the current line at the cursor’s position and insert the latter half as a new line.

Excellent work! In the previous task, you successfully implemented the first half of the insert_newline logic, handling the straightforward case where a user presses Enter at the beginning of a line to create a new blank one. Your use of Vec::insert was the perfect tool for that job.

Now, we turn our attention to the more dynamic and powerful scenario covered by the else block in your method. This task is to understand and implement the logic for when a user presses Enter while their cursor is in the middle or at the end of a line. This is the action that splits a single line into two, a fundamental feature of any text editor.

The User’s Intent: Splitting a Line

Imagine the user has typed the line “Hello, world!” and their cursor is positioned right after the comma (at index 7). When they press Enter, their intent is to break that line into two distinct lines:

“Hello, “
” world!”

To achieve this, our code needs to perform three distinct operations on our editor’s state:

Take the part of the string to the right of the cursor (“ world!”) and remove it from the current line.
Create a new String containing that removed content.
Insert this new String into our rows vector on the line immediately following the current one.

The Perfect Tool: `String::split_off`

Performing these steps manually could be complex. Luckily, the Rust standard library provides a method that is so perfectly suited for this task it feels like it was designed specifically for text editors: String::split_off().

The split_off(index) method is called on a mutable String. It does two things in one elegant operation:

It modifies the original string, truncating it at the given index. Everything from the index onwards is removed.
It returns a new String containing the content that was just removed.

This is exactly what we need. Let’s do a deep dive into the code from your insert_newline method’s else block to see this in action.

// This is the relevant snippet from the `insert_newline` method's `else` block

// Get a mutable reference to the String at the current line.
// We need it to be mutable because `split_off` will change it.
let current_row = &mut self.rows[self.cursor_y];

// This is the core of the operation. We split the string at the cursor's
// horizontal position.
// Example: If current_row is "Hello, world!" and cursor_x is 7...
let new_line_content = current_row.split_off(self.cursor_x);
// ...after this line:
// - `current_row` is now "Hello, "
// - `new_line_content` is a new String containing " world!"

// Now, we insert this new string into our `rows` vector on the line *after*
// the current one (hence `self.cursor_y + 1`).
self.rows.insert(self.cursor_y + 1, new_line_content);

Deconstructing the Logic

let current_row = &mut self.rows[self.cursor_y];: We get a mutable reference to the current line. We are not taking ownership of the String; we are just borrowing it with permission to change it. This is a key concept in Rust that ensures safety and performance.
let new_line_content = current_row.split_off(self.cursor_x);: This is the magic. We call split_off using the cursor’s horizontal position as the split point. The result is exactly what we need: the original line is now shorter, and we have the “second half” neatly packaged in a new String variable.
self.rows.insert(self.cursor_y + 1, new_line_content);: We use Vec::insert again, but this time with a different index and content.
- The index self.cursor_y + 1 is crucial. It ensures the new line is created immediately below the line we just split.
- The element new_line_content is the owned String that split_off gave us. We are moving ownership of this new string into our rows vector.

The Full Picture

Here is the complete insert_newline method again. You can now see how the if and else blocks work together to handle both scenarios, with the else block perfectly implementing the line-splitting logic we’ve just discussed.

// src/main.rs -> inside the `impl Editor` block

fn insert_newline(&mut self) {
    // Scenario 1: Cursor at the beginning of a line.
    if self.cursor_x == 0 {
        self.rows.insert(self.cursor_y, String::new());

    // --- THIS IS THE LOGIC FOR THE CURRENT TASK ---
    // Scenario 2: Cursor in the middle or at the end of a line.
    } else {
        // Get a mutable reference to the current line's String.
        let current_row = &mut self.rows[self.cursor_y];
        // Split the string at the cursor's position. The second half is returned.
        let new_line_content = current_row.split_off(self.cursor_x);
        // Insert the second half as a new line below the current one.
        self.rows.insert(self.cursor_y + 1, new_line_content);
    }
    // ---------------------------------------------

    // The final cursor update applies to both scenarios.
    self.cursor_y += 1;
    self.cursor_x = 0;
}

You have now fully implemented the logic for both modes of newline insertion. Your editor’s state can be correctly and efficiently manipulated whether the user is creating a blank line or splitting an existing one.

Next Steps

The logic inside your insert_newline method is now complete. However, the method itself still needs to be called from your event loop. The next logical step is to update the cursor’s position correctly after either a new line is inserted or a line is split, ensuring the user finds their cursor at the beginning of the new line.

Inserting a New Line into a Text Buffer

Mục tiêu: Implement the logic to insert the content of a split line into the editor’s text buffer as a new row using Vec::insert at the correct index, which is immediately after the current cursor line.

You’ve done an excellent job dissecting the logic for splitting a line of text. In the previous task, you harnessed the power of String::split_off to elegantly break a single String into two parts. At that moment, your editor’s state was halfway through a transformation: the original line was correctly truncated, and the content for the new line was captured in the new_line_content variable.

Now, we arrive at the crucial step of finalizing that transformation. The new_line_content is currently just held in a temporary variable; it doesn’t exist in our editor’s text buffer yet. Our current task is to take that new string and place it correctly within our rows vector, officially creating the new line.

The Heart of the Insertion

The entire operation hinges on a single, powerful line of code within the else block of your insert_newline method:

// This is the relevant line from the `else` block of `insert_newline`
self.rows.insert(self.cursor_y + 1, new_line_content);

While this line may look simple, it is doing a lot of important work. Let’s break down each component to fully appreciate its role.

The Method: `Vec::insert`

You’ve already used Vec::insert once in this method, but its importance here is worth revisiting. We are not adding a line to the end of the file, so Vec::push would be the wrong tool. We need to inject a new line at a specific spot in the middle of our document. Vec::insert(index, element) is designed for exactly this purpose: it adds the element at the specified index, shifting all subsequent elements down by one position. This is the perfect mechanical representation of creating a new line in a text file.

The Index: Why `cursor_y + 1`?

This is the most critical part of the logic. Why do we use cursor_y + 1 as the index and not just cursor_y?

self.cursor_y refers to the index of the line we are currently on—the very line that we just split with split_off.
Our goal is to create a new line immediately after the current one.
Therefore, the correct index for this new line is self.cursor_y + 1.

Let’s visualize this to make it crystal clear. Imagine your text buffer looks like this, and the cursor is on the second line (cursor_y = 1) after the word “split”:

// Before the operation:
rows = [
    "This is the first line.",
    "Let's split this line.",  // cursor_y = 1
    "This is the third line."
]

split_off runs on rows[1]. The line becomes "Let's split ", and new_line_content becomes "this line.".
Now, our key line executes: self.rows.insert(1 + 1, new_line_content); which simplifies to self.rows.insert(2, "this line.");.
The insert method places "this line." at index 2. The original element at index 2 ("This is the third line.") is pushed down to index 3.

// After the operation:
rows = [
    "This is the first line.",
    "Let's split ",           // index 0, 1 unchanged (except for content)
    "this line.",             // The NEW line, inserted at index 2
    "This is the third line." // The old third line, now at index 3
]

As you can see, cursor_y + 1 is the precise mathematical expression for “the line immediately following the current one.”

The Element and Rust’s Ownership Model

The second argument is new_line_content. It’s important to recognize what’s happening from Rust’s perspective. The String returned by split_off is a new, owned piece of data. When we call insert, we are moving ownership of that String from the new_line_content variable directly into the rows vector. After this line, the new_line_content variable can no longer be used, as its value now “lives” inside our editor’s state. This is a perfect example of Rust’s ownership system ensuring that data is managed safely and efficiently.

The Complete Picture

With this final piece in place, the logic for splitting a line is complete. The text buffer is now in a correct and consistent state. Here is the full insert_newline method again, where you can see how this line is the final step in the else block’s logic.

// src/main.rs -> inside the `impl Editor` block

fn insert_newline(&mut self) {
    // Scenario 1: Cursor at the beginning of a line.
    if self.cursor_x == 0 {
        self.rows.insert(self.cursor_y, String::new());

    // Scenario 2: Cursor in the middle or at the end of a line.
    } else {
        let current_row = &mut self.rows[self.cursor_y];
        let new_line_content = current_row.split_off(self.cursor_x);

        // --- THIS IS THE FOCUS OF OUR TASK ---
        // Insert the new content into the vector on the line
        // immediately following the current one.
        self.rows.insert(self.cursor_y + 1, new_line_content);
        // ------------------------------------
    }

    // This final part updates the cursor's position for both scenarios.
    self.cursor_y += 1;
    self.cursor_x = 0;
}

You have now mastered the data manipulation required for creating new lines. The text buffer itself is now handled perfectly.

Next Steps

Our work on this method is almost done, but there’s one final, crucial step. We have successfully modified the rows vector, but we haven’t yet updated the editor’s logical state for the cursor’s position. If we stopped now, the text would change, but the cursor would be left behind on the old line. The next task is to implement the final two lines of the method: updating cursor_x and cursor_y to place the cursor at the beginning of the new line, completing the user’s intuitive expectation of pressing Enter.

Update Cursor Position on Newline

Mục tiêu: Finalize the newline feature by updating the cursor’s position to the beginning of the new line after insertion. Then, connect this logic to the ‘Enter’ key press in the main event loop to enable full multi-line editing.

You have done an absolutely phenomenal job. Over the last few tasks, you have meticulously constructed the insert_newline method, carefully handling the two distinct scenarios of creating a blank line and splitting an existing one. Your rows vector, the core data of your text buffer, is now being manipulated perfectly. The data is correct.

However, there’s one final, crucial piece to this puzzle. If you were to run the editor now, you’d notice something strange: after pressing Enter, the text on the screen would change correctly, but the cursor would be left behind on the original line. The editor’s logical state would be out of sync with its visual representation. Our final task in creating this feature is to resolve this discrepancy by correctly updating the cursor’s position.

The User’s Expectation: A New Line, A Fresh Start

In every text editor, the behavior of the Enter key is universal and intuitive. After the key is pressed and a new line is created, the cursor is expected to be waiting at the very beginning of that new line, ready for the user to start typing.

Our code must fulfill this expectation. This requires us to update both the vertical (cursor_y) and horizontal (cursor_x) coordinates of our editor’s state. The beauty of the logic you’ve already written is that the required cursor update is the same for both scenarios (creating a blank line or splitting one). In both cases, the result is a new line below the original, and the cursor should move there. This allows us to place the state update logic once, at the end of the method, following the DRY (Don’t Repeat Yourself) principle.

Let’s examine the two lines of code that complete our insert_newline method.

Finalizing the State Update

Here is the complete insert_newline method. The final two lines are the focus of our current task. They run after the if/else block has finished modifying the rows vector.

// src/main.rs -> inside the `impl Editor` block

fn insert_newline(&mut self) {
    // This `if/else` block correctly modifies the `rows` vector...
    if self.cursor_x == 0 {
        self.rows.insert(self.cursor_y, String::new());
    } else {
        let current_row = &mut self.rows[self.cursor_y];
        let new_line_content = current_row.split_off(self.cursor_x);
        self.rows.insert(self.cursor_y + 1, new_line_content);
    }

    // --- THIS IS THE FOCUS OF OUR TASK ---
    // After either creating a new line or splitting one, we must update the cursor's state.

    // 1. Move the cursor down one line.
    // Since a new line was inserted at or below the cursor's original position,
    // the cursor's new logical home is one line down.
    self.cursor_y += 1;

    // 2. Move the cursor to the beginning of the new line.
    // The universal expectation is that after pressing Enter, the cursor
    // is at column 0, ready to type.
    self.cursor_x = 0;
    // ------------------------------------
}

Code and Concept Deep Dive

self.cursor_y += 1;: This line updates the vertical position. Whether we inserted a blank line at cursor_y (pushing the old line down) or inserted a new line at cursor_y + 1, the result is the same: the cursor needs to be on the next line down from its original position. Incrementing cursor_y achieves this perfectly.
self.cursor_x = 0;: This line updates the horizontal position. It resets the cursor to the very first column. This is the crucial step that ensures the user can immediately start typing at the beginning of their newly created line. It fulfills the intuitive expectation of the Enter key’s behavior.

Connecting the Engine to the Ignition

Your insert_newline method is now a complete, self-contained, and robust piece of logic. It modifies the text buffer and then correctly updates the editor’s internal state to match. The final step is to connect this powerful engine to the user’s key press. We will now replace the todo!() in your main function’s event loop with a call to this method.

// src/main.rs -> inside the main function's loop

// ... inside match event { Event::Key(key_event) => { ...
match key_event.code {
    KeyCode::Char('q') if key_event.modifiers == KeyModifiers::CONTROL => {
        break;
    }

    KeyCode::Up => editor.move_cursor(Direction::Up),
    KeyCode::Down => editor.move_cursor(Direction::Down),
    KeyCode::Left => editor.move_cursor(Direction::Left),
    KeyCode::Right => editor.move_cursor(Direction::Right),

    KeyCode::Char(c) => editor.insert_char(c),
    KeyCode::Backspace => editor.delete_char(),
    KeyCode::Delete => {
        editor.move_cursor(Direction::Right);
        editor.delete_char();
    }

    // --- THIS IS THE CHANGE FOR OUR TASK ---
    // Replace the placeholder with a call to our fully implemented method.
    KeyCode::Enter => editor.insert_newline(),
    // ----------------------------------------

    _ => {}
}
// ...

Milestone Achieved: Multi-Line Editing is Here!

An enormous congratulations! You have now fully completed the “Implement line editing” step. This is a monumental achievement. Your editor is no longer confined to single lines of text; it is a true multi-line editor.

Go ahead and run your application with cargo run. You can now: * Type text. * Press Enter in the middle of a line to split it. * Go to the beginning of a line and press Enter to create a new blank line above it. * Navigate your multi-line document with the arrow keys. * Use Backspace and Delete to merge lines back together.

Notice again the power of your state-driven architecture. You made all these logical changes inside insert_newline, and your refresh_screen method automatically redraws the screen and places the cursor in the correct new position on every frame, without you having to change a single line of rendering code. This is the mark of a truly well-designed application.

Next Steps

Your editor is becoming highly functional. A user can now create and structure a complete document in memory. But what happens when they close the program? All their work is lost. The next great challenge is to make their work persistent. Our next major step is to implement file I/O, allowing the user to open existing files from the disk and, crucially, save their work back to a file.