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

pyqt_code_editor/mixins/python_auto_indent.py

@@ -0,0 +1,239 @@
+from qtpy.QtCore import Qt
+from .. import python_utils, settings
+import logging
+logging.basicConfig(level=logging.INFO, force=True)
+
+
+class PythonAutoIndent:
+    """
+    A mixin class to provide Python-specific auto-indentation,
+    suitable for mixing into a QPlainTextEdit subclass.
+
+    This version includes more "smart" indentation heuristics:
+      1. Increase indentation for lines ending in ':' (block start).
+      2. Increase indentation for an open bracket '([{', if it has no closing match
+         on the same line (simple heuristic).
+      3. Attempt to align arguments if we detect a function call or definition
+         continuing onto the next line.
+      4. Dedent if the new line starts with keywords like 'elif' or 'else'.
+      5. Basic bracket matching to align closing brackets with the line holding
+         the corresponding open bracket (though for brevity we show a simple approach).
+    """
+
+    def keyPressEvent(self, event):
+        key = event.key()
+        modifiers = event.modifiers()
+        logging.info("keyPressEvent: key=%s, modifiers=%s", key, modifiers)
+
+        # Check for Tab/Shift+Tab indentation
+        if key == Qt.Key_Tab and modifiers == Qt.NoModifier:
+            logging.info("Tab pressed, indent code")
+            self.indent_code()
+            return
+        elif (key == Qt.Key_Tab and modifiers == Qt.ShiftModifier) or key == Qt.Key_Backtab:
+            logging.info("Shift+Tab pressed, dedent code")
+            self.dedent_code()
+            return
+
+        # Handle backspace in leading indentation
+        if key == Qt.Key_Backspace and modifiers == Qt.NoModifier:
+            if self._handle_backspace():
+                return
+
+        # Handle delete in leading indentation
+        if key == Qt.Key_Delete and modifiers == Qt.NoModifier:
+            if self._handle_delete():
+                return
+
+        # Check for Enter/Return
+        if key in (Qt.Key_Enter, Qt.Key_Return):
+            logging.info("Enter/Return pressed")
+            cursor = self.textCursor()
+            cursor.beginEditBlock()
+            code = self.toPlainText()[:cursor.position()]
+            new_indent = python_utils.python_auto_indent(code)
+            # Insert the computed indentation
+            super().keyPressEvent(event)
+            if new_indent > 0:
+                logging.info("Inserting %d spaces of indentation", new_indent)
+                self._insert_indentation(new_indent)
+            cursor.endEditBlock()
+            self.setTextCursor(cursor)
+            return
+
+        # Otherwise, default behavior
+        super().keyPressEvent(event)
+
+    def _handle_backspace(self):
+        """
+        If the cursor is in leading indentation, remove a 'tab chunk'
+        of spaces (settings.tab_width), otherwise let normal backspace happen.
+        Returns True if we handled it, False if not.
+        """
+        cursor = self.textCursor()
+        if not cursor.hasSelection():
+            block_text = cursor.block().text()
+            pos_in_block = cursor.positionInBlock()
+            leading_spaces = len(block_text) - len(block_text.lstrip(' '))
+
+            # Only if we're in the leading whitespace region:
+            if pos_in_block > 0 and pos_in_block <= leading_spaces:
+                # Figure out how many spaces to remove
+                remainder = pos_in_block % settings.tab_width
+                if remainder == 0:
+                    remainder = settings.tab_width
+
+                remove_count = min(remainder, pos_in_block)
+                logging.info("Backspace in leading indentation, removing %d spaces", remove_count)
+
+                # Delete the chunk of spaces
+                for _ in range(remove_count):
+                    cursor.deletePreviousChar()
+                return True
+        return False
+
+    def _handle_delete(self):
+        """
+        If the cursor is in leading indentation, remove a 'tab chunk'
+        of spaces (settings.tab_width) going forward, otherwise let normal delete happen.
+        Returns True if we handled it, False if not.
+        """
+        cursor = self.textCursor()
+        if not cursor.hasSelection():
+            block_text = cursor.block().text()
+            pos_in_block = cursor.positionInBlock()
+            leading_spaces = len(block_text) - len(block_text.lstrip(' '))
+
+            # Only if we're in the leading whitespace region:
+            if pos_in_block < leading_spaces:
+                # Figure out how many spaces remain in this "tab chunk"
+                chunk_end = ((pos_in_block // settings.tab_width) + 1) * settings.tab_width
+                remove_count = min(chunk_end - pos_in_block, leading_spaces - pos_in_block)
+                logging.info("Delete in leading indentation, removing %d spaces", remove_count)
+
+                for _ in range(remove_count):
+                    cursor.deleteChar()
+                return True
+        return False
+
+
+    def _is_multiline_selection(self):
+        """
+        Returns True if selection spans more than one line, else False.
+        """
+        cursor = self.textCursor()
+        start = cursor.selectionStart()
+        end = cursor.selectionEnd()
+        start_block = self.document().findBlock(start).blockNumber()
+        end_block = self.document().findBlock(end).blockNumber()
+        return end_block > start_block
+
+    def indent_code(self):
+        """
+        Indent either the selected lines (if multi-line selection)
+        or just the current cursor position (if single-line or no selection).
+        All changes happen in a single undo block.
+        """
+        logging.info("Indent code triggered")
+        cursor = self.textCursor()
+        cursor.beginEditBlock()
+
+        if self._is_multiline_selection():
+            logging.info("Multi-line selection detected -> Indenting each line")
+            self._indent_selection()
+        else:
+            logging.info("Single-line (or no) selection -> Inserting indent at cursor")
+            # Insert spacing at the current cursor position
+            cursor.insertText(' ' * settings.tab_width)
+
+        cursor.endEditBlock()
+
+    def dedent_code(self):
+        """
+        Dedent either the selected lines (if multi-line selection)
+        or just the current line (if single-line or no selection).
+        All changes happen in a single undo block.
+        """
+        logging.info("Dedent code triggered")
+        cursor = self.textCursor()
+        cursor.beginEditBlock()
+
+        if self._is_multiline_selection():
+            logging.info("Multi-line selection detected -> Dedenting each line")
+            self._dedent_selection()
+        else:
+            logging.info("Single-line (or no) selection -> Removing indent from current line if possible")
+            line_start = cursor.block().position()
+            leading_spaces = 0
+            doc_text = cursor.block().text()
+            for ch in doc_text:
+                if ch == ' ':
+                    leading_spaces += 1
+                else:
+                    break
+
+            remove_spaces = min(settings.tab_width, leading_spaces)
+            cursor.setPosition(line_start)
+            for _ in range(remove_spaces):
+                self._delete_forward_if_space(cursor)
+
+        cursor.endEditBlock()
+
+    def _indent_selection(self):
+        """
+        Increase indent for each selected line by settings.tab_width spaces.
+        If no selection or selection on one line, that is handled outside.
+        """
+        logging.info("Indent selection (multi-line)")
+        cursor = self.textCursor()
+        start = cursor.selectionStart()
+        end = cursor.selectionEnd()
+
+        start_block = self.document().findBlock(start).blockNumber()
+        end_block = self.document().findBlock(end).blockNumber()
+
+        # Work line by line
+        for block_num in range(start_block, end_block + 1):
+            block = self.document().findBlockByNumber(block_num)
+            tmp_cursor = self.textCursor()
+            tmp_cursor.setPosition(block.position())
+            tmp_cursor.insertText(' ' * settings.tab_width)
+
+    def _dedent_selection(self):
+        """
+        Decrease indent for each selected line by settings.tab_width spaces, 
+        ensuring no reduction below zero.
+        If no selection or selection on one line, that is handled outside.
+        """
+        logging.info("Dedent selection (multi-line)")
+        cursor = self.textCursor()
+        start = cursor.selectionStart()
+        end = cursor.selectionEnd()
+
+        start_block = self.document().findBlock(start).blockNumber()
+        end_block = self.document().findBlock(end).blockNumber()
+
+        for block_num in range(start_block, end_block + 1):
+            block = self.document().findBlockByNumber(block_num)
+            line_text = block.text()
+            leading_spaces = len(line_text) - len(line_text.lstrip(' '))
+
+            remove_spaces = min(settings.tab_width, leading_spaces)
+
+            tmp_cursor = self.textCursor()
+            tmp_cursor.setPosition(block.position())
+            for _ in range(remove_spaces):
+                self._delete_forward_if_space(tmp_cursor)
+
+    def _delete_forward_if_space(self, cursor):
+        """
+        Deletes one character if it is a space, used in dedent logic.
+        """
+        if cursor.document().characterAt(cursor.position()) == ' ':
+            logging.info("Deleting forward space during dedent")
+            cursor.deleteChar()
+
+    def _insert_indentation(self, indent_count):
+        """Insert the specified number of spaces at the cursor."""
+        logging.info("Inserting indentation: %d spaces", indent_count)
+        self.textCursor().insertText(' ' * indent_count)

pyqt_code_editor/mixins/search_replace.py

@@ -0,0 +1,396 @@
+import re
+from qtpy.QtWidgets import QShortcut
+from qtpy.QtGui import (
+    QSyntaxHighlighter, QTextCharFormat, QColor, QAction,
+    QTextCursor, QKeySequence, QTextDocument
+)
+from qtpy.QtCore import Qt
+from .. import settings
+from ..widgets.search_replace_frame import SearchReplaceFrame
+
+
+class SearchReplaceHighlighter(QSyntaxHighlighter):
+    """
+    Simple syntax highlighter that highlights all matches of a given pattern.
+    Updated whenever the pattern or text changes.
+    """
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._pattern = ""
+        self._use_regex = False
+        self._case_sensitive = False
+        self._whole_word = False
+        
+        # Highlight style
+        self.highlight_format = QTextCharFormat()
+        self.highlight_format.setBackground(QColor(settings.search_replace_background))
+        self.highlight_format.setForeground(QColor(settings.search_replace_foreground))
+    
+    def setSearchOptions(self, pattern, use_regex, case_sensitive, whole_word):
+        self._pattern = pattern
+        self._use_regex = use_regex
+        self._case_sensitive = case_sensitive
+        self._whole_word = whole_word
+        self.rehighlight()  # Trigger a re-scan
+    
+    def highlightBlock(self, text):
+        if not self._pattern:
+            return
+        
+        # Build the pattern
+        pattern = self._pattern
+        flags = 0 if self._case_sensitive else re.IGNORECASE
+    
+        if self._use_regex:
+            # If whole_word is asked for, add \b on both sides (can be tricky with punctuation).
+            if self._whole_word:
+                pattern = rf"\b{pattern}\b"
+            try:
+                regex = re.compile(pattern, flags)
+            except re.error:
+                return  # invalid regex, just skip
+        else:
+            # Escape user text if not in regex mode
+            pattern = re.escape(pattern)
+            if self._whole_word:
+                pattern = rf"\b{pattern}\b"
+            regex = re.compile(pattern, flags)
+        
+        for match in regex.finditer(text):
+            start = match.start()
+            length = match.end() - match.start()
+            self.setFormat(start, length, self.highlight_format)
+
+
+class SearchReplace:
+    """
+    A mixin for QPlainTextEdit that floats a search/replace widget
+    at the top-right corner, highlights all matches, and supports
+    next/prev/replace operations. Automatically uses a single-line
+    selection as the search needle if available.
+
+    This version swaps out your 'original' syntax highlighter with
+    our search highlighter while the search widget is visible, so only
+    one QSyntaxHighlighter is attached at a time.
+    """
+    
+    def __init__(self, *args, **kwargs):
+        """
+        The derived editor class must:
+          1) Inherit from QPlainTextEdit + SearchReplace
+          2) Call super().__init__() properly.
+        """
+        super().__init__(*args, **kwargs)
+        self._originalHighlighter = None  # We'll store your existing syntax highlighter here
+        self._searchHighlighter = SearchReplaceHighlighter(None)  # We'll attach/detach dynamically
+        
+        self.setupSearchReplace()
+    
+    def setSyntaxHighlighter(self, highlighter):
+        """
+        Call this to register your normal syntax highlighter.
+        We'll attach/detach it as needed.
+        """
+        self._originalHighlighter = highlighter
+        if highlighter:
+            highlighter.setDocument(self.document())
+    
+    def setupSearchReplace(self):
+        """
+        Call this once in your QPlainTextEdit subclass's __init__ 
+        """
+        # Create the search/replace frame
+        self._searchFrame = SearchReplaceFrame(self)
+        self._searchFrame.setVisible(False)
+        
+        # Connect signals
+        self._searchFrame.findNextRequested.connect(self.findNext)
+        self._searchFrame.findPrevRequested.connect(self.findPrev)
+        self._searchFrame.replaceOneRequested.connect(self.replaceOne)
+        self._searchFrame.replaceAllRequested.connect(self.replaceAll)
+        
+        # Whenever user changes the find text or toggles checkboxes, re-highlight
+        self._searchFrame.findEdit.textChanged.connect(self.updateHighlighter)
+        self._searchFrame.caseBox.toggled.connect(self.updateHighlighter)
+        self._searchFrame.regexBox.toggled.connect(self.updateHighlighter)
+        self._searchFrame.wholeWordBox.toggled.connect(self.updateHighlighter)
+        
+        # Shortcuts
+        findShortcut = QShortcut(QKeySequence.Find, self)
+        findShortcut.setContext(Qt.WidgetWithChildrenShortcut)
+        findShortcut.activated.connect(self.showSearchOnly)
+        
+        replShortcut = QShortcut(QKeySequence.Replace, self)
+        replShortcut.setContext(Qt.WidgetWithChildrenShortcut)
+        replShortcut.activated.connect(self.showSearchReplace)
+        
+        # Hide on Escape if wanted
+        self.escapeAction = QAction(self)
+        self.escapeShortcut = QShortcut(QKeySequence.Cancel, self)
+        self.escapeShortcut.setContext(Qt.WidgetWithChildrenShortcut)
+        self.escapeShortcut.activated.connect(self.hideSearch)
+        self.escapeShortcut.setEnabled(False)
+        self.escapeAction.triggered.connect(self.hideSearch)
+        self.escapeAction.setEnabled(False)
+        self.addAction(self.escapeAction)
+        
+    def _showSearchReplace(self, search_only):
+        # If user has single-line selection, auto-populate
+        cursor = self.textCursor()
+        if cursor.hasSelection():
+            needle = cursor.selectedText().splitlines()            
+            if len(needle) == 1:
+                needle = needle[0].strip()
+                self._searchFrame.findEdit.setText(needle)
+            else:
+                needle = self._searchFrame.findEdit.text()
+            self._updateMatchLabel(needle, self._find_flags())
+        
+        if search_only:
+            self._searchFrame.showSearchOnly()
+        else:
+            self._searchFrame.showSearchReplace()
+        self._searchFrame.setVisible(True)
+        self._searchFrame.findEdit.setFocus()
+        self.updateSearchPosition()
+        
+        # Swap out original highlighter for the search highlighter
+        self._swapToSearchHighlighter()
+        self.updateHighlighter()
+        self.escapeAction.setEnabled(True)
+        self.escapeShortcut.setEnabled(True)         
+    
+    def showSearchOnly(self):
+        self._showSearchReplace(search_only=True)
+    
+    def showSearchReplace(self):
+        self._showSearchReplace(search_only=False)
+    
+    def hideSearch(self):
+        self._searchFrame.setVisible(False)
+        self.setFocus()
+        self.escapeAction.setEnabled(False)
+        self.escapeShortcut.setEnabled(False)
+        # Revert to original highlighter
+        self._revertToOriginalHighlighter()
+    
+    def resizeEvent(self, event):
+        """ Overridden to keep the search frame pinned top-right. """
+        super().resizeEvent(event)
+        self.updateSearchPosition()
+    
+    def updateSearchPosition(self):
+        if self._searchFrame.isVisible():
+            # Pin to top-right with some margin
+            margin = 20
+            frame_width = self._searchFrame.width()
+            self._searchFrame.move(self.width() - frame_width - margin, margin)
+    
+    def _swapToSearchHighlighter(self):
+        """
+        Temporarily remove the original syntax highlighter
+        and attach the search highlighter.
+        """
+        if self._originalHighlighter:
+            self._originalHighlighter.setDocument(None)
+        self._searchHighlighter.setDocument(self.document())
+    
+    def _revertToOriginalHighlighter(self):
+        """
+        Detach the search highlighter and restore the original highlighter.
+        """
+        self._searchHighlighter.setDocument(None)
+        if self._originalHighlighter:
+            self._originalHighlighter.setDocument(self.document())
+            
+    def _find_flags(self, forward=True):
+        flags = QTextDocument.FindFlag(0)
+        if self._searchFrame.caseBox.isChecked():
+            flags |= QTextDocument.FindFlag.FindCaseSensitively
+        if not forward:
+            flags |= QTextDocument.FindFlag.FindBackward
+        if self._searchFrame.wholeWordBox.isChecked():
+            flags |= QTextDocument.FindFlag.FindWholeWords
+        return flags
+    
+    def findNext(self):
+        self._find(forward=True)
+    
+    def findPrev(self):
+        self._find(forward=False)
+    
+    def _find(self, forward=True):
+        flags = self._find_flags(forward=forward) 
+        needle = self._searchFrame.findEdit.text()
+        if not needle:
+            self._searchFrame.matchCountLabel.clear()
+            return
+        
+        # 1) Attempt to find next/prev match.
+        found = self.find(needle, flags)
+        
+        # 2) If not found, do wrap-around by jumping to start or end.
+        if not found:
+            cursor = self.textCursor()
+            if forward:
+                cursor.movePosition(QTextCursor.Start)
+            else:
+                cursor.movePosition(QTextCursor.End)
+            self.setTextCursor(cursor)
+            self.find(needle, flags)
+
+        # 3) Regardless of found or wrap-around success, update label:
+        self._updateMatchLabel(needle, flags)
+
+    def _updateMatchLabel(self, needle, flags):
+        """
+        Counts how many total occurrences are in the document
+        and which occurrence the cursor is currently on. Then sets
+        "X of Y" in self._searchFrame.matchCountLabel, or clears
+        it if no matches are found.
+        """
+        if not needle:
+            self._searchFrame.matchCountLabel.clear()
+            return
+        
+        # We'll remove any backward flag to count from top to bottom
+        # so we can do a standard forward pass for counting:
+        forward_flags = QTextDocument.FindFlag(flags & ~QTextDocument.FindBackward)
+
+        # Save the user's current cursor
+        saved_cursor = self.textCursor()
+
+        # Move a fresh cursor to the start
+        temp_cursor = QTextCursor(self.document())
+        temp_cursor.movePosition(QTextCursor.Start)
+
+        total_matches = 0
+        current_index = 0
+
+        # We'll store all match positions so we can see which is "current"
+        found_positions = []
+
+        # 1) Find all matches from top to bottom.
+        while True:
+            temp_cursor = self.document().find(needle, temp_cursor, forward_flags)
+            if temp_cursor.isNull():
+                break
+            found_positions.append((temp_cursor.position(), temp_cursor.anchor()))
+            total_matches += 1
+        
+        if total_matches == 0:
+            # No matches at all
+            self._searchFrame.matchCountLabel.setText('0 of 0')
+            # Restore original cursor
+            self.setTextCursor(saved_cursor)
+            return
+        
+        # 2) Determine which match is "current" by comparing
+        # our saved_cursor's position to the found positions:
+        current_pos = saved_cursor.position()
+        current_anchor = saved_cursor.anchor()
+
+        for idx, (pos, anch) in enumerate(found_positions, start=1):
+            if pos == current_pos and anch == current_anchor:
+                current_index = idx
+                break
+        
+        if current_index == 0:
+            # Possibly just in wrap-around scenario; we can do extra logic
+            # or default to 1 (the last found match).
+            current_index = total_matches
+
+        # 3) Update the label text
+        self._searchFrame.matchCountLabel.setText(f"{current_index} of {total_matches}")
+
+        # 4) Restore original cursor
+        self.setTextCursor(saved_cursor)
+    
+    def replaceOne(self):
+        needle = self._searchFrame.findEdit.text()
+        if not needle:
+            return
+        
+        cursor = self.textCursor()
+        if cursor.hasSelection():
+            # Optionally verify the selected text is the current match. We'll skip that check here.
+            replacement_text = self._searchFrame.replaceEdit.text()
+            cursor.insertText(replacement_text)
+            self.setTextCursor(cursor)
+        self.findNext()
+        self.updateHighlighter()
+        self.set_modified(True)
+    
+    def replaceAll(self):
+        needle = self._searchFrame.findEdit.text()
+        if not needle:
+            return
+        
+        replacement = self._searchFrame.replaceEdit.text()
+        
+        # Save cursor
+        saved_cursor = self.textCursor()
+        text = self.toPlainText()
+        
+        # Build regex pattern
+        flags = 0 if self._searchFrame.caseBox.isChecked() else re.IGNORECASE
+        patt = needle
+        if not self._searchFrame.regexBox.isChecked():
+            patt = re.escape(patt)
+        if self._searchFrame.wholeWordBox.isChecked():
+            patt = rf"\b{patt}\b"
+        
+        try:
+            compiled = re.compile(patt, flags)
+        except re.error:
+            return
+        
+        new_text, num_replacements = compiled.subn(replacement, text)
+        self.setPlainText(new_text)
+        
+        # After replace all, set the needle to the replacement text
+        self._searchFrame.findEdit.setText(replacement)
+        
+        # Restore cursor
+        self.setTextCursor(saved_cursor)
+        self.updateHighlighter()
+        self.set_modified(True)
+    
+    def updateHighlighter(self):
+        # When search widget is hidden, the search highlighter won't be attached
+        # So only do this if the widget is visible
+        if not self._searchFrame.isVisible():
+            return
+        
+        find_text = self._searchFrame.findEdit.text()
+        use_regex = self._searchFrame.regexBox.isChecked()
+        case_sensitive = self._searchFrame.caseBox.isChecked()
+        whole_word = self._searchFrame.wholeWordBox.isChecked()
+        
+        self._searchHighlighter.setSearchOptions(
+            find_text, use_regex, case_sensitive, whole_word
+        )
+        
+        # Count total matches to enable/disable buttons
+        match_count = 0
+        if find_text:
+            flags = 0 if case_sensitive else re.IGNORECASE
+            pattern = find_text
+            if not use_regex:
+                pattern = re.escape(pattern)
+            if whole_word:
+                pattern = rf"\b{pattern}\b"
+            try:
+                compiled = re.compile(pattern, flags)
+                match_count = len(compiled.findall(self.toPlainText()))
+            except re.error:
+                match_count = 0
+        
+        # Enable/disable buttons based on matches
+        has_matches = (match_count > 0)
+        self._searchFrame.findNextBtn.setEnabled(has_matches)
+        self._searchFrame.findPrevBtn.setEnabled(has_matches)
+        self._searchFrame.replaceBtn.setEnabled(has_matches)
+        self._searchFrame.replaceAllBtn.setEnabled(has_matches)
+        self._updateMatchLabel(self._searchFrame.findEdit.text(),
+                               self._find_flags())