fix(editor): code blocks cover only the selected lines and can be left

The code button took in the line whose end a selection started at, and
lines sharing a paragraph through line breaks or an image turned the whole
paragraph into code. Selections now ignore lines they only touch at the
line break, and the lines selected are split into paragraphs of their own
first. A note ending in code could not be continued below it: Enter on an
empty last code line now ends the block, and Down on the last line or a
click below the text opens a plain line after it.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: thebanri

CHANGELOG.md

@@ -6,6 +6,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Fixed
+- The code block button makes only the selected lines code. A selection starting at the end of a line, or ending at the start of one, no longer takes that line in, and lines that share a paragraph with an image or other lines (split by Shift+Enter or pasted line breaks) become a paragraph of their own instead of turning the whole paragraph into code. The same selection rule applies to the list and checklist buttons.
+- A note that ends in a code block can be continued below it: Enter on an empty last code line ends the block, and Down on the last line or a click below the text opens a plain line after it.
+
 ## [0.1.9] - 2026-09-22
 
 ### Changed

app/src/text_formatter.cpp

@@ -596,10 +596,21 @@ QList<QTextBlock> blocksIn(QTextDocument *document, int start, int end) {
     if (!document || start < 0 || end < start ||
         end >= document->characterCount())
         return blocks;
-    for (auto block = document->findBlock(start); block.isValid();
-         block = block.next()) {
+    auto first = document->findBlock(start);
+    auto last = document->findBlock(end);
+    // A selection starting after the last character of a paragraph, or
+    // ending before the first one of the next, only touches the line break
+    // between them: dragging from the end of a line takes in no text of it.
+    if (end > start) {
+        if (first != last && first.length() > 1 &&
+            start == first.position() + first.length() - 1)
+            first = first.next();
+        if (first != last && end == last.position())
+            last = last.previous();
+    }
+    for (auto block = first; block.isValid(); block = block.next()) {
         blocks.append(block);
-        if (block.position() + block.length() > end)
+        if (block == last)
             break;
     }
     return blocks;
@@ -709,15 +720,71 @@ bool TextFormatter::codeActive(QQuickTextDocument *quickDocument, int start,
     return any;
 }
 
+namespace {
+// Code formatting is per paragraph, but one paragraph can hold several lines:
+// line breaks (Shift+Enter, or <br> in pasted HTML) and images, each on a line
+// of its own. Splits the paragraphs around start and end there, so the lines
+// from start to end become paragraphs of their own and formatting them
+// leaves the other lines as they are. Returns how far start and end moved.
+int isolateLines(QTextCursor &cursor, int start, int end) {
+    QTextDocument *document = cursor.document();
+    // After the last selected line first, so start stays where it is.
+    // A selection ending just after a line break, or starting just before
+    // one, takes in no text of the line beyond it (as in blocksIn()).
+    auto block = document->findBlock(end);
+    QString text = block.text();
+    int from = end - block.position();
+    if (end > start && from > 0 && text.at(from - 1) == QChar::LineSeparator)
+        --from;
+    for (int i = from; i < text.size(); ++i) {
+        if (i == 0)
+            continue;
+        if (text.at(i) == QChar::LineSeparator) {
+            cursor.setPosition(block.position() + i);
+            cursor.deleteChar();
+            cursor.insertBlock();
+            break;
+        }
+        if (text.at(i) == QChar::ObjectReplacementCharacter) {
+            cursor.setPosition(block.position() + i);
+            cursor.insertBlock();
+            break;
+        }
+    }
+    block = document->findBlock(start);
+    text = block.text();
+    from = start - block.position();
+    if (end > start && from < text.size() && text.at(from) == QChar::LineSeparator)
+        ++from;
+    for (int i = std::min(from, int(text.size())) - 1; i >= 0; --i) {
+        if (text.at(i) == QChar::LineSeparator) {
+            cursor.setPosition(block.position() + i);
+            cursor.deleteChar();
+            cursor.insertBlock();
+            return 0;
+        }
+        if (text.at(i) == QChar::ObjectReplacementCharacter) {
+            if (i + 1 >= text.size())
+                return 0;
+            cursor.setPosition(block.position() + i + 1);
+            cursor.insertBlock();
+            return 1;
+        }
+    }
+    return 0;
+}
+} // namespace
+
 void TextFormatter::toggleCode(QQuickTextDocument *quickDocument, int start,
                                int end) {
     auto *document = quickDocument ? quickDocument->textDocument() : nullptr;
-    const auto blocks = blocksIn(document, start, end);
-    if (blocks.isEmpty())
+    if (blocksIn(document, start, end).isEmpty())
         return;
     const bool code = !codeActive(quickDocument, start, end);
     QTextCursor cursor(document);
     cursor.beginEditBlock();
+    const int moved = isolateLines(cursor, start, end);
+    const auto blocks = blocksIn(document, start + moved, end + moved);
     for (const auto &block : blocks) {
         if (isImageOnly(block))
             continue;
@@ -737,6 +804,37 @@ void TextFormatter::toggleCode(QQuickTextDocument *quickDocument, int start,
     cursor.endEditBlock();
 }
 
+bool TextFormatter::endEmptyCodeLine(QQuickTextDocument *quickDocument,
+                                     int position) {
+    auto *document = quickDocument ? quickDocument->textDocument() : nullptr;
+    if (!document || position < 0 || position >= document->characterCount())
+        return false;
+    const auto block = document->findBlock(position);
+    if (!isCodeBlock(block) || !block.text().isEmpty() ||
+        (block.next().isValid() && isCodeBlock(block.next())))
+        return false;
+    QTextCursor cursor(document);
+    cursor.beginEditBlock();
+    setCode(block, false);
+    cursor.endEditBlock();
+    return true;
+}
+
+int TextFormatter::lineAfterCode(QQuickTextDocument *quickDocument) {
+    auto *document = quickDocument ? quickDocument->textDocument() : nullptr;
+    if (!document || !isCodeBlock(document->lastBlock()))
+        return -1;
+    QTextCursor cursor(document);
+    cursor.beginEditBlock();
+    cursor.movePosition(QTextCursor::End);
+    // The new paragraph starts as a copy of the code line; setCode() takes
+    // the code formatting off again.
+    cursor.insertBlock();
+    setCode(cursor.block(), false);
+    cursor.endEditBlock();
+    return cursor.block().position();
+}
+
 void TextFormatter::restoreCodeFont(QQuickTextDocument *quickDocument) {
     auto *document = quickDocument ? quickDocument->textDocument() : nullptr;
     if (!document)

app/src/text_formatter.h

@@ -60,6 +60,13 @@ class TextFormatter : public QObject {
     // Makes the paragraphs from start to end code, or plain text again.
     Q_INVOKABLE void toggleCode(QQuickTextDocument *document, int start,
                                 int end);
+    // Enter on an empty last line of a code block ends the block: the line
+    // becomes plain text. Returns whether it did.
+    Q_INVOKABLE bool endEmptyCodeLine(QQuickTextDocument *document, int position);
+    // A note ending in code gets a plain paragraph after it, so there is
+    // somewhere to write below the block. Returns that paragraph's position,
+    // or -1 when the note does not end in code.
+    Q_INVOKABLE int lineAfterCode(QQuickTextDocument *document);
     // Restores the font of empty code lines, which HTML does not keep, so text
     // typed there after reopening a note is code too.
     Q_INVOKABLE void restoreCodeFont(QQuickTextDocument *document);

app/tests/notes_flow.qml

@@ -816,6 +816,40 @@ Window {
         check(!codeLine(0) && codeLine(1), "The code button did not turn the caret's line back into text")
         body.text = ""
 
+        // A selection from the end of one line to the start of another takes
+        // in neither of them, only the lines between.
+        body.insert(0, "<p>above</p><p>middle</p><p>below</p>")
+        body.select("above".length, "above\nmiddle\n".length)
+        window.toggleCode()
+        check(!codeLine(0) && codeLine(1) && !codeLine(2), "The code button took in the lines around the selection")
+        body.text = ""
+
+        // Lines inside one paragraph, split by line breaks or an image, are
+        // made code on their own.
+        body.insert(0, "<p>one<br>two<br>three</p>")
+        body.select("one\n".length, "one\ntwo".length)
+        window.toggleCode()
+        check(!codeLine(0) && codeLine(1) && !codeLine(2), "The code button took in lines sharing the paragraph: " + JSON.stringify(window.plainContent))
+        check(window.plainContent === "one\ntwo\nthree", "Splitting the paragraph changed the text: " + JSON.stringify(window.plainContent))
+        body.text = ""
+
+        // Enter on an empty last code line ends the block.
+        body.forceActiveFocus()
+        typeText("```\ncode\n\nplain")
+        check(window.plainContent === "code\nplain", "Enter on an empty code line kept it: " + JSON.stringify(window.plainContent))
+        check(codeLine(0) && !codeLine(1), "Enter on an empty code line did not end the block")
+        body.select(body.length - 1, body.length)
+        check(body.cursorSelection.font.family !== "monospace", "Text typed after leaving the block is still monospace")
+        body.text = ""
+
+        // Down on a code block that ends the note opens a plain line under it.
+        body.forceActiveFocus()
+        typeText("```\nlast")
+        input.keyClick(Qt.Key_Down)
+        typeText("tail")
+        check(window.plainContent === "last\ntail" && codeLine(0) && !codeLine(1), "Down did not leave the code block: " + JSON.stringify(window.plainContent))
+        body.text = ""
+
         // The toolbar buttons turn existing lines into a list and back.
         // The note is rich text by now, so each line is its own paragraph,
         // as pressing Enter makes them.

qml/windows/StickyNote.qml

@@ -919,6 +919,29 @@ ApplicationWindow {
         return true
     }
 
+    // Enter on an empty last line of a code block ends the block.
+    function leaveCodeBlock() {
+        if (!isRichText || hasTextSelection) return false
+        if (!formatter.endEmptyCodeLine(contentEditor.textDocument, contentEditor.cursorPosition)) return false
+        typingFont(false)
+        backend.editContent(contentEditor.text)
+        autosave.restart()
+        return true
+    }
+
+    // Down on the last line, or a click below the text, opens a plain line
+    // after a code block that ends the note; otherwise there is none to reach.
+    function openLineAfterCode() {
+        if (!isRichText) return false
+        const caret = formatter.lineAfterCode(contentEditor.textDocument)
+        if (caret < 0) return false
+        contentEditor.cursorPosition = caret
+        typingFont(false)
+        backend.editContent(contentEditor.text)
+        autosave.restart()
+        return true
+    }
+
     // The editor keeps the format for the next typed character with its own
     // caret, so a change to the paragraph alone would not reach new text.
     function typingFont(code) {
@@ -2221,13 +2244,19 @@ ApplicationWindow {
                 onSelectionStartChanged: if (noteWindow.selectedImage >= 0 && selectionStart !== noteWindow.selectedImage) noteWindow.selectedImage = -1
                 onSelectionEndChanged: if (noteWindow.selectedImage >= 0 && selectionEnd !== noteWindow.selectedImage + 1) noteWindow.selectedImage = -1
 
-                // Enter on an empty list item ends the list.
-                // Enter on a ``` line opens or closes a code block, and on an
-                // empty list item ends the list.
+                // Enter on a ``` line opens or closes a code block, on an empty
+                // last code line ends the block, and on an empty list item
+                // ends the list.
                 Keys.onReturnPressed: function(event) {
                     event.accepted = event.modifiers === Qt.NoModifier
-                        && (noteWindow.codeFence() || noteWindow.leaveEmptySubItem() || (noteWindow.isRichText
-                            && formatter.endEmptyListItem(contentEditor.textDocument, contentEditor.cursorPosition)))
+                        && (noteWindow.codeFence() || noteWindow.leaveCodeBlock() || noteWindow.leaveEmptySubItem()
+                            || (noteWindow.isRichText
+                                && formatter.endEmptyListItem(contentEditor.textDocument, contentEditor.cursorPosition)))
+                }
+                Keys.onDownPressed: function(event) {
+                    const caret = positionToRectangle(cursorPosition)
+                    event.accepted = event.modifiers === Qt.NoModifier && !noteWindow.hasTextSelection
+                        && caret.y >= positionToRectangle(length).y && noteWindow.openLineAfterCode()
                 }
                 Keys.onEscapePressed: function(event) {
                     if (noteWindow.findOpen) {
@@ -2259,7 +2288,9 @@ ApplicationWindow {
                         const x = eventPoint.position.x
                         const y = eventPoint.position.y
                         const link = noteWindow.linkAt(x, y)
+                        const end = contentEditor.positionToRectangle(contentEditor.length)
                         if (link.length > 0) noteWindow.openLink(link)
+                        else if (y > end.y + end.height && noteWindow.openLineAfterCode()) return
                         else noteWindow.selectImageAt(x, y)
                     }
                     // Double-clicking an image keeps it selected for resizing;