Add opt-in vim key bindings

README.md

@@ -22,8 +22,76 @@ Install via the Omarchy Package Repository via the `omawrite` package. It's inst
 - `Ctrl+F` searches the document. Use `Enter` or `Ctrl+G` for the next match and `Shift+Enter` for the previous match.
 - `Ctrl+H` opens find and replace.
 - `Ctrl+B`, `Ctrl+I`, and `Ctrl+K` insert bold, italic, and link Markdown.
+- `Ctrl+Alt+V` turns vim mode on and off.
 - `Ctrl+?` shows the keyboard shortcut reference.
 
+## Vim mode
+
+The diamond in the bottom-left corner, or `Ctrl+Alt+V`, toggles vim key
+bindings, and the choice is remembered between sessions. The current mode sits
+in the bottom-left corner, and normal mode draws the caret as a block. Insert
+mode is the plain editor: smart returns, list continuation and Markdown paste
+all behave as they do with vim mode off.
+
+- Modes: `i` `I` `a` `A` `o` `O` to insert, `v` and `V` to select, `Esc` to
+  return to normal.
+- Motions: `h` `j` `k` `l`, `w` `W` `b` `B` `e` `E` `ge` `gE`, `0` `^` `$`,
+  `gg` `G`, `{` `}` by paragraph, `(` `)` by sentence, and `f` `F` `t` `T`
+  with `;` and `,`.
+- `j` and `k` follow the wrapped line, so a paragraph moves the way it reads
+  on screen. `gj` and `gk` reach the logical line the Markdown has, which is
+  the mirror of vim, where `g` is the display-line prefix. Operators keep the
+  logical line either way: `dj` takes two whole paragraphs.
+- Operators: `d` `c` `y` with any motion, doubled for whole lines (`dd`, `cc`,
+  `yy`), plus `D` `C` `Y` `S` `s` `x` `X` `r` `J` `~` and `p` / `P`.
+- Text objects: `iw` `aw`, `ip` `ap`, `i"` `a"`, `i'` `a'`, and the bracket
+  pairs `i(` `i[` `i{` with their `a` forms. They take a span without a
+  motion, under an operator or from visual mode.
+- Counts work throughout: `3j`, `d2w`, `2dd`.
+- `u` and `Ctrl+R` undo and redo a whole command at a time, and `.` repeats the
+  last change, including the text typed during it.
+- `/` opens the app's find bar, with `n` and `N` for next and previous match.
+  `Ctrl+D` and `Ctrl+U` scroll by a page.
+
+### Registers
+
+Yanks and deletes go to vim's unnamed register, which stays inside the editor:
+an `x` never costs you what you copied from a browser. `"` names a register
+for the command after it.
+
+- `"ayy` and `"ap` keep a line aside in `a`, one of `"a` to `"z`. A named yank
+  fills the unnamed register too, so a bare `p` still pastes what you last
+  took.
+- `"+y` and `"+p` are the system clipboard, for carrying text out of the
+  window and back. `"*` is the primary selection, where a middle click pastes
+  from, falling back to the clipboard on desktops without one.
+- A clipboard carries no linewise flag, so a trailing newline stands in for
+  one: `"+yy` here pastes as a whole line into another vim, and text copied
+  from elsewhere ending in a newline arrives as a line.
+
+Every `Ctrl` shortcut above keeps working in either mode.
+
+### The `:` command line
+
+`:` opens a command line along the bottom edge. `Enter` runs it; `Esc`, or
+backspacing past the start, abandons it.
+
+- `:w`, `:w <path>`, `:wq`, `:x`, `:q`, `:q!` write and quit. Writing an
+  unsaved document opens the portal picker, and `:q` on a modified one asks
+  before closing, the same as clicking the window's close button.
+- `:e <path>` opens a file, `:e!` reloads the open one from disk. Relative
+  paths hang off the open document's directory, and `~` is your home.
+- `:42`, `:$` jump to a line.
+- `:s/pattern/replacement/`, with `%`, `3`, `2,5` or `'<,'>` in front of it to
+  choose the lines, and `g` (every match on the line) or `i` (ignore case)
+  after it. `&` stands for the whole match and `\1` for a capture group, and
+  any punctuation can stand in for `/` as the separator. Patterns are
+  JavaScript regular expressions, not vim's.
+- `:d` deletes the lines in the range, into the same register `p` pastes from.
+- `:noh` clears the search highlight.
+
+`u` undoes a whole `:s` or `:d` in one step.
+
 Unsaved drafts are recovered after an abnormal exit. Omawrite also watches open files
 and warns before an external change can replace local work.
 

src/EditorMutations.js

@@ -4,10 +4,19 @@ function normalizePlainText(text) {
     return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
 }
 
+// Inside a QTextDocument edit block the editor's text property still holds
+// the version from before the block opened, and clamping a range against it
+// drags the edit back inside the old length. An editor that can tell the
+// difference offers liveLength(); one that cannot is never in a block.
+function documentLength(editor) {
+    return editor.liveLength ? editor.liveLength() : editor.text.length;
+}
+
 function replaceRange(editor, rangeStart, rangeEnd, replacement,
                       selectionStartOffset, selectionEndOffset) {
-    var start = Math.max(0, Math.min(editor.text.length, rangeStart));
-    var end = Math.max(start, Math.min(editor.text.length, rangeEnd));
+    var limit = documentLength(editor);
+    var start = Math.max(0, Math.min(limit, rangeStart));
+    var end = Math.max(start, Math.min(limit, rangeEnd));
     var insertedText = normalizePlainText(replacement);
 
     if (start !== end)

src/FooterIconButton.qml

@@ -54,6 +54,15 @@ Item {
                 context.lineTo(4.5, 9.5);
                 context.lineTo(11.5, 9.5);
                 context.lineTo(11.5, 13.5);
+            } else if (control.iconName === "vim") {
+                context.moveTo(8, 1.5);
+                context.lineTo(14.5, 8);
+                context.lineTo(8, 14.5);
+                context.lineTo(1.5, 8);
+                context.closePath();
+                context.moveTo(5.5, 5.5);
+                context.lineTo(8, 10.5);
+                context.lineTo(10.5, 5.5);
             } else {
                 context.moveTo(2.5, 13);
                 context.lineTo(2.5, 3.5);