QCodeSitter 0.1.0__py3-none-any.whl

QCodeSitter/behaviors/highlight_matching_brackets.py

@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+from collections.abc import Collection
+from typing import TYPE_CHECKING
+
+from Qt import QtGui, QtWidgets
+
+from ..gui_colors import GuiColors, gui_color
+from ..languages import language_spec
+from ..tracked_document import len16, utf16_to_index
+from ..utils import MM
+from . import Behavior
+
+if TYPE_CHECKING:
+    from tree_sitter import Node
+
+    from ..code_editor import CodeEditor
+
+
+class HighlightMatchingBrackets(Behavior):
+    """Highlight a bracket or quote next to the cursor, and the one it pairs with
+
+    The pairs come from the tree-sitter tree, so brackets in strings and
+    comments don't match the code around them. The brackets and quotes come
+    from the "highlight_bracket_pairs" and "highlight_quote_chars" options
+    """
+
+    SOURCE = "bracket_matching"
+
+    def __init__(self, editor: CodeEditor) -> None:
+        super().__init__(editor)
+        self.watch_options(
+            {
+                "colors": self._set_colors,
+                "highlight_bracket_pairs": self._set_bracket_pairs,
+            }
+        )
+        self.connect(
+            self.editor.cursorPositionChanged, self.highlight_matching_brackets
+        )
+
+    def _set_colors(self, colors: GuiColors) -> None:
+        self._format = QtGui.QTextCharFormat()
+        self._format.setBackground(gui_color(colors, "pair_hl"))
+
+    def _set_bracket_pairs(self, ordered_pairs: Collection[str]) -> None:
+        """Set the brackets from strings of an opening and closing character, ie "()" """
+        self.opening_brackets = "".join(p[0] for p in ordered_pairs)
+        self.bracket_chars = "".join(ordered_pairs)
+        self.bracket_pairs = {p[0]: p[1] for p in ordered_pairs}
+        self.bracket_pairs.update({p[1]: p[0] for p in ordered_pairs})
+
+    @property
+    def _quote_chars(self) -> str:
+        return self.options["highlight_quote_chars"]
+
+    def on_remove(self) -> None:
+        self.editor.clear_selections(self.SOURCE)
+
+    def highlight_matching_brackets(self) -> None:
+        self.editor.set_selections(self.SOURCE, self._matching_selections())
+
+    def _matching_selections(self) -> list[QtWidgets.QTextEdit.ExtraSelection]:
+        match_info = self._find_character_to_match()
+        if match_info is None:
+            return []
+        match_char, match_pos = match_info
+        node = self.editor.tree_manager.node_at_char(match_pos)
+        if node is None:
+            return []
+
+        if match_char in self._quote_chars:
+            ranges = self._matching_quote_ranges(node, match_pos)
+        else:
+            ranges = self._matching_bracket_ranges(node, match_char)
+        return [self._create_selection(start, end) for start, end in ranges]
+
+    def _find_character_to_match(self) -> tuple[str, int] | None:
+        """Find the bracket or quote next to the cursor, preferring the one before it
+
+        Returns:
+            The character and its position, or None if neither side matches
+        """
+        cursor = self.editor.textCursor()
+        pos = cursor.position()
+        text = cursor.block().text()
+        index = utf16_to_index(text, cursor.positionInBlock())
+        matchable = self._quote_chars + self.bracket_chars
+        if index > 0 and text[index - 1] in matchable:
+            char = text[index - 1]
+            return char, pos - len16(char)
+        if index < len(text) and text[index] in matchable:
+            return text[index], pos
+        return None
+
+    def _matching_quote_ranges(
+        self, node: Node, match_pos: int
+    ) -> list[tuple[int, int]]:
+        """Get the ranges of the quote at match_pos, and the other end of its string"""
+        spec = language_spec(self.editor.tree_manager.language)
+        string_node: Node | None = node
+        while string_node is not None and string_node.type != spec.string_type:
+            string_node = string_node.parent
+        if string_node is None:
+            return []
+
+        # The delimiter nodes include triple quotes and prefixes like f"
+        delimiters = {child.type: child for child in string_node.children}
+        start_type, end_type = spec.string_delimiter_types
+        start_node = delimiters.get(start_type)
+        end_node = delimiters.get(end_type)
+        if start_node is None or end_node is None:
+            return []
+
+        doc = self.editor.document()
+        opening, closing = (
+            (doc.byte_to_char(n.start_byte), doc.byte_to_char(n.end_byte))
+            for n in (start_node, end_node)
+        )
+        if opening[0] <= match_pos < opening[1]:
+            return [opening, closing]
+        if closing[0] <= match_pos < closing[1]:
+            return [closing, opening]
+        # A quote inside the string, like the apostrophe in "don't"
+        return []
+
+    def _matching_bracket_ranges(
+        self, node: Node, match_char: str
+    ) -> list[tuple[int, int]]:
+        """Get the ranges of a bracket node, and its sibling it pairs with
+
+        The partner is the nearest balanced one, which matters in error nodes
+        that hold several unmatched brackets
+        """
+        if node.type not in self.bracket_pairs or node.parent is None:
+            return []
+
+        partner_type = self.bracket_pairs[match_char]
+        siblings = node.parent.children
+        index = siblings.index(node)
+        # Opening brackets match forwards, and closing brackets match backwards
+        if match_char in self.opening_brackets:
+            candidates = siblings[index + 1 :]
+        else:
+            candidates = siblings[index - 1 :: -1] if index else []
+        partner = None
+        depth = 0
+        for sibling in candidates:
+            if sibling.type == node.type:
+                depth += 1
+            elif sibling.type == partner_type:
+                if depth == 0:
+                    partner = sibling
+                    break
+                depth -= 1
+        if partner is None:
+            return []
+
+        doc = self.editor.document()
+        return [
+            (doc.byte_to_char(n.start_byte), doc.byte_to_char(n.end_byte))
+            for n in (node, partner)
+        ]
+
+    def _create_selection(
+        self, start: int, end: int
+    ) -> QtWidgets.QTextEdit.ExtraSelection:
+        """Create an ExtraSelection for a range of the document
+
+        The range is clamped to the document, which it can pass
+        if the tree hasn't caught up with an edit yet
+        """
+        # -1 for the paragraph separator at the end of the document
+        doc_length = self.editor.document().characterCount() - 1
+        cursor = self.editor.textCursor()
+        cursor.setPosition(min(start, doc_length))
+        cursor.setPosition(min(end, doc_length), MM.KeepAnchor)
+        selection = QtWidgets.QTextEdit.ExtraSelection()
+        selection.cursor = cursor
+        selection.format = self._format
+        return selection

QCodeSitter/behaviors/highlight_matching_selection.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from Qt import QtGui, QtWidgets
+
+from ..gui_colors import GuiColors, gui_color
+from . import Behavior
+
+if TYPE_CHECKING:
+    from ..code_editor import CodeEditor
+
+
+class HighlightMatchingSelection(Behavior):
+    """Highlight the other occurrences of the selected text"""
+
+    SOURCE = "selection_highlight"
+    MIN_LENGTH = 2
+    MAX_LENGTH = 100
+
+    def __init__(self, editor: CodeEditor) -> None:
+        super().__init__(editor)
+        self.watch_options({"colors": self._set_colors})
+        self.connect(self.editor.selectionChanged, self.highlight_occurrences)
+
+    def _set_colors(self, colors: GuiColors) -> None:
+        self._match_hl = gui_color(colors, "match_hl")
+
+    def on_remove(self) -> None:
+        self.editor.clear_selections(self.SOURCE)
+
+    def highlight_occurrences(self) -> None:
+        """Highlight all occurrences of the selected text"""
+        extra_selections = []
+        cursor = self.editor.textCursor()
+        selected_text = cursor.selectedText()
+
+        # Single characters would match everywhere
+        if self.MIN_LENGTH <= len(selected_text) <= self.MAX_LENGTH:
+            fmt = QtGui.QTextCharFormat()
+            fmt.setBackground(self._match_hl)
+            doc = self.editor.document()
+            search_cursor = QtGui.QTextCursor(doc)
+            case_sensitive = QtGui.QTextDocument.FindFlag.FindCaseSensitively
+
+            while True:
+                search_cursor = doc.find(selected_text, search_cursor, case_sensitive)
+                if search_cursor.isNull():
+                    break
+
+                # Qt already highlights the selection itself
+                found = (search_cursor.selectionStart(), search_cursor.selectionEnd())
+                if found != (cursor.selectionStart(), cursor.selectionEnd()):
+                    selection = QtWidgets.QTextEdit.ExtraSelection()
+                    selection.cursor = search_cursor
+                    selection.format = fmt
+                    extra_selections.append(selection)
+
+        self.editor.set_selections(self.SOURCE, extra_selections)

QCodeSitter/behaviors/line_numbers.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from Qt import QtCore, QtGui
+
+from ..gutters import GutterWidget
+from . import Behavior
+
+if TYPE_CHECKING:
+    from ..code_editor import CodeEditor
+
+
+class LineNumberArea(GutterWidget):
+    def width_hint(self) -> int:
+        digits = len(str(max(1, self.editor.blockCount())))
+        return 10 + self.fontMetrics().horizontalAdvance("9") * digits
+
+    def paintEvent(self, event: QtGui.QPaintEvent) -> None:
+        painter = QtGui.QPainter(self)
+        painter.fillRect(event.rect(), self.bg_color)
+        painter.setPen(self.fg_color)
+        for block, top, bottom in self.visible_blocks(event.rect().bottom()):
+            if bottom >= event.rect().top():
+                painter.drawText(
+                    0,
+                    int(top),
+                    self.width() - 5,
+                    self.fontMetrics().height(),
+                    QtCore.Qt.AlignmentFlag.AlignRight,
+                    str(block.blockNumber() + 1),
+                )
+
+
+class LineNumbers(Behavior):
+    """A gutter showing the line numbers"""
+
+    def __init__(self, editor: CodeEditor) -> None:
+        super().__init__(editor)
+        self.line_number_area = LineNumberArea(self.editor)
+        self.watch_options(
+            {
+                "font": self.line_number_area.setFont,
+                "colors": self.line_number_area.set_gutter_colors,
+            }
+        )
+
+    def on_remove(self) -> None:
+        self.line_number_area.remove()

QCodeSitter/behaviors/multi_cursor_paint.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from Qt import QtCore, QtGui, QtWidgets
+
+from ..gui_colors import GuiColors, gui_color
+from . import Behavior
+
+if TYPE_CHECKING:
+    from ..code_editor import CodeEditor
+
+
+class MultiCursorPaint(Behavior):
+    """Draws every cursor, including the secondary cursors of multi-cursor mode
+
+    Qt's own cursor is hidden while this behavior is installed, and the primary
+    cursor is drawn the same way as the others. The selections of the secondary
+    cursors are shown as extra selections.
+    """
+
+    SOURCE = "multi_cursor"
+
+    def __init__(self, editor: CodeEditor) -> None:
+        super().__init__(editor)
+        self.cursor_width = 2
+        self.watch_options({"colors": self._set_colors})
+        self._qt_cursor_width = self.editor.cursorWidth()
+        self.editor.setCursorWidth(0)
+
+        self._blink_state = True
+        self.blink_timer = QtCore.QTimer(self.editor)
+        self.blink_timer.timeout.connect(self._update_blink)
+        self.blink_timer.start(QtWidgets.QApplication.instance().cursorFlashTime() // 2)
+        self.connect(
+            self.editor.behaviorPaint,
+            self.paint_cursors,
+            QtCore.Qt.ConnectionType.DirectConnection,
+        )
+        self.connect(self.editor.cursors.changed, self.on_cursors_changed)
+
+    def _set_colors(self, colors: GuiColors) -> None:
+        self.primary_cursor_color = gui_color(colors, "primary_cursor")
+        self.secondary_cursor_color = gui_color(colors, "secondary_cursor")
+        self.secondary_selection_color = gui_color(colors, "secondary_selection")
+
+    @property
+    def cursors_visible(self) -> bool:
+        """Whether the cursors are drawn right now, which toggles as they blink"""
+        return self._blink_state
+
+    @cursors_visible.setter
+    def cursors_visible(self, visible: bool) -> None:
+        self._blink_state = visible
+        self.editor.viewport().update()
+
+    def on_cursors_changed(self) -> None:
+        if self.editor.cursors.secondary:
+            self._update_selections()
+        else:
+            self.editor.clear_selections(self.SOURCE)
+        self.editor.viewport().update()
+
+    def _update_selections(self) -> None:
+        """Show the selections of every cursor as extra selections"""
+        # In multi-cursor mode the primary selection is drawn like the others
+        states = [*self.editor.cursors.secondary, self.editor.cursors.primary()]
+
+        fmt = QtGui.QTextCharFormat()
+        fmt.setBackground(self.secondary_selection_color.lighter(150))
+        doc = self.editor.document()
+        selections = []
+        for state in states:
+            if state.hasSelection():
+                selection = QtWidgets.QTextEdit.ExtraSelection()
+                selection.format = fmt
+                selection.cursor = state.build_cursor(doc)
+                selections.append(selection)
+
+        self.editor.set_selections(self.SOURCE, selections)
+
+    def paint_cursors(self, _event: QtGui.QPaintEvent, painter: QtGui.QPainter) -> None:
+        """Paint thin cursor lines for all cursors without selections"""
+        if not self._blink_state:
+            return
+        painter.save()
+        try:
+            cursor = QtGui.QTextCursor(self.editor.document())
+            for state in self.editor.cursors.secondary:
+                if not state.hasSelection():
+                    self._draw_cursor_at_position(
+                        painter, cursor, state.position, self.secondary_cursor_color
+                    )
+            primary = self.editor.cursors.primary()
+            if not primary.hasSelection():
+                self._draw_cursor_at_position(
+                    painter, cursor, primary.position, self.primary_cursor_color
+                )
+        finally:
+            painter.restore()
+
+    def _update_blink(self) -> None:
+        if not self.editor.hasFocus():
+            if self._blink_state:
+                self.cursors_visible = False
+            return
+        self.cursors_visible = not self._blink_state
+
+    def _draw_cursor_at_position(
+        self,
+        painter: QtGui.QPainter,
+        cursor: QtGui.QTextCursor,
+        position: int,
+        color: QtGui.QColor,
+    ) -> None:
+        """Draw a cursor line at a document position, if it's in the viewport"""
+        cursor.setPosition(position)
+        cursor_rect = self.editor.cursorRect(cursor)
+        if not self.editor.viewport().rect().intersects(cursor_rect):
+            return
+
+        pen = QtGui.QPen(color)
+        pen.setWidth(self.cursor_width)
+        painter.setPen(pen)
+        painter.drawLine(cursor_rect.topLeft(), cursor_rect.bottomLeft())
+
+    def on_remove(self) -> None:
+        self.blink_timer.stop()
+        self.blink_timer.deleteLater()
+        self.editor.clear_selections(self.SOURCE)
+        self.editor.setCursorWidth(self._qt_cursor_width)

QCodeSitter/behaviors/overscroll.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from Qt import QtCore, QtGui
+
+from ..gui_colors import GuiColors, gui_color
+from . import Behavior
+
+if TYPE_CHECKING:
+    from ..code_editor import CodeEditor
+
+
+class Overscroll(Behavior):
+    """Behavior that allows scrolling past the end of the document"""
+
+    def __init__(self, editor: CodeEditor) -> None:
+        super().__init__(editor)
+        self._brush = QtGui.QBrush(QtCore.Qt.BrushStyle.SolidPattern)
+        self._pen = QtGui.QPen(QtCore.Qt.PenStyle.NoPen)
+
+        # Track the scroll position if the scroll position gets clamped
+        # to the "normal" scroll range, so we can restore it afterwards
+        self._cur_scroll = 0
+        self._was_clamped = False
+
+        sb = self.editor.verticalScrollBar()
+        self.connect(sb.valueChanged, self.track_scroll)
+        self.connect(sb.rangeChanged, self.on_range_changed)
+        self.connect(self.editor.document().contentsChanged, self.update_extra_scroll)
+
+        self.update_extra_scroll()
+        self.connect(
+            self.editor.behaviorPaint,
+            self.paint_outside_document,
+            QtCore.Qt.ConnectionType.DirectConnection,
+        )
+        self.watch_options({"colors": self._set_colors})
+
+    def track_scroll(self, value: int) -> None:
+        sb = self.editor.verticalScrollBar()
+        self._was_clamped = value == sb.maximum() and self._cur_scroll > sb.maximum()
+        self._cur_scroll = value
+
+    def update_extra_scroll(self) -> None:
+        """Let the last line scroll up to the top of the viewport"""
+        sb = self.editor.verticalScrollBar()
+        newmax = self.editor.document().blockCount() - 1
+        if sb.maximum() != newmax:
+            sb.setMaximum(newmax)
+
+    def on_range_changed(self) -> None:
+        """Put back the extra scroll range, and a scroll position Qt clamped"""
+        saved_value = self._cur_scroll
+        update = self._was_clamped
+        self.update_extra_scroll()
+        if update:
+            sb = self.editor.verticalScrollBar()
+            sb.setValue(saved_value)
+
+    def _set_colors(self, colors: GuiColors) -> None:
+        self._brush.setColor(gui_color(colors, "outside_bg"))
+        self.editor.viewport().update()
+
+    def paint_outside_document(
+        self, _event: QtGui.QPaintEvent, painter: QtGui.QPainter
+    ) -> None:
+        """Shade the space below the last line"""
+        doc = self.editor.document()
+        block = doc.lastBlock()
+
+        if not block.isValid():
+            return
+
+        last_rect = self.editor.blockBoundingGeometry(block)
+        last_rect.translate(self.editor.contentOffset())
+
+        viewport_rect = QtCore.QRectF(self.editor.viewport().rect())
+        if not viewport_rect.intersects(last_rect):
+            return
+
+        painter.save()
+        try:
+            painter.setBrush(self._brush)
+            painter.setPen(self._pen)
+
+            oob_rect = QtCore.QRect(
+                0,
+                int(last_rect.bottom()),
+                int(viewport_rect.width()),
+                int(viewport_rect.height() - last_rect.bottom()),
+            )
+            painter.drawRect(oob_rect)
+        finally:
+            painter.restore()
+
+    def on_remove(self) -> None:
+        """Set the scroll range back to the line count"""
+        sb = self.editor.verticalScrollBar()
+        viewport_height = self.editor.viewport().height()
+        line_height = self.editor.fontMetrics().lineSpacing()
+        visible_line_count = viewport_height // line_height
+        total_line_count = self.editor.document().blockCount()
+        sb.setMaximum(max(0, total_line_count - visible_line_count))