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

pyqt_code_editor/widgets/completion_popup.py

@@ -0,0 +1,89 @@
+from qtpy.QtCore import Qt
+from qtpy.QtGui import QTextCursor
+from qtpy.QtWidgets import QListWidget, QListWidgetItem
+from .. import settings
+
+
+class CompletionPopup(QListWidget):
+    """
+    A popup widget to display multiple completion suggestions,
+    but it does NOT automatically grab focus or hide on focusOut
+    so that it won't flicker when the user keeps typing in the editor.
+    """
+    def __init__(self, editor):
+        super().__init__(editor)
+        self.editor = editor
+        self._completion_map = {}
+        self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+        self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)        
+        if editor.code_editor_colors is not None:
+            self.setStyleSheet(f'''QListWidget {{
+                color: {editor.code_editor_colors['text']};
+                background-color: {editor.code_editor_colors['background']};
+                font: {settings.font_size}pt '{settings.font_family}';
+                border: 1px solid {editor.code_editor_colors['border']};
+            }}''')
+        # Use a frameless tool window so it can float above the editor
+        # without stealing focus. Note we do NOT use Qt.Popup here.
+        self.setWindowFlags(Qt.FramelessWindowHint | Qt.Tool)
+
+        # Let the editor keep focus
+        self.setFocusPolicy(Qt.NoFocus)
+
+        # Single selection mode
+        self.setSelectionMode(self.SingleSelection)
+
+        # Insert the chosen completion when activated
+        self.itemActivated.connect(self.insert_completion)
+
+    def show_completions(self, completions):
+        """
+        Show/update the list of completions near the editor's cursor,
+        without grabbing focus or hiding automatically.
+        """
+        self.clear()
+        for c in completions:
+            self._completion_map[c['name']] = c['name']
+            QListWidgetItem(c['name'], self)
+
+        if not completions:
+            self.hide()
+            return
+
+        # Place near the text cursor, taking into account that the viewport 
+        # might change due to line numbers or other things to the left of the
+        # editor
+        cursor_rect = self.editor.cursorRect()
+        cursor_rect.moveRight(cursor_rect.left() + self.editor.viewportMargins().left())
+        global_pos = self.editor.mapToGlobal(cursor_rect.bottomLeft())
+        self.move(global_pos)
+
+        # Resize to fit the number of completions (within reason)
+        self.setCurrentRow(0)
+        self.resize(min(500, self.sizeHintForColumn(0) + 8),
+                    min(500, self.sizeHintForRow(0) * len(completions) + 8))
+
+        # If we are already visible, no need to hide/show
+        # Just continue to show it in the new position.
+        if not self.isVisible():
+            self.show()
+            
+    def focusOutEvent(self, event):
+        """
+        We override focusOutEvent but don't hide the popup
+        so we can continue showing suggestions while the editor has focus.
+        """
+        # If you want it to hide whenever it loses focus, uncomment:
+        super().focusOutEvent(event)
+
+    def insert_completion(self, item):
+        """
+        Inserts the selected completion text into the editor at the current cursor position.
+        """
+        if not item:
+            return
+        name = item.text()
+        completion = self._completion_map.get(name)
+        if not completion:
+            return
+        self.editor._cm_insert_completion(completion)

pyqt_code_editor/widgets/dock.py

@@ -0,0 +1,15 @@
+from qtpy.QtCore import Signal
+from qtpy.QtWidgets import QDockWidget
+
+
+class Dock(QDockWidget):
+
+    close_requested = Signal()
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def closeEvent(self, event):
+        event.ignore()
+        self.hide()
+        self.close_requested.emit()

pyqt_code_editor/widgets/quick_open_dialog.py

@@ -0,0 +1,196 @@
+import os
+import logging
+from qtpy.QtWidgets import (
+    QDialog,
+    QVBoxLayout,
+    QLineEdit,
+    QListView,
+    QAbstractItemView,
+    QApplication
+)
+from qtpy.QtCore import Qt, QSortFilterProxyModel, QModelIndex
+from qtpy.QtGui import QStandardItemModel, QStandardItem
+
+logger = logging.getLogger(__name__)
+
+class MultiNeedleFilterProxyModel(QSortFilterProxyModel):
+    """
+    Custom proxy model that splits the user input string into
+    multiple tokens (space-delimited). Each token must appear
+    somewhere in the item text (case-insensitive) for it to match.
+    """
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setFilterCaseSensitivity(Qt.CaseInsensitive)
+        self._needles = []
+
+    def setFilterString(self, text):
+        # Split on whitespace to get multiple tokens
+        self._needles = text.strip().split()
+        self.invalidateFilter()
+
+    def filterAcceptsRow(self, source_row, source_parent):
+        if not self._needles:
+            return True  # If no input, show all
+        index = self.sourceModel().index(source_row, 0, source_parent)
+        item_text = index.data(Qt.DisplayRole) or ""
+        item_text_lower = item_text.lower()
+
+        # Each needle must be present in the text
+        for needle in self._needles:
+            needle = needle.lower()
+            if needle not in item_text_lower:
+                return False
+        return True
+
+class QuickOpenDialog(QDialog):
+    """
+    A generic quick-open dialog for filtering and selecting from a list of items, each a dict
+    with at least a 'name' key.
+
+    Subclasses should override on_item_selected(item_dict) to handle the chosen item.
+    """
+    def __init__(self, parent, items, title="Quick Open"):
+        super().__init__(parent)
+        self.setWindowFlags(Qt.Dialog | Qt.FramelessWindowHint)
+        self.setWindowModality(Qt.ApplicationModal)
+
+        self.setWindowTitle(title)
+        self.resize(400, 400)
+
+        layout = QVBoxLayout(self)
+        self._filter_edit = QLineEdit(self)
+        self._filter_edit.setPlaceholderText("Type to filter...")
+        layout.addWidget(self._filter_edit)
+
+        self._list_view = QListView(self)
+        self._list_view.setSelectionMode(QAbstractItemView.SingleSelection)
+        layout.addWidget(self._list_view)
+
+        self._items = items
+        self._item_model = QStandardItemModel(self)
+        self._proxy_model = MultiNeedleFilterProxyModel(self)
+        self._proxy_model.setSourceModel(self._item_model)
+        self._list_view.setModel(self._proxy_model)
+
+        # Populate the model with items
+        self._populate_model()
+
+        # Ensure we select the top item whenever the filter results change
+        self._proxy_model.layoutChanged.connect(self._select_top_item_if_available)
+
+        # Connect signals
+        self._filter_edit.textChanged.connect(self._proxy_model.setFilterString)
+        self._list_view.doubleClicked.connect(self._on_item_double_clicked)
+
+        # Attempt to select top item immediately
+        self._select_top_item_if_available()
+
+    def _populate_model(self):
+        for item_dict in self._items:
+            name = item_dict.get("name", "")
+            item = QStandardItem(name)
+            # Store the entire dict in UserRole
+            item.setData(item_dict, Qt.UserRole)
+            self._item_model.appendRow(item)
+
+    def _on_item_double_clicked(self, proxy_index: QModelIndex):
+        source_index = self._proxy_model.mapToSource(proxy_index)
+        item = self._item_model.itemFromIndex(source_index)
+        item_dict = item.data(Qt.UserRole)
+        self.on_item_selected(item_dict)
+        self.accept()
+
+    def _select_top_item_if_available(self):
+        """Select the top item if it exists, otherwise clear selection."""
+        count = self._proxy_model.rowCount()
+        if count > 0:
+            top_index = self._proxy_model.index(0, 0)
+            self._list_view.setCurrentIndex(top_index)
+        else:
+            self._list_view.clearSelection()
+
+    def on_item_selected(self, item_dict: dict):
+        """
+        Override this in subclasses to define what happens when an item is chosen.
+        """
+        raise NotImplementedError("Subclasses must implement on_item_selected()")
+
+    def keyPressEvent(self, event):
+        """Handle Enter for selection and Up/Down wrap-around navigation."""
+        key = event.key()
+        count = self._proxy_model.rowCount()
+
+        # If there are no matches, ignore arrow and page navigation
+        if count == 0:
+            if key in (
+                Qt.Key_Up, Qt.Key_Down, Qt.Key_PageUp, Qt.Key_PageDown,
+                Qt.Key_Home, Qt.Key_End
+            ):
+                return
+
+        if key in (Qt.Key_Return, Qt.Key_Enter):
+            current_index = self._list_view.currentIndex()
+            if current_index.isValid():
+                proxy_index = current_index
+            else:
+                # If nothing is selected, fall back to top item if available
+                proxy_index = self._proxy_model.index(0, 0) if count > 0 else None
+
+            if proxy_index is not None and proxy_index.isValid():
+                source_index = self._proxy_model.mapToSource(proxy_index)
+                item = self._item_model.itemFromIndex(source_index)
+                item_dict = item.data(Qt.UserRole)
+                self.on_item_selected(item_dict)
+            self.accept()
+
+        elif key == Qt.Key_Up:
+            if count > 0:
+                current_index = self._list_view.currentIndex()
+                if current_index.isValid():
+                    row = current_index.row()
+                    if row <= 0:
+                        # wrap to last
+                        self._list_view.setCurrentIndex(
+                            self._proxy_model.index(count - 1, 0)
+                        )
+                    else:
+                        self._list_view.setCurrentIndex(
+                            self._proxy_model.index(row - 1, 0)
+                        )
+                else:
+                    # If nothing is selected, go to last
+                    self._list_view.setCurrentIndex(
+                        self._proxy_model.index(count - 1, 0)
+                    )
+            return
+
+        elif key == Qt.Key_Down:
+            if count > 0:
+                current_index = self._list_view.currentIndex()
+                if current_index.isValid():
+                    row = current_index.row()
+                    if row >= count - 1:
+                        # wrap to first
+                        self._list_view.setCurrentIndex(
+                            self._proxy_model.index(0, 0)
+                        )
+                    else:
+                        self._list_view.setCurrentIndex(
+                            self._proxy_model.index(row + 1, 0)
+                        )
+                else:
+                    # If nothing is selected, go to first
+                    self._list_view.setCurrentIndex(
+                        self._proxy_model.index(0, 0)
+                    )
+            return
+
+        elif key in (Qt.Key_PageUp, Qt.Key_PageDown, Qt.Key_Home, Qt.Key_End):
+            # Let default navigation logic handle these keys
+            self._list_view.setFocus()
+            QApplication.sendEvent(self._list_view, event)
+            return
+
+        else:
+            super().keyPressEvent(event)

pyqt_code_editor/widgets/quick_open_file_dialog.py

@@ -0,0 +1,32 @@
+import os
+import logging
+from . import QuickOpenDialog
+logger = logging.getLogger(__name__)
+
+
+class QuickOpenFileDialog(QuickOpenDialog):
+    """
+    Specialized dialog that handles quickly opening files.
+    Collects files in a given root_path, strips common prefix,
+    and calls open_file_callback on selection.
+    """
+    def __init__(self, parent, file_list, open_file_callback):
+        self.open_file_callback = open_file_callback
+        items = []
+        if file_list:
+            common_prefix = os.path.commonpath(file_list)
+            for full_path in file_list:
+                relative_path = os.path.relpath(full_path, common_prefix)
+                items.append({
+                    "name": relative_path,
+                    "full_path": full_path,
+                })
+        else:
+            logger.warning('no files to show')
+        super().__init__(parent, items, title="Quick Open File")
+
+    def on_item_selected(self, item_dict: dict):
+        """Opens the file at item_dict['full_path'] and closes the dialog."""
+        full_path = item_dict.get("full_path", None)
+        if full_path:
+            self.open_file_callback(full_path)

pyqt_code_editor/widgets/quick_symbol_dialog.py

@@ -0,0 +1,13 @@
+import os
+import logging
+from . import QuickOpenDialog
+logger = logging.getLogger(__name__)
+
+
+class QuickSymbolDialog(QuickOpenDialog):
+    def __init__(self, parent, items, jump_to_symbol_callback):
+        self.jump_to_symbol_callback = jump_to_symbol_callback
+        super().__init__(parent, items, title="Symbols")
+
+    def on_item_selected(self, item_dict: dict):
+        self.jump_to_symbol_callback(item_dict)

pyqt_code_editor/widgets/search_replace_frame.py

@@ -0,0 +1,128 @@
+from qtpy.QtWidgets import (
+    QFrame, QVBoxLayout, QHBoxLayout,
+    QLineEdit, QPushButton, QCheckBox, QLabel
+)
+from qtpy.QtCore import Qt, Signal
+from .. import settings
+
+    
+class SearchReplaceFrame(QFrame):
+    """
+    A small widget containing 'Find' and optionally 'Replace' fields,
+    plus checkboxes and buttons for next/prev/replace/replace all, etc.
+    Hides or shows replace-related UI depending on mode.
+    """
+    findNextRequested = Signal()
+    findPrevRequested = Signal()
+    replaceOneRequested = Signal()
+    replaceAllRequested = Signal()
+    
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        
+        self.setFrameShape(QFrame.StyledPanel)
+        self.setFrameShadow(QFrame.Raised)
+        editor = parent
+        if editor.code_editor_colors is not None:
+            self.setStyleSheet(f'''
+            QCheckBox,
+            QPushButton,
+            QLineEdit,    
+            QFrame {{
+                color: {editor.code_editor_colors['text']};
+                background-color: {editor.code_editor_colors['background']};
+                font: {settings.font_size}pt '{settings.font_family}';
+                padding: 8px;
+            }}
+            QCheckBox::indicator,
+            QPushButton,
+            QLineEdit,
+            QFrame {{
+                border-color: {editor.code_editor_colors['border']};
+                border-width: 1px;
+                border-style: solid;
+                border-radius: 4px;
+            }}
+            QCheckBox::indicator:checked {{
+                background-color: {editor.code_editor_colors['text']};
+            }}
+            QLabel {{
+                border: none;
+            }}
+        ''')
+        self.setWindowFlags(Qt.SubWindow | Qt.FramelessWindowHint)
+        
+        # Layout
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(5, 5, 5, 5)
+        
+        # Find row
+        findRow = QHBoxLayout()
+        
+        self.findLabel = QLabel("Find:", self)
+        self.matchCountLabel = QLabel("0 of 0", self)
+        self.findEdit = QLineEdit(self)
+        self.caseBox = QCheckBox("Aa", self)
+        self.caseBox.setToolTip("Case Sensitive")
+        self.regexBox = QCheckBox(".*", self)
+        self.regexBox.setToolTip("Use Regular Expressions")
+        self.wholeWordBox = QCheckBox("\\b", self)
+        self.wholeWordBox.setToolTip("Match Whole Word")
+        
+        self.findNextBtn = QPushButton("Next", self)
+        self.findPrevBtn = QPushButton("Prev", self)
+        
+        findRow.addWidget(self.findLabel)
+        findRow.addWidget(self.findEdit)
+        findRow.addWidget(self.matchCountLabel)
+        findRow.addWidget(self.caseBox)
+        findRow.addWidget(self.regexBox)
+        findRow.addWidget(self.wholeWordBox)
+        findRow.addWidget(self.findNextBtn)
+        findRow.addWidget(self.findPrevBtn)
+        
+        layout.addLayout(findRow)
+        
+        # Replace row
+        replaceRow = QHBoxLayout()
+        self.replaceLabel = QLabel("Replace:", self)
+        self.replaceEdit = QLineEdit(self)
+        self.replaceBtn = QPushButton("Replace", self)
+        self.replaceAllBtn = QPushButton("Replace All", self)
+        
+        replaceRow.addWidget(self.replaceLabel)
+        replaceRow.addWidget(self.replaceEdit)
+        replaceRow.addWidget(self.replaceBtn)
+        replaceRow.addWidget(self.replaceAllBtn)
+        
+        layout.addLayout(replaceRow)
+        
+        self.replaceRowWidget = replaceRow  # Keep reference to manage visibility
+        
+        # Connections
+        self.findNextBtn.clicked.connect(self.findNextRequested)
+        self.findPrevBtn.clicked.connect(self.findPrevRequested)
+        self.replaceBtn.clicked.connect(self.replaceOneRequested)
+        self.replaceAllBtn.clicked.connect(self.replaceAllRequested)
+        
+        # Default: searching only, so hide the "replace" row
+        self.showSearchOnly()
+    
+    def showSearchOnly(self):
+        # Hide replace UI
+        self.replaceLabel.setVisible(False)
+        self.replaceEdit.setVisible(False)
+        self.replaceBtn.setVisible(False)
+        self.replaceAllBtn.setVisible(False)
+        self.adjustSize()
+        self.resize(self.sizeHint())
+    
+    def showSearchReplace(self):
+        # Show replace UI
+        self.replaceLabel.setVisible(True)
+        self.replaceEdit.setVisible(True)
+        self.replaceBtn.setVisible(True)
+        self.replaceAllBtn.setVisible(True)
+        self.adjustSize()
+        self.resize(self.sizeHint())
+

pyqt_code_editor/widgets/tab_splitter.py

@@ -0,0 +1,22 @@
+from qtpy.QtWidgets import QSplitter
+
+
+class TabSplitter(QSplitter):
+    
+    def editors(self):
+        """Returns a list of all in this splitter and all sub splitters"""
+        editors = []
+        for i in range(self.count()):
+            editors += self.widget(i).editors()
+        return editors
+
+    def tab_widgets(self):
+        """Returns a list of all tab widgets in this splitter and all sub splitters"""
+        tab_widgets = []
+        for i in range(self.count()):
+            widget = self.widget(i)
+            if isinstance(widget, TabSplitter):
+                tab_widgets += widget.tab_widgets()
+            else:
+                tab_widgets.append(widget)
+        return tab_widgets