QCodeSitter 0.1.0__py3-none-any.whl

QCodeSitter/defaults.py

@@ -0,0 +1,93 @@
+"""The standard editor setup, shared by the demo, the PrEditor plugin and the tests"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from Qt import QtGui
+from tree_sitter import Language
+
+from .behaviors.auto_bracket import AutoBracket
+from .behaviors.code_folding import CodeFolding
+from .behaviors.comment_toggle import CommentToggle
+from .behaviors.highlight_matching_brackets import HighlightMatchingBrackets
+from .behaviors.highlight_matching_selection import HighlightMatchingSelection
+from .behaviors.line_numbers import LineNumbers
+from .behaviors.multi_cursor_paint import MultiCursorPaint
+from .behaviors.overscroll import Overscroll
+from .behaviors.smart_indent import SmartIndent
+from .behaviors.syntax_highlighting import SyntaxHighlighting
+from .behaviors.tab_completion import TabCompletion
+from .behaviors.tab_completion.providers import IdentifierProvider
+from .editor_options import EditorOptions
+from .themes import DARK_THEME, Theme, read_theme
+
+if TYPE_CHECKING:
+    from .behaviors import Behavior
+    from .code_editor import CodeEditor
+
+# The built-in behaviors that install_default_behaviors adds, along with
+# TabCompletion, which needs its providers
+DEFAULT_BEHAVIORS: tuple[type[Behavior], ...] = (
+    SyntaxHighlighting,
+    SmartIndent,
+    HighlightMatchingBrackets,
+    HighlightMatchingSelection,
+    LineNumbers,
+    Overscroll,
+    MultiCursorPaint,
+    CodeFolding,
+    CommentToggle,
+)
+
+# The built-in behaviors that are off by default
+OPTIONAL_BEHAVIORS: tuple[type[Behavior], ...] = (AutoBracket,)
+
+
+def default_options(
+    theme: Theme = DARK_THEME,
+    language: Language | None = None,
+    font: QtGui.QFont | None = None,
+) -> EditorOptions:
+    """Make a new set of options for editing python, or another language
+
+    The other options take their values from OPTION_DEFAULTS
+
+    Args:
+        theme: The color theme
+        language: The tree-sitter language. Defaults to python, which needs
+            the tree-sitter-python package
+        font: Defaults to an 11pt system font
+    """
+    if language is None:
+        import tree_sitter_python
+
+        language = Language(tree_sitter_python.language())
+    if font is None:
+        font = QtGui.QFontDatabase.systemFont(
+            QtGui.QFontDatabase.SystemFont.GeneralFont
+        )
+        font.setPointSize(11)
+    colors, syntax = read_theme(theme)
+    return EditorOptions(
+        {"language": language, "syntax": syntax, "colors": colors, "font": font}
+    )
+
+
+def install_tab_completion(editor: CodeEditor) -> TabCompletion:
+    """Add tab completion, completing the names defined in the document"""
+    completion = editor.add_behavior(TabCompletion)
+    completion.add_provider(IdentifierProvider)
+    return completion
+
+
+def install_default_behaviors(editor: CodeEditor, optional: bool = False) -> None:
+    """Add tab completion and DEFAULT_BEHAVIORS to an editor
+
+    Args:
+        editor: The editor to add the behaviors to
+        optional: Also add the OPTIONAL_BEHAVIORS
+    """
+    install_tab_completion(editor)
+    for behavior_cls in DEFAULT_BEHAVIORS + (OPTIONAL_BEHAVIORS if optional else ()):
+        editor.add_behavior(behavior_cls)

QCodeSitter/editing_keys.py

@@ -0,0 +1,150 @@
+"""The editor's built-in keys: typing, deleting, moving, and the edit commands"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING
+
+from .utils import KEY, MO, MOD
+
+if TYPE_CHECKING:
+    from Qt import QtGui
+
+    from .code_editor import CodeEditor
+
+# Delete key -> (move operation, move operation with Ctrl held)
+_DELETE_OPS: dict[int, tuple[MO, MO]] = {
+    KEY.Key_Backspace: (MO.PreviousCharacter, MO.PreviousWord),
+    KEY.Key_Delete: (MO.NextCharacter, MO.NextWord),
+}
+
+# Movement key -> (move operation, move operation with Ctrl held)
+# None is smart home, which toggles between the indent and column 0
+_MOVE_OPS: dict[int, tuple[MO | None, MO]] = {
+    KEY.Key_Left: (MO.Left, MO.WordLeft),
+    KEY.Key_Right: (MO.Right, MO.WordRight),
+    KEY.Key_Up: (MO.Up, MO.Up),
+    KEY.Key_Down: (MO.Down, MO.Down),
+    KEY.Key_Home: (None, MO.Start),
+    KEY.Key_End: (MO.EndOfLine, MO.End),
+}
+
+# The modifiers that can be held while typing text, besides Shift: the
+# numpad, and AltGr, which is Ctrl+Alt on Windows and Group Switch elsewhere
+_TEXT_MODIFIERS = MOD.ShiftModifier | MOD.KeypadModifier | MOD.GroupSwitchModifier
+_ALTGR = MOD.ControlModifier | MOD.AltModifier
+
+
+class EditingKeys:
+    """Applies the built-in editing keys to every cursor of an editor
+
+    The editor gives a key to its behaviors first, and to this after them
+    """
+
+    def __init__(self, editor: CodeEditor) -> None:
+        self.editor = editor
+        # Whether the next word character joins the last one's undo step
+        self._can_join = False
+        # (modifier, action) pairs for the keys that run editor commands
+        self._command_keys: dict[int, tuple[tuple[MOD, Callable[[], None]], ...]] = {
+            KEY.Key_C: ((MOD.ControlModifier, editor.copy),),
+            KEY.Key_Insert: (
+                (MOD.ControlModifier, editor.copy),
+                (MOD.ShiftModifier, editor.paste),
+            ),
+            KEY.Key_V: ((MOD.ControlModifier, editor.paste),),
+            KEY.Key_X: ((MOD.ControlModifier, editor.cut),),
+            KEY.Key_Z: (
+                (MOD.ControlModifier, editor.undo),
+                (MOD.ControlModifier | MOD.ShiftModifier, editor.redo),
+            ),
+            KEY.Key_Y: ((MOD.ControlModifier, editor.redo),),
+        }
+
+    def end_undo_step(self) -> None:
+        """Make the next typing start a new undo step"""
+        self._can_join = False
+
+    def handle_key_press(self, event: QtGui.QKeyEvent) -> bool:
+        """Apply an editing key to all the cursors
+
+        Returns whether the key was handled
+        """
+        key = event.key()
+        modifiers = event.modifiers()
+        cursors = self.editor.cursors
+
+        # Escape leaves multi-cursor mode, or else goes on to the parent widget
+        if key == KEY.Key_Escape:
+            had_secondary = bool(cursors.secondary)
+            cursors.clear_secondary()
+            return had_secondary
+
+        if self._type_text(event):
+            return True
+
+        if modifiers == MOD.ControlModifier and key == KEY.Key_A:
+            cursors.clear_secondary()
+            return False
+
+        delete_ops = _DELETE_OPS.get(key)
+        if delete_ops is not None:
+            self.editor.delete(delete_ops[bool(modifiers & MOD.ControlModifier)])
+            return True
+
+        # Alt+arrow combinations are hotkeys, like Ctrl+Alt+Up to add a cursor
+        if modifiers & MOD.AltModifier:
+            return False
+
+        move_ops = _MOVE_OPS.get(key)
+        if move_ops is None:
+            return self._run_command_key(event)
+        select = bool(modifiers & MOD.ShiftModifier)
+        move_op = move_ops[bool(modifiers & MOD.ControlModifier)]
+        if move_op is None:
+            cursors.smart_home(select)
+        else:
+            cursors.move(move_op, select)
+        return True
+
+    def _type_text(self, event: QtGui.QKeyEvent) -> bool:
+        """Insert the text of a typing key at every cursor
+
+        Returns whether the key typed text
+        """
+        text = event.text()
+        typing = (
+            text
+            and text.isprintable()
+            and event.modifiers() & ~_TEXT_MODIFIERS in (MOD.NoModifier, _ALTGR)
+        )
+        if not typing:
+            self._can_join = False
+            return False
+        # Typing a word is a single undo step, so each character joins the last
+        is_word = text.isalnum() or text == "_"
+        self.editor.insert_text(text, join_edit=self._can_join and is_word)
+        self._can_join = is_word
+        return True
+
+    def _run_command_key(self, event: QtGui.QKeyEvent) -> bool:
+        """Run the editor command for Tab, Enter, or a clipboard/undo shortcut"""
+        key = event.key()
+        options = self.editor.options
+        if key == KEY.Key_Tab:
+            if options["indent_using_tabs"]:
+                self.editor.insert_text("\t")
+            else:
+                self.editor.insert_text(" " * options["space_indent_width"])
+            return True
+        # Key_Enter is the numpad
+        if key in (KEY.Key_Return, KEY.Key_Enter):
+            self.editor.insert_text("\n")
+            return True
+        # The modifiers must match exactly, so Ctrl+Shift+Z doesn't also undo
+        modifiers = event.modifiers() & ~MOD.KeypadModifier
+        for modifier, command in self._command_keys.get(key, ()):
+            if modifiers == modifier:
+                command()
+                return True
+        return False

QCodeSitter/editor_options.py

@@ -0,0 +1,246 @@
+from __future__ import annotations
+
+import copy
+from collections.abc import Callable, Iterable, Mapping
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Literal,
+    TypedDict,
+    get_origin,
+    get_type_hints,
+    overload,
+)
+
+from Qt import QtCore, QtGui
+from tree_sitter import Language
+
+from .gui_colors import GuiColors
+from .syntax_specs import SyntaxSpecs
+
+
+class OptionsDict(TypedDict, total=False):
+    """Every option the editor and the built-in behaviors understand
+
+    Behaviors from outside the package add their options with `register_option`
+    """
+
+    # Indentation
+    space_indent_width: int
+    tab_indent_width: int
+    indent_using_tabs: bool
+    copy_indents_as_spaces: bool
+    # Opening and closing characters, like ["()", "[]"]
+    indent_bracket_pairs: list[str]
+    # Language and appearance. The highlight query comes from the language
+    language: Language
+    syntax: SyntaxSpecs
+    colors: GuiColors
+    font: QtGui.QFont
+    # Tab completion
+    vim_completion_keys: bool  # Ctrl+N/Ctrl+P for next/prev and Ctrl+Y to accept
+    debounce_delay: int  # milliseconds
+    # Brackets, as pairs of opening and closing characters
+    auto_bracket_pairs: list[str]
+    highlight_bracket_pairs: list[str]
+    # The characters that open and close strings, like "'\""
+    highlight_quote_chars: str
+
+
+# The value of every option that isn't given. The language and font have none
+OPTION_DEFAULTS: OptionsDict = {
+    "space_indent_width": 4,
+    "tab_indent_width": 8,
+    "indent_using_tabs": False,
+    "copy_indents_as_spaces": True,
+    "indent_bracket_pairs": ["()", "[]", "{}"],
+    "syntax": {},
+    "colors": {},
+    "vim_completion_keys": True,
+    "debounce_delay": 150,
+    "auto_bracket_pairs": ["()", "[]", "{}", '""', "''", "``"],
+    "highlight_bracket_pairs": ["()", "[]", "{}"],
+    "highlight_quote_chars": "\"'`",
+}
+
+# The keys of the built-in options
+OPTION_KEYS = frozenset(get_type_hints(OptionsDict))
+
+# What EditorOptions._lookup returns for an option without a value
+_MISSING = object()
+
+# Option key -> the function that applies its value
+OptionHandlers = Mapping[str, Callable[[Any], object]]
+
+
+def _copy_mutable(value: Any) -> Any:
+    """A deep copy of a list or dict value, so the store's own can't be edited in place
+
+    Other values are returned as they are, since languages and fonts can't be deep-copied
+    """
+    return copy.deepcopy(value) if isinstance(value, (list, dict)) else value
+
+
+class OptionSchema:
+    """The type every option's values must have, and the registered options' defaults
+
+    The built-in options come from OptionsDict, and behaviors from outside the
+    package add theirs with `register`
+    """
+
+    def __init__(self) -> None:
+        self._types: dict[str, type] = {
+            key: get_origin(hint) or hint
+            for key, hint in get_type_hints(OptionsDict).items()
+        }
+        self._defaults: dict[str, Any] = {}
+
+    def register(self, key: str, value_type: type, default: object = None) -> None:
+        """Add an option, for a behavior from outside the package
+
+        Args:
+            key: The option's name, which mustn't be a built-in option
+            value_type: The type its values must have
+            default: Its value when it isn't set. None means it has no default,
+                and handlers for it wait until it is set
+        """
+        if key in OPTION_KEYS:
+            raise ValueError(f"{key!r} is a built-in editor option")
+        # Check the default first, so a bad one leaves the schema as it was
+        if default is not None and not isinstance(default, value_type):
+            raise TypeError(
+                f"Editor option {key!r} must be a {value_type.__name__}, "
+                f"not {type(default).__name__}"
+            )
+        self._types[key] = value_type
+        self._defaults.pop(key, None)
+        if default is not None:
+            self._defaults[key] = _copy_mutable(default)
+
+    def unregister(self, key: str) -> None:
+        """Remove an option added with `register`"""
+        if key in OPTION_KEYS:
+            raise ValueError(f"{key!r} is a built-in editor option")
+        self._types.pop(key, None)
+        self._defaults.pop(key, None)
+
+    def registered_default(self, key: str) -> Any:
+        """A registered option's stored default, not a copy. Raises a KeyError if it
+        has none
+        """
+        return self._defaults[key]
+
+    def check_keys(self, keys: Iterable[str]) -> None:
+        """Raise a KeyError for any key that isn't a known option"""
+        unknown = set(keys) - set(self._types)
+        if unknown:
+            raise KeyError(f"Unknown editor options: {sorted(unknown)}")
+
+    def check(self, opts: Mapping[str, object]) -> None:
+        """Raise a KeyError for unknown keys, or a TypeError for wrong value types"""
+        self.check_keys(opts)
+        for key, value in opts.items():
+            expected = self._types[key]
+            if not isinstance(value, expected):
+                raise TypeError(
+                    f"Editor option {key!r} must be a {expected.__name__}, "
+                    f"not {type(value).__name__}"
+                )
+
+
+# There is one schema for the process, so a registered option works in every editor
+OPTION_SCHEMA = OptionSchema()
+register_option = OPTION_SCHEMA.register
+unregister_option = OPTION_SCHEMA.unregister
+check_option_keys = OPTION_SCHEMA.check_keys
+check_options = OPTION_SCHEMA.check
+
+
+class EditorOptions(QtCore.QObject):
+    """The options shared by an editor and its behaviors
+
+    Options that aren't given take their value from OPTION_DEFAULTS, or from
+    the default they were registered with. Setting options emits
+    `optionsUpdated` with the keys whose value changed
+    """
+
+    optionsUpdated = QtCore.Signal(list)  # list of str
+
+    def __init__(self, opts: OptionsDict | None = None) -> None:
+        super().__init__()
+        opts = {} if opts is None else opts
+        check_options(opts)
+        self._options: dict[str, Any] = {
+            **copy.deepcopy(OPTION_DEFAULTS),
+            **{key: _copy_mutable(value) for key, value in opts.items()},
+        }
+
+    def _lookup(self, key: str) -> Any:
+        """The option's value, or its registered default, or _MISSING
+
+        A registered default is looked up every time, so registering the
+        option again later changes it for editors that already read it. This is
+        the stored value, not a copy, so callers must not change it
+        """
+        if key in self._options:
+            return self._options[key]
+        try:
+            return OPTION_SCHEMA.registered_default(key)
+        except KeyError:
+            return _MISSING
+
+    if TYPE_CHECKING:
+        # Reading a built-in option gives the type OptionsDict declares for it
+        # fmt: off
+        @overload
+        def __getitem__(self, key: Literal["space_indent_width", "tab_indent_width", "debounce_delay"]) -> int: ...
+        @overload
+        def __getitem__(self, key: Literal["indent_using_tabs", "copy_indents_as_spaces", "vim_completion_keys"]) -> bool: ...
+        @overload
+        def __getitem__(self, key: Literal["indent_bracket_pairs", "auto_bracket_pairs", "highlight_bracket_pairs"]) -> list[str]: ...
+        @overload
+        def __getitem__(self, key: Literal["highlight_quote_chars"]) -> str: ...
+        @overload
+        def __getitem__(self, key: Literal["language"]) -> Language: ...
+        @overload
+        def __getitem__(self, key: Literal["syntax"]) -> SyntaxSpecs: ...
+        @overload
+        def __getitem__(self, key: Literal["colors"]) -> GuiColors: ...
+        @overload
+        def __getitem__(self, key: Literal["font"]) -> QtGui.QFont: ...
+        @overload
+        def __getitem__(self, key: str) -> Any: ...
+        # fmt: on
+
+    def __getitem__(self, key: str) -> Any:
+        value = self._lookup(key)
+        if value is _MISSING:
+            raise KeyError(key)
+        # A list or dict is a copy, so changing it means setting it again
+        return _copy_mutable(value)
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.update({key: value})
+
+    def __contains__(self, key: str) -> bool:
+        return self._lookup(key) is not _MISSING
+
+    def update(self, opts: Mapping[str, Any]) -> None:
+        """Set several options, emitting `optionsUpdated` once for the changed ones"""
+        check_options(opts)
+        changed = [key for key, value in opts.items() if self._lookup(key) != value]
+        self._options.update({key: _copy_mutable(value) for key, value in opts.items()})
+        if changed:
+            self.optionsUpdated.emit(changed)
+
+    def get(self, key: str, default: Any = None) -> Any:
+        value = self._lookup(key)
+        return default if value is _MISSING else _copy_mutable(value)
+
+    def apply(self, handlers: OptionHandlers, keys: Iterable[str]) -> None:
+        """Call the handler of each key that is set, with its value"""
+        for key in keys:
+            handler = handlers.get(key)
+            value = self._lookup(key)
+            if handler is not None and value is not _MISSING:
+                handler(_copy_mutable(value))

QCodeSitter/gui_colors.py

@@ -0,0 +1,51 @@
+"""The "colors" option: named colors for the editor chrome and the behaviors
+
+Every color the editor and the built-in behaviors use has a default in
+GUI_COLOR_DEFAULTS, or in DERIVED_GUI_COLORS when it depends on another color.
+`gui_color` falls back to them for any color a theme doesn't set.
+
+Hex colors with alpha should be given in ARGB order, which is how QColor reads them.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from Qt import QtGui
+
+# Gui color name -> hex color
+GuiColors = dict[str, str]
+
+GUI_COLOR_DEFAULTS: GuiColors = {
+    "bg": "#282828",
+    "fg": "#DCDCDC",
+    "gutter": "#282828",
+    "gutter_fg": "#969696",
+    "bg_dim": "#503C3C3C",
+    "fg_dim": "#C8787878",
+    "hl_dim": "#96464646",
+    "manual_fold": "#D7BA7D",
+    "match_hl": "#50FFFF00",
+    "menu": "#2B2B2B",
+    "pair_hl": "#C8C8C8",
+    "primary_cursor": "#FFFFFFFF",
+    "secondary_cursor": "#B4B4B4",
+    "selection": "#094771",
+    "secondary_selection": "#B4B4B4",
+}
+
+# Gui color name -> its default, made from the other colors
+DERIVED_GUI_COLORS: dict[str, Callable[[GuiColors], QtGui.QColor]] = {
+    # The space below the document is a shade darker than the background
+    "outside_bg": lambda colors: gui_color(colors, "bg").darker(120),
+}
+
+
+def gui_color(colors: GuiColors, name: str) -> QtGui.QColor:
+    """Get a gui color, falling back to its default if the theme doesn't set it"""
+    if name in colors:
+        return QtGui.QColor(colors[name])
+    derive = DERIVED_GUI_COLORS.get(name)
+    if derive is not None:
+        return derive(colors)
+    return QtGui.QColor(GUI_COLOR_DEFAULTS[name])

QCodeSitter/gutters.py

@@ -0,0 +1,141 @@
+"""The columns beside the editor viewport, like line numbers and fold markers"""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from typing import TYPE_CHECKING
+
+from Qt import QtCore, QtGui, QtWidgets
+
+from .gui_colors import GuiColors, gui_color
+
+if TYPE_CHECKING:
+    from .code_editor import CodeEditor
+
+
+class GutterLayout:
+    """Lays out an editor's gutters left of its viewport, in the order they were added
+
+    The editor owns one as `editor.gutters`, and iterating it gives the gutters
+    """
+
+    def __init__(self, editor: CodeEditor) -> None:
+        self.editor = editor
+        self._gutters: list[GutterWidget] = []
+
+    def __iter__(self) -> Iterator[GutterWidget]:
+        return iter(list(self._gutters))
+
+    def add(self, gutter: GutterWidget) -> None:
+        """Add a gutter to the right of the others. GutterWidget calls this"""
+        gutter.reserved_width = gutter.width_hint()
+        self._gutters.append(gutter)
+        self.layout()
+
+    def remove(self, gutter: GutterWidget) -> None:
+        """Remove a gutter and close the gap. GutterWidget.remove calls this"""
+        self._gutters.remove(gutter)
+        self.layout()
+
+    def layout(self) -> None:
+        """Make room for the gutters left of the viewport, and put them there"""
+        margins = self.editor.viewportMargins()
+        margins.setLeft(sum(g.reserved_width for g in self._gutters))
+        self.editor.setViewportMargins(margins)
+        self.place()
+
+    def place(self) -> None:
+        """Fit the gutters to the editor's height, side by side"""
+        rect = self.editor.contentsRect()
+        left = rect.left()
+        for gutter in self._gutters:
+            gutter.setGeometry(left, rect.top(), gutter.reserved_width, rect.height())
+            left += gutter.reserved_width
+
+    def update(self) -> None:
+        """Repaint every gutter, like after lines are hidden or shown"""
+        for gutter in self._gutters:
+            gutter.update()
+
+
+class GutterWidget(QtWidgets.QWidget):
+    """Base class for a column beside the editor viewport, like line numbers
+
+    A gutter adds itself to the editor's GutterLayout when it is made.
+    Subclasses define `width_hint` and `paintEvent`, and call `remove` to take
+    the gutter away.
+    """
+
+    def __init__(self, editor: CodeEditor) -> None:
+        super().__init__(editor)
+        self.editor: CodeEditor = editor
+        self.fg_color = QtGui.QColor()
+        self.bg_color = QtGui.QColor()
+        # The width the editor has made room for
+        self.reserved_width = 0
+        self.editor.blockCountChanged.connect(self.update_width)
+        self.editor.updateRequest.connect(self.update_gutter)
+        self.editor.gutters.add(self)
+        if self.editor.isVisible():
+            self.show()
+
+    def set_gutter_colors(self, colors: GuiColors) -> None:
+        """Paint with the "gutter_fg" and "gutter" gui colors"""
+        self.fg_color = gui_color(colors, "gutter_fg")
+        self.bg_color = gui_color(colors, "gutter")
+        self.update()
+
+    def sizeHint(self) -> QtCore.QSize:
+        return QtCore.QSize(self.width_hint(), 0)
+
+    def width_hint(self) -> int:
+        raise NotImplementedError("width_hint must be defined")
+
+    def update_width(self) -> None:
+        # This gets called on every full-viewport update, so skip it if nothing changed
+        width = self.width_hint()
+        if self.reserved_width != width:
+            self.reserved_width = width
+            self.editor.gutters.layout()
+
+    def remove(self) -> None:
+        """Take the gutter out of the editor, and give its space back"""
+        self.editor.blockCountChanged.disconnect(self.update_width)
+        self.editor.updateRequest.disconnect(self.update_gutter)
+        self.editor.gutters.remove(self)
+        self.deleteLater()
+
+    @QtCore.Slot(QtCore.QRect, int)
+    def update_gutter(self, rect: QtCore.QRect, dy: int) -> None:
+        if dy:
+            self.scroll(0, dy)
+        else:
+            # Repaint the rows of the gutter that changed in the viewport
+            self.update(0, rect.y(), self.width(), rect.height())
+
+        if rect.contains(self.editor.viewport().rect()):
+            self.update_width()
+
+    def visible_blocks(
+        self, bottom_limit: float | None = None
+    ) -> Iterator[tuple[QtGui.QTextBlock, float, float]]:
+        """Yield each visible block with its top and bottom in gutter coordinates
+
+        Args:
+            bottom_limit: Stop after the block that reaches past this y position
+        """
+        block = self.editor.firstVisibleBlock()
+        top = (
+            self.editor.blockBoundingGeometry(block)
+            .translated(self.editor.contentOffset())
+            .top()
+        )
+        while block.isValid() and (bottom_limit is None or top <= bottom_limit):
+            bottom = top + self.editor.blockBoundingRect(block).height()
+            if block.isVisible():
+                yield block, top, bottom
+            block = block.next()
+            top = bottom
+
+    def paintEvent(self, event: QtGui.QPaintEvent) -> None:
+        raise NotImplementedError("paintEvent must be defined")

QCodeSitter/integrations/__init__.py

@@ -0,0 +1 @@
+"""Plugins that put the editor into other applications"""