pyqt-code-editor 0.0.1__py3-none-any.whl

pyqt_code_editor/mixins/shortcuts.py

@@ -0,0 +1,228 @@
+import logging
+from qtpy.QtWidgets import QShortcut
+from qtpy.QtGui import QTextCursor, QKeySequence
+from qtpy.QtCore import Qt, QEvent
+from .. import settings
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO, force=True)
+
+
+class Shortcuts:
+    """
+    Mixin that adds common editor shortcuts to a QPlainTextEdit.
+    """
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # Move line up
+        self._shortcut_move_line_up = QShortcut(
+            QKeySequence(settings.shortcut_move_line_up), self)
+        self._shortcut_move_line_up.setContext(Qt.WidgetShortcut)
+        self._shortcut_move_line_up.activated.connect(self._move_line_up)
+
+        # Move line down
+        self._shortcut_move_line_down = QShortcut(
+            QKeySequence(settings.shortcut_move_line_down), self)
+        self._shortcut_move_line_down.setContext(Qt.WidgetShortcut)
+        self._shortcut_move_line_down.activated.connect(self._move_line_down)
+
+        # Duplicate line
+        self._shortcut_duplicate_line = QShortcut(
+            QKeySequence(settings.shortcut_duplicate_line), self)
+        self._shortcut_duplicate_line.setContext(Qt.WidgetShortcut)
+        self._shortcut_duplicate_line.activated.connect(self._duplicate_line)
+        
+    def eventFilter(self, obj, event):
+        """Filters out and handles the 'Cut' shortcut, cross-platform."""
+        if obj == self and event.type() == QEvent.KeyPress:
+            if event.matches(QKeySequence.Cut):
+                if not self.textCursor().hasSelection():
+                    self._delete_current_line()
+                    return False
+        return super().eventFilter(obj, event)
+    
+    def _delete_current_line(self):
+        """
+        Removes the current line, preserving undo/redo.
+        """
+        cursor = self.textCursor()
+        start, end = self._current_line_bounds(cursor)
+        doc_length = self.document().characterCount()
+        
+        cursor.beginEditBlock()
+        # We want to remove the trailing or preceding newline, but not both.
+        if end < doc_length - 1:
+            end += 1
+        elif start > 0:
+            start -= 1
+        cursor.setPosition(start)
+        cursor.setPosition(end, QTextCursor.KeepAnchor)
+        cursor.removeSelectedText()
+        cursor.endEditBlock()
+
+    def _current_line_bounds(self, cursor=None):
+        """
+        Return (start, end) positions of the current line in the document.
+        """
+        if cursor is None:
+            cursor = self.textCursor()
+        original_pos = cursor.position()
+
+        cursor.movePosition(QTextCursor.StartOfBlock)
+        start = cursor.position()
+        cursor.movePosition(QTextCursor.EndOfBlock)
+        end = cursor.position()
+
+        # Restore cursor
+        cursor.setPosition(original_pos)
+        self.setTextCursor(cursor)
+        return start, end
+
+    def _move_lines_impl(self, direction: int):
+        """
+        Step 1 of the plan:
+          - Expand selection to cover the line before and the line after the
+            current selection (or the current line if nothing is selected).
+          - Ignore 'direction' for now.
+        """
+        doc = self.document()
+        cursor = self.textCursor()
+        cursor.beginEditBlock()
+    
+        anchor = cursor.anchor()
+        pos = cursor.position()
+    
+        # Identify which line is top vs bottom
+        anchor_block = doc.findBlock(anchor)
+        pos_block = doc.findBlock(pos)
+        if anchor_block.firstLineNumber() > pos_block.firstLineNumber():
+            anchor_block, pos_block = pos_block, anchor_block
+    
+        # Expand upward if possible
+        prev_block = anchor_block.previous()
+        if prev_block.isValid():
+            has_preceding_line = True
+            anchor_block = prev_block
+        else:
+            has_preceding_line = False
+    
+        # Expand downward if possible
+        next_block = pos_block.next()
+        if next_block.isValid():
+            has_following_line = True
+            pos_block = next_block
+        else:
+            has_following_line = False
+            
+        # Don't move lines up or down if they're already at the start or end
+        if not has_preceding_line and direction < 0:
+            logger.info('cannot move line up')
+            return 
+        if not has_following_line and direction > 0:
+            logger.info('cannot move line down')
+            return 
+    
+        # Build new selection from start of anchor_block to end of pos_block
+        start_pos = anchor_block.position()
+        end_pos = pos_block.position() + pos_block.length()
+    
+        # Set the new selection
+        cursor.setPosition(start_pos)
+        if end_pos >= doc.characterCount():
+            # If the end of the selection is the end of the document, then we
+            # need to set it one character sooner, and manually add a newline
+            # to the end to compensate for this, but then not pad with a 
+            # newline to in turn compensate for the fact that we already padded
+            # the selection
+            cursor.setPosition(end_pos - 1, QTextCursor.KeepAnchor)
+            selection = cursor.selectedText() + '\n'
+            insert_padding = ''
+        else:
+            cursor.setPosition(end_pos, QTextCursor.KeepAnchor)
+            selection = cursor.selectedText()
+            insert_padding = '\n'
+        
+        # Get the current selection, and swap the lines according to the 
+        # direction in which we're moving. We have special cases for when there
+        # is no preceding or following line.
+        lines = selection.splitlines()
+        if direction < 0:
+            anchor -= len(lines[0]) + 1
+            pos -= len(lines[0]) + 1
+            if has_following_line:
+                lines = lines[1:-1] + [lines[0], lines[-1]]
+            else:
+                lines = lines[1:] + [lines[0]]
+        else:
+            anchor += len(lines[-1]) + 1
+            pos += len(lines[-1]) + 1
+            if has_preceding_line:
+                lines = [lines[0], lines[-1]] + lines[1:-1]
+            else:
+                lines = [lines[-1]] + lines[:-1]
+        cursor.removeSelectedText()
+        cursor.insertText('\n'.join(lines) + insert_padding)
+        # Restore the original selection
+        cursor.setPosition(anchor)
+        cursor.setPosition(pos, QTextCursor.KeepAnchor)
+        self.setTextCursor(cursor)        
+        cursor.endEditBlock()
+        self.refresh()
+    
+    def _move_line_up(self):
+        """Move the currently selected lines (or single line) up by one line."""
+        self._move_lines_impl(direction=-1)
+    
+    def _move_line_down(self):
+        """Move the currently selected lines (or single line) down by one line."""
+        self._move_lines_impl(direction=1)
+
+    def _duplicate_line(self):
+        """
+        If there is no selection, duplicate the current block. If there is
+        a selection, all blocks that are part of the selection should be duplicated.
+        The anchor and cursor should be preserved on the lower of the duplicated blocks.
+        In other words, it should appear as if the duplication is inserted above.
+        """
+        cursor = self.textCursor()
+        cursor.beginEditBlock()
+        
+        # 1) Remember original anchor and cursor positions
+        original_anchor = cursor.anchor()
+        original_position = cursor.position()
+        
+        # 2) Determine start_pos and end_pos based on anchor / cursor
+        start_pos = min(original_anchor, original_position)
+        end_pos   = max(original_anchor, original_position)
+        
+        # 3) Move the cursor to the start of the block that contains start_pos
+        cursor.setPosition(start_pos)
+        cursor.movePosition(cursor.StartOfBlock)
+        start_block_pos = cursor.position()
+        
+        # 4) Move the cursor to the end of the block containing end_pos (keeping anchor)
+        cursor.setPosition(end_pos, cursor.KeepAnchor)
+        cursor.movePosition(cursor.EndOfBlock, cursor.KeepAnchor)
+        end_block_pos = cursor.position()
+        
+        # 5) The text that is now selected should be duplicated
+        duplication_text = cursor.selectedText()
+        # QPlainTextEdit often uses U+2029 for newlines
+        duplication_text = duplication_text.replace(u'\u2029', '\n')
+        
+        # 6) Insert '\n' + duplication_text just after the selection
+        #    But first, move cursor to the end of the selected blocks without a selection
+        cursor.setPosition(end_block_pos, cursor.MoveAnchor)
+        # Now insert a new line plus the duplicated text
+        cursor.insertText('\n' + duplication_text)
+        
+        # Figure out how many characters were inserted
+        inserted_length = 1 + len(duplication_text)
+        
+        # 7) Restore anchor/cursor so that they point to the *new* lines (the lower portion).
+        #    According to your docstring, we want the final “visual” anchor/cursor to effectively
+        #    be as if the duplication is inserted above, leaving anchor/cursor on the newly inserted lines.        
+        cursor.setPosition(original_anchor + inserted_length, cursor.MoveAnchor)
+        cursor.setPosition(original_position + inserted_length, cursor.KeepAnchor)
+        
+        self.setTextCursor(cursor)        
+        cursor.endEditBlock()

pyqt_code_editor/mixins/smart_backspace_delete.py

@@ -0,0 +1,120 @@
+from qtpy.QtCore import Qt
+from qtpy.QtGui import QKeyEvent, QTextCursor
+import logging
+logging.basicConfig(level=logging.INFO, force=True)
+logger = logging.getLogger(__name__)
+
+
+class SmartBackspaceDelete:
+    """
+    This is meant to be used as a mixin for QPlainTextEdit to enhance the
+    functionality of backspace and delete in a code editor. It re-implements
+    keyPressEvent(), supporting the following behavior:
+
+    1) Backspace anywhere in the whitespace at the end of a line:
+       - Full right-trim of the whitespace for that line (including whitespace
+         before the cursor).
+       - Place the cursor at the end of the trimmed line.
+    2) Backspace at the very start of a line:
+       - Delete the preceding newline and trailing whitespace on the previous
+         line (up to the first non-whitespace or newline).
+       - Place the cursor at the end of the trimmed preceding line.
+    3) Delete anywhere in the whitespace at the end of a line (except the
+       very last position):
+       - Right-trim from the cursor position onward.
+       - The cursor does not move, so it can remain at the same block/column
+         index once the whitespace is removed.
+    4) Delete at the very end of a line:
+       - Delete the next newline and the leading whitespace on the next line
+         up to the first non-whitespace or newline.
+       - Keep the cursor where it was, effectively pulling up the next line.
+    """
+
+    def keyPressEvent(self, event: QKeyEvent) -> None:
+        """
+        Handle the specific 'backspace anywhere in the whitespace at the
+        end of a line' logic. If not applicable, fall back to default behavior.
+        """
+        c = self.textCursor()
+        # We don't handle special cases if there is a selection
+        if c.hasSelection():
+            super().keyPressEvent(event)
+            return
+        key = event.key()
+        block = c.block()
+        pos = c.positionInBlock()
+        text = block.text()
+        block_length = len(text)
+        stripped_block_length = len(text.rstrip())
+        in_trailing_whitespace = text[pos:].isspace()
+        has_trailing_whitespace = block_length > stripped_block_length
+        at_block_end = pos == block_length
+        # We don't do anything with empty lines unless we're at the start of the
+        # block
+        if text.isspace() and pos > 0:
+            super().keyPressEvent(event)
+            return
+        # If we're at the very start of the line, then we're also eating up the
+        # trailing whitespace of the previous line. We do this by first moving to
+        # the end of the previous line, then handling this case recursively, and
+        # finally deleting the newline.
+        if key == Qt.Key_Backspace and pos == 0 and block.previous().isValid():
+            logger.info('moving to end of previous block')
+            c.movePosition(QTextCursor.PreviousBlock, QTextCursor.MoveAnchor)
+            c.movePosition(QTextCursor.EndOfBlock, QTextCursor.MoveAnchor)
+            self.setTextCursor(c)
+            # We only delete trailing whitespace if the previous line has 
+            # trailing whitespace
+            prev_text = c.block().text()
+            if prev_text.rstrip() != prev_text:
+                logger.info('removing trailing whitespace from previous block')
+                self.keyPressEvent(event)
+            else:
+                logger.info('previous block doesn\'t have trailing whitespace')
+            logger.info('removing neweline')
+            c = self.textCursor()
+            c.movePosition(QTextCursor.NextBlock, QTextCursor.KeepAnchor)
+            c.removeSelectedText()
+            self.setTextCursor(c)
+            return
+        # If we're in the whitespace at the end of the block, we delete all 
+        # trailing whitespace.
+        if key == Qt.Key_Backspace and has_trailing_whitespace and \
+                (in_trailing_whitespace or at_block_end):
+            n_trim = block_length - stripped_block_length
+            logger.info(f'trimming {n_trim} whitespace from end of block')
+            c.movePosition(QTextCursor.EndOfBlock)
+            c.movePosition(QTextCursor.Left, QTextCursor.KeepAnchor, n_trim)
+            c.removeSelectedText()
+            self.setTextCursor(c)
+            event.accept()
+            return
+        # If we're in the whitespace at the end of the block, we delete all 
+        # trailing whitespace that follows the cursor.
+        if key == Qt.Key_Delete and in_trailing_whitespace:
+            n_trim = block_length - pos
+            logger.info(f'trimming {n_trim} whitespace from end of block')
+            c.movePosition(QTextCursor.EndOfBlock)
+            c.movePosition(QTextCursor.Left, QTextCursor.KeepAnchor, n_trim)
+            c.removeSelectedText()
+            self.setTextCursor(c)
+            event.accept()
+            return
+        # If we're at the end of a line, then delete removes the next line break
+        # and the leading whitespace on the next line. We do this by first moving
+        # to the next block, calculating how much leading whitespace there is,
+        # then getting a fresh cursor and removing this leading whitespace plus
+        # one character for the newline.
+        if key == Qt.Key_Delete and at_block_end and block.next().isValid():
+            c.movePosition(QTextCursor.NextBlock, QTextCursor.MoveAnchor)
+            next_text = c.block().text()
+            n_trim = len(next_text) - len(next_text.lstrip()) + 1
+            c = self.textCursor()
+            c.movePosition(
+                QTextCursor.NextCharacter, QTextCursor.KeepAnchor, n_trim)
+            c.removeSelectedText()
+            self.setTextCursor(c)
+            event.accept()
+            return                    
+        # In any situation, fall back
+        super().keyPressEvent(event)

pyqt_code_editor/mixins/symbols.py

@@ -0,0 +1,45 @@
+import logging
+from qtpy.QtGui import QShortcut
+from qtpy.QtCore import Qt, Signal
+from .. import settings
+from ..widgets import QuickSymbolDialog
+logging.basicConfig(level=logging.INFO, force=True)
+logger = logging.getLogger(__name__)
+
+    
+class Symbols:
+    """
+    A mixin for QPlainTextEdit that provides all symbols (functions, classes, etc.)
+    for the current file.
+    """
+    symbols_available = Signal(list)
+    
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        logger.info("Initializing symbols")
+        self.symbol_shortcut = QShortcut(settings.shortcut_symbols, self)
+        self.symbol_shortcut.setContext(Qt.WidgetWithChildrenShortcut)
+        self.symbol_shortcut.activated.connect(self.request_symbols)                
+    
+    def request_symbols(self):
+        logger.info("Requesting symbols")
+        code = self.toPlainText()
+        self.send_worker_request(action='symbols', code=code,
+                                 path=self.code_editor_file_path,
+                                 language=self.code_editor_language)
+
+    def handle_worker_result(self, action, result):
+        """Check for completion or calltip results from the external worker."""
+        super().handle_worker_result(action, result)
+        if action != 'symbols':
+            return
+        QuickSymbolDialog(self, result['symbols'], self.jump_to_symbol).exec()
+        
+    def jump_to_symbol(self, symbol):
+        block_nr = symbol['line'] - 1
+        cursor = self.textCursor()
+        # Jump to block number
+        cursor.setPosition(self.document().findBlockByNumber(block_nr).position())
+        self.setTextCursor(cursor)
+        self.centerCursor()
+        self.ensureCursorVisible()

pyqt_code_editor/mixins/theme.py

@@ -0,0 +1,99 @@
+from pygments.token import Token
+from .. import settings
+from ..syntax_highlighters.syntax_highlighter import create_syntax_highlighter
+import logging
+from qtpy.QtGui import QPainter, QColor, QFont, QFontMetrics
+from qtpy.QtWidgets import QPlainTextEdit
+
+logging.basicConfig(level=logging.INFO, force=True)
+logger = logging.getLogger(__name__)
+
+class Theme:
+    """
+    Mixin for QPlainTextEdit that provides theming. It handles the following:
+    
+    - Apply syntax highlighting
+    - Set a stylesheet
+    - Set code_editor_colors property so that other mixins can use it
+    - Toggle visibility of character ruler (based on settings.character_ruler)
+    - Toggle word wrap (based on settings.word_wrap)
+    """
+        
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._highlighter = create_syntax_highlighter(
+            self.code_editor_language, self.document(),
+            color_scheme=settings.color_scheme)
+        style = self._highlighter._style
+        self.code_editor_colors = {            
+            'background': style.background_color,
+            'highlight': style.highlight_color,
+            'text': '#' + style.style_for_token(Token.Text)['color'],
+            'line-number': '#' + style.style_for_token(Token.Comment)['color'],
+            'border': '#' + style.style_for_token(Token.Comment)['color']
+        }
+        self._apply_stylesheet()
+        self._apply_word_wrap()
+        self._apply_tab_width()
+
+    def refresh(self):
+        super().refresh()
+        self._highlighter.rehighlight()
+        
+    def update_theme(self):
+        super().update_theme()
+        self._apply_stylesheet()
+        self._apply_word_wrap()
+        self._apply_tab_width
+        self.viewport().update()
+
+    def _apply_stylesheet(self):
+        stylesheet = f"""
+            QPlainTextEdit {{
+                background-color: {self.code_editor_colors['background']};
+                font: {settings.font_size}pt '{settings.font_family}';
+                color: {self.code_editor_colors['text']};
+            }}
+            QToolTip {{
+                color: {self.code_editor_colors['text']};
+                background-color: {self.code_editor_colors['background']};
+                font: {settings.font_size}pt '{settings.font_family}';
+                border-color: {self.code_editor_colors['border']};
+                border-width: 1px;
+                border-style: solid;
+                border-radius: 4px;
+                padding: 4px;
+            }}
+        """
+        self.setStyleSheet(stylesheet)
+
+    def paintEvent(self, event):
+        super().paintEvent(event)
+        if settings.character_ruler:
+            char_width = self.fontMetrics().width("x")
+            x_pos = int(char_width * settings.character_ruler + self.contentOffset().x())
+            y_pos = self.viewport().height()
+            painter = QPainter(self.viewport())
+            painter.setPen(QColor(self.code_editor_colors['line-number']))
+            painter.drawLine(x_pos, 0, x_pos, y_pos)
+
+    def _apply_word_wrap(self):
+        """
+        Toggles word wrap mode based on settings.word_wrap
+        """
+        if settings.word_wrap:
+            self.setLineWrapMode(QPlainTextEdit.WidgetWidth)
+        else:
+            self.setLineWrapMode(QPlainTextEdit.NoWrap)
+
+    def _apply_tab_width(self):
+        """Sets the tab-stop distance. This uses a QFont rather than relying on
+        the standard font metrics, because these are not immediately applied on
+        initialization.
+        """
+        font = QFont()
+        font.setFamily(settings.font_family)
+        font.setPointSize(settings.font_size)
+        self.setTabStopDistance(
+            settings.tab_width * QFontMetrics(font).horizontalAdvance(' '))
+     

pyqt_code_editor/mixins/zoom.py

@@ -0,0 +1,51 @@
+from qtpy.QtCore import Qt
+from .. import settings
+
+
+class Zoom:
+    """
+    A mixin that implements zoom in/out with:
+      - Ctrl+Plus
+      - Ctrl+Minus
+      - Ctrl+ScrollUp/Down
+    It expects the QPlainTextEdit to have a 'code_editor_font_size'
+    attribute and a 'setFont(...)' method.
+    """
+
+    def keyPressEvent(self, event):
+        if (event.modifiers() & Qt.ControlModifier):
+            if event.key() == Qt.Key_Plus:
+                self.zoom_in()
+                return
+            elif event.key() == Qt.Key_Minus:
+                self.zoom_out()
+                return
+
+        super().keyPressEvent(event)
+
+    def wheelEvent(self, event):
+        """
+        Zoom in/out when Ctrl is pressed and the user scrolls the wheel.
+        """
+        if event.modifiers() & Qt.ControlModifier:
+            # angleDelta().y() is typically 120 per step on many systems.
+            delta = event.angleDelta().y()
+            if delta > 0:
+                self.zoom_in()
+            else:
+                self.zoom_out()
+            # Do not pass event along so normal scrolling doesn't occur
+            event.accept()
+        else:
+            super().wheelEvent(event)
+
+    def zoom_in(self):
+        """ Increase the editor's font size by 1 point. """
+        settings.font_size += 1
+        self.update_theme()
+
+    def zoom_out(self):
+        """ Decrease the editor's font size by 1 point, down to a minimum of 1. """
+        if settings.font_size > 1:
+            settings.font_size -= 1
+        self.update_theme()