side-vim 0.1.0__py3-none-any.whl

side_vim/caret.py

@@ -0,0 +1,131 @@
+"""vim's block cursor in Visual mode.
+
+The selection is the editor's own, so the app's copy (Ctrl+C) copies what `y` yanks.
+But Qt draws its cursor at one end of its selection, and in vim the character under
+the cursor is part of the selection, so the two don't line up. In Visual mode the
+editor's cursor is hidden and this widget draws vim's one on top of the text. It
+blinks like the editor's cursor, and only while the editor has focus.
+"""
+
+from math import ceil
+
+from PySide6.QtCore import QPointF, QRect, Qt, QTimer
+from PySide6.QtGui import QGuiApplication, QPainter, QPaintEvent, QPalette, QTextCursor
+from PySide6.QtWidgets import QPlainTextEdit, QWidget
+
+from side_vim.text import split_clusters, utf16_len
+
+
+class Caret(QWidget):
+    def __init__(self, editor: QPlainTextEdit) -> None:
+        super().__init__(editor.viewport())
+        self._editor = editor
+        self._position: int | None = None
+        self._text = ""
+        self._ascent = 0.0
+        self._on = True  # the half of the blink it's drawn in
+        self._blink = QTimer(self)
+        self._blink.timeout.connect(self._toggle)
+        self.setAttribute(Qt.WidgetAttribute.WA_TransparentForMouseEvents)
+        self.setFocusPolicy(Qt.FocusPolicy.NoFocus)
+        self.hide()
+        editor.updateRequest.connect(self._on_update_request)
+
+    @property
+    def position(self) -> int | None:
+        """The Qt position of the character it's on, or None when hidden."""
+        return self._position
+
+    def show_at(self, position: int | None) -> None:
+        """Draw the cursor on the character at this Qt position; None hides it."""
+        if position != self._position:
+            self._position = position
+            self.restart_blink()
+        self.place()
+
+    def restart_blink(self) -> None:
+        """Drawn from now on for half a blink, like the editor's cursor after a move.
+        Call it when the editor gets or loses focus."""
+        self._on = True
+        flash = QGuiApplication.styleHints().cursorFlashTime()
+        if self._position is not None and flash > 0 and self._editor.hasFocus():
+            self._blink.start(flash // 2)
+        else:
+            self._blink.stop()
+        self.update()
+
+    def _toggle(self) -> None:
+        self._on = not self._on
+        self.update()
+
+    def place(self) -> None:
+        """Put the widget over its character again, after a scroll or a change."""
+        position = self._position
+        document = self._editor.document()
+        if position is None or position >= document.characterCount():
+            self.hide()
+            return
+        cursor = QTextCursor(document)
+        cursor.setPosition(position)
+        block = cursor.block()
+        offset = position - block.position()
+        line = block.layout().lineForTextPosition(offset)
+        if not line.isValid():
+            self.hide()
+            return
+        self._text = char_at(block.text(), offset)
+        self._ascent = line.ascent()
+        rect = self._editor.cursorRect(cursor)
+        width = char_width(self._editor, position)
+        geometry = QRect(rect.left(), rect.top(), width, ceil(line.height()))
+        if self.geometry() != geometry:
+            self.setGeometry(geometry)
+        self.update()
+        self.show()
+        self.raise_()
+
+    def _on_update_request(self, _rect: QRect, _dy: int) -> None:
+        if self._position is not None:
+            self.place()
+
+    def paintEvent(self, event: QPaintEvent) -> None:
+        if not (self._on and self._editor.hasFocus()):
+            return
+        palette = self._editor.palette()
+        painter = QPainter(self)
+        painter.fillRect(self.rect(), palette.color(QPalette.ColorRole.Text))
+        if self._text.strip():
+            painter.setPen(palette.color(QPalette.ColorRole.Base))
+            painter.setFont(self._editor.font())
+            painter.drawText(QPointF(0, self._ascent), self._text)
+        painter.end()
+
+
+def char_at(text: str, offset: int) -> str:
+    """The character starting at a UTF-16 offset in a block's text, or "" at its end."""
+    end = 0
+    for cluster in split_clusters(text):
+        end += utf16_len(cluster)
+        if end > offset:
+            return cluster
+    return ""
+
+
+def char_width(editor: QPlainTextEdit, position: int) -> int:
+    """The width of the character at a Qt position, as the editor draws it. At the end
+    of a line, the width of an "x"."""
+    cursor = QTextCursor(editor.document())
+    cursor.setPosition(position)
+    block = cursor.block()
+    offset = position - block.position()
+    metrics = editor.fontMetrics()
+    cluster = char_at(block.text(), offset)
+    if not cluster:
+        return max(metrics.horizontalAdvance("x"), 1)
+    line = block.layout().lineForTextPosition(offset)
+    end = offset + utf16_len(cluster)
+    if line.isValid() and end <= line.textStart() + line.textLength():
+        width = line.cursorToX(end)[0] - line.cursorToX(offset)[0]
+        if width >= 1:
+            return ceil(width)
+    return max(metrics.horizontalAdvance(cluster), metrics.horizontalAdvance("x"), 1)

side_vim/edits.py

@@ -0,0 +1,84 @@
+"""Edits vim makes that are worked out on plain text: joining lines, and where the
+cursor goes after undo, redo and Visual mode operators. No Qt here.
+"""
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+
+from side_vim.motions import BLANKS, Line, Pos, first_non_blank
+
+
+@dataclass(frozen=True)
+class Register:
+    """What yank, delete and change saved. linewise: whole lines (`yy`, `dd`), and the
+    text ends with a newline. Otherwise part of a line (`yw`, `x`)."""
+
+    text: str = ""
+    linewise: bool = False
+
+
+def join_parts(lines: Sequence[str]) -> list[tuple[int, str]]:
+    """How vim's J (with 'nojoinspaces') joins lines: for each line after the first,
+    how many leading blanks it loses, and what goes before it ("" or one space).
+
+    No space goes in when the line so far is empty or ends in a blank, or when the
+    next line is empty (or all blanks) or starts with ")".
+    """
+    parts: list[tuple[int, str]] = []
+    empty = not lines[0]
+    previous = lines[0]
+    for line in lines[1:]:
+        rest = line.lstrip("".join(BLANKS))
+        space = bool(rest) and not rest.startswith(")") and not empty
+        space = space and not previous.endswith(BLANKS)
+        parts.append((len(line) - len(rest), " " if space else ""))
+        empty = empty and not rest
+        previous = rest
+    return parts
+
+
+def join(lines: Sequence[str]) -> tuple[str, int]:
+    """The line vim's J makes of these lines, and the index in it (in code points)
+    where the cursor goes: where the last join happened."""
+    out = lines[0]
+    cursor = 0
+    for line, (blanks, space) in zip(lines[1:], join_parts(lines), strict=True):
+        cursor = len(out)
+        out += space + line[blanks:]
+    return out, cursor
+
+
+def undo_cursor(lines: Sequence[Line], saved: Pos | None, first: int, last: int) -> Pos:
+    """Where vim puts the cursor after an undo or redo (u_undoredo in vim's undo.c).
+
+    saved: the cursor when the change was made, or None if unknown. first and last:
+    the lines the undo or redo changed, as they are now. If the saved cursor is in or
+    next to those lines, it goes back there. Otherwise it goes to the first changed
+    line, on its first non-blank.
+    """
+    last_line = len(lines) - 1
+    if saved is not None and first - 1 <= saved.line <= last + 1:
+        line = saved.line
+    else:
+        line = first
+        if saved is not None and saved.line + 1 == line and line > 0:
+            # off by one line: back where the change was made (undoing an `o`)
+            line = saved.line
+    line = min(max(line, 0), last_line)
+    text = lines[line]
+    col = saved.col if saved is not None and saved.line == line else first_non_blank(text)
+    return Pos(line, min(col, max(len(text) - 1, 0)))
+
+
+def visual_start(anchor: Pos, cursor: Pos, linewise: bool) -> Pos:
+    """Where an operator on a Visual selection starts: the cursor goes there after `y`,
+    and `u` puts it back there.
+
+    Part of a line: the start of the selection. Whole lines: the cursor if it's on a
+    line above the other end, otherwise column 0 of the first line, like vim.
+    """
+    if not linewise:
+        return min(anchor, cursor)
+    if cursor.line < anchor.line:
+        return cursor
+    return Pos(anchor.line, 0)

side_vim/keys.py

@@ -0,0 +1,134 @@
+"""Qt key events as vim key tokens: "w", "G", "<Esc>", "<C-r>", "<Left>".
+
+None means the key isn't for vim: a modifier on its own, a key with Cmd (macOS) or
+Meta, or a key with no text that vim doesn't know (PageUp, F1). Those go to the editor
+or the app as usual.
+"""
+
+import sys
+import unicodedata
+
+from PySide6.QtCore import QCoreApplication, Qt
+from PySide6.QtGui import QKeyEvent
+
+ESC = "<Esc>"
+IS_MAC = sys.platform == "darwin"
+
+# Invisible characters used in emoji and Indic scripts.
+JOINERS = frozenset({"\u200c", "\u200d"})
+
+# Keys without text, by their vim name. Shift and Alt add "S-" and "A-".
+NAMED = {
+    Qt.Key.Key_Escape: "Esc",
+    Qt.Key.Key_Left: "Left",
+    Qt.Key.Key_Right: "Right",
+    Qt.Key.Key_Up: "Up",
+    Qt.Key.Key_Down: "Down",
+    Qt.Key.Key_Home: "Home",
+    Qt.Key.Key_End: "End",
+    Qt.Key.Key_Return: "CR",
+    Qt.Key.Key_Enter: "CR",
+    Qt.Key.Key_Backspace: "BS",
+    Qt.Key.Key_Delete: "Del",
+    Qt.Key.Key_Tab: "Tab",
+    Qt.Key.Key_Backtab: "Tab",
+    Qt.Key.Key_Insert: "Insert",
+}
+
+MODIFIER_KEYS = frozenset(
+    {
+        Qt.Key.Key_Shift,
+        Qt.Key.Key_Control,
+        Qt.Key.Key_Meta,
+        Qt.Key.Key_Alt,
+        Qt.Key.Key_AltGr,
+        Qt.Key.Key_CapsLock,
+        Qt.Key.Key_NumLock,
+        Qt.Key.Key_ScrollLock,
+        Qt.Key.Key_Super_L,
+        Qt.Key.Key_Super_R,
+        Qt.Key.Key_Hyper_L,
+        Qt.Key.Key_Hyper_R,
+        Qt.Key.Key_Mode_switch,
+    }
+)
+
+
+def map_layout(token: str, layout: dict[str, str] | None) -> str:
+    """A key token with its letter mapped through a layout map: "к" -> "r",
+    "<C-к>" -> "<C-r>", and "<C-х>" -> "<Esc>" like Ctrl+[. Tokens it doesn't know
+    stay as they are."""
+    if not layout:
+        return token
+    if token in layout:
+        return layout[token]
+    if token.startswith("<C-") and token.endswith(">"):
+        head, _, name = token[1:-1].rpartition("-")
+        mapped = layout.get(name)
+        if mapped is not None and len(mapped) == 1:
+            if head == "C" and mapped == "[":
+                return ESC  # Ctrl+х is the key of Ctrl+[
+            # Ctrl tokens use the lower case name, like key_token does
+            return f"<{head}-{mapped.lower() if mapped.isalpha() else mapped}>"
+    return token
+
+
+def control_modifier(mac: bool = IS_MAC) -> Qt.KeyboardModifier:
+    """The modifier the physical Control key arrives as. On macOS Qt swaps Ctrl and Cmd,
+    so Control arrives as Meta, unless the app turned the swap off."""
+    swapped = not QCoreApplication.testAttribute(Qt.ApplicationAttribute.AA_MacDontSwapCtrlAndMeta)
+    if mac and swapped:
+        return Qt.KeyboardModifier.MetaModifier
+    return Qt.KeyboardModifier.ControlModifier
+
+
+def _name(key: int) -> str | None:
+    """A key's name for a Ctrl token: the lower case character, or a NAMED name."""
+    if key in NAMED:
+        return NAMED[key]
+    if key < 0x110000 and chr(key).isprintable():
+        return chr(key).lower()
+    return None
+
+
+def _is_text(text: str) -> bool:
+    """True if a key typed text. Not str.isprintable: that refuses the joiner in a
+    family emoji, and the key would then type in Normal mode."""
+    return bool(text) and all(unicodedata.category(ch)[0] != "C" or ch in JOINERS for ch in text)
+
+
+def key_token(event: QKeyEvent, mac: bool = IS_MAC) -> str | None:
+    """The vim token for a key press, or None if the key isn't for vim."""
+    key = event.key()
+    if key in MODIFIER_KEYS:
+        return None
+    mods = event.modifiers()
+    ctrl = control_modifier(mac)
+    # Cmd on macOS, the Meta (Super) key elsewhere: always the app's
+    app_modifier = (
+        Qt.KeyboardModifier.MetaModifier
+        if ctrl == Qt.KeyboardModifier.ControlModifier
+        else Qt.KeyboardModifier.ControlModifier
+    )
+    if mods & app_modifier:
+        return None
+    shift = "S-" if mods & Qt.KeyboardModifier.ShiftModifier else ""
+    alt = "A-" if mods & Qt.KeyboardModifier.AltModifier else ""
+    text = event.text()
+
+    if mods & ctrl:
+        if (key == Qt.Key.Key_BracketLeft or text == "\x1b") and not (shift or alt):
+            return ESC
+        name = _name(key)
+        return f"<C-{alt}{shift}{name}>" if name else None
+
+    if key in NAMED:
+        if key == Qt.Key.Key_Escape:
+            return ESC
+        return f"<{alt}{shift}{NAMED[key]}>"
+    if text == "\x1b":
+        return ESC
+    if _is_text(text):
+        # on macOS, Option is how people type characters, so its text is just text
+        return f"<A-{text}>" if alt and not mac else text
+    return None

side_vim/layouts.py

@@ -0,0 +1,13 @@
+"""Keyboard layout maps for VimMode.layout_map."""
+
+# The Ukrainian layout: each Cyrillic letter maps to the Latin key in the same place,
+# so Normal mode keys work without switching layouts. Only letters: punctuation stays
+# as it is, so the English layout keeps working. ґ is left out, since its key differs
+# between layout variants.
+UKRAINIAN_LOWER = "йцукенгшщзхїфівапролджєячсмитьбю"
+LATIN_LOWER = "qwertyuiop[]asdfghjkl;'zxcvbnm,."
+LATIN_UPPER = 'QWERTYUIOP{}ASDFGHJKL:"ZXCVBNM<>'
+UKRAINIAN: dict[str, str] = {
+    **dict(zip(UKRAINIAN_LOWER, LATIN_LOWER, strict=True)),
+    **dict(zip(UKRAINIAN_LOWER.upper(), LATIN_UPPER, strict=True)),
+}

side_vim/mode.py

@@ -0,0 +1,10 @@
+"""The vim modes."""
+
+from enum import Enum
+
+
+class Mode(Enum):
+    NORMAL = "normal"
+    INSERT = "insert"
+    VISUAL = "visual"
+    VISUAL_LINE = "visual line"