PrEditor 2.1.0__py3-none-any.whl

preditor/gui/errordialog.py

@@ -0,0 +1,69 @@
+from __future__ import absolute_import
+
+import os
+import traceback
+
+from Qt.QtCore import Qt
+from Qt.QtGui import QColor, QPixmap
+
+from .. import __file__ as pfile
+from ..utils.cute import QtPropertyInit
+from . import Dialog, loadUi
+
+
+class ErrorDialog(Dialog):
+    # These Qt Properties can be customized using style sheets.
+    errorMessageColor = QtPropertyInit('_errorMessageColor', QColor(Qt.GlobalColor.red))
+
+    def __init__(self, parent):
+        super(ErrorDialog, self).__init__(parent)
+
+        loadUi(__file__, self)
+
+        self.parent_ = parent
+        self.setWindowTitle('Error Occurred')
+        self.uiErrorLBL.setTextFormat(Qt.TextFormat.RichText)
+        self.uiIconLBL.setPixmap(
+            QPixmap(
+                os.path.join(
+                    os.path.dirname(pfile),
+                    'resource',
+                    'img',
+                    'warning-big.png',
+                )
+            ).scaledToHeight(64, Qt.TransformationMode.SmoothTransformation)
+        )
+
+        self.uiLoggerBTN.clicked.connect(self.show_logger)
+        self.uiIgnoreBTN.clicked.connect(self.close)
+
+    def setText(self, exc_info):
+        self.traceback_msg = "".join(traceback.format_exception(*exc_info))
+        msg = (
+            'The following error has occurred:<br>'
+            '<br><font color=%(color)s>%(text)s</font>'
+        )
+        self.uiErrorLBL.setText(
+            msg
+            % {
+                'text': self.traceback_msg.split('\n')[-2],
+                'color': self.errorMessageColor.name(),
+            }
+        )
+
+    def show_logger(self):
+        """Create/show the main PrEditor instance with the full traceback."""
+        from .. import launch
+
+        launch()
+        self.close()
+
+    @classmethod
+    def show_prompt(cls, *exc_info):
+        """Return False to this dialog should not be shown on an exception.
+
+        This is useful for applications like Nuke which uses exceptions to signal
+        traditionally non-exception worthy events, such as when a user cancels
+        an Open File dialog window.
+        """
+        return True

preditor/gui/find_files.py

@@ -0,0 +1,137 @@
+from __future__ import absolute_import, print_function
+
+from Qt.QtCore import Qt, Slot
+from Qt.QtGui import QIcon, QKeySequence
+from Qt.QtWidgets import QApplication, QShortcut, QWidget
+
+from .. import resourcePath
+from ..utils.text_search import RegexTextSearch, SimpleTextSearch
+from . import loadUi
+
+
+class FindFiles(QWidget):
+    def __init__(self, parent=None, managers=None, console=None):
+        super(FindFiles, self).__init__(parent=parent)
+        if managers is None:
+            managers = []
+        self.managers = managers
+        self.console = console
+        self.finder = None
+        self.match_files_count = 0
+
+        loadUi(__file__, self)
+
+        # Set the icons
+        self.uiCaseSensitiveBTN.setIcon(
+            QIcon(resourcePath("img/format-letter-case.svg"))
+        )
+        self.uiCloseBTN.setIcon(QIcon(resourcePath('img/close-thick.png')))
+        self.uiRegexBTN.setIcon(QIcon(resourcePath("img/regex.svg")))
+
+        # Create shortcuts
+        self.uiCloseSCT = QShortcut(
+            QKeySequence(Qt.Key.Key_Escape),
+            self,
+            context=Qt.ShortcutContext.WidgetWithChildrenShortcut,
+        )
+
+        self.uiCloseSCT.activated.connect(self.hide)
+
+        self.uiCaseSensitiveSCT = QShortcut(
+            QKeySequence(Qt.KeyboardModifier.AltModifier | Qt.Key.Key_C),
+            self,
+            context=Qt.ShortcutContext.WidgetWithChildrenShortcut,
+        )
+        self.uiCaseSensitiveSCT.activated.connect(self.uiCaseSensitiveBTN.toggle)
+
+        self.uiRegexSCT = QShortcut(
+            QKeySequence(Qt.KeyboardModifier.AltModifier | Qt.Key.Key_R),
+            self,
+            context=Qt.ShortcutContext.WidgetWithChildrenShortcut,
+        )
+        self.uiRegexSCT.activated.connect(self.uiRegexBTN.toggle)
+
+    def activate(self):
+        """Called to make this widget ready for the user to interact with."""
+        self.show()
+        self.uiFindTXT.setFocus()
+
+    @Slot()
+    def find(self):
+        find_text = self.uiFindTXT.text()
+        context = self.uiContextSPN.value()
+        # Create an instance of the TextSearch to use for this search
+        if self.uiRegexBTN.isChecked():
+            TextSearch = RegexTextSearch
+        else:
+            TextSearch = SimpleTextSearch
+        self.finder = TextSearch(
+            find_text, self.uiCaseSensitiveBTN.isChecked(), context=context
+        )
+        self.finder.callback_matching = self.insert_found_text
+        self.finder.callback_non_matching = self.insert_text
+
+        # Start fresh output line.
+        window = self.parent().window() if self.parent() else None
+        if window:
+            window.console().startPrompt("")
+
+        self.insert_text(self.finder.title())
+
+        self.match_files_count = 0
+        for manager in self.managers:
+            for (
+                editor,
+                group_name,
+                tab_name,
+                _group_index,
+                _tab_index,
+            ) in manager.all_widgets():
+                path = "/".join((group_name, tab_name))
+                self.find_in_editor(editor, path)
+
+        self.insert_text(
+            '\n{} matches in {} workboxes\n'.format(
+                self.finder.match_count, self.match_files_count
+            )
+        )
+
+        # If user has Auto-prompt chosen, do so now.
+        if window:
+            if window.uiAutoPromptCHK.isChecked():
+                window.console().startInputLine()
+
+    def find_in_editor(self, editor, path):
+        # Ensure the editor text is loaded and get its raw text
+        editor.__show__()
+        text = editor.__text__()
+        workbox_name = editor.__workbox_name__()
+
+        # Use the finder to check for matches
+        found = self.finder.search_text(text, path, workbox_name)
+        if found:
+            self.match_files_count += 1
+
+    def insert_found_text(self, text, workbox_id, line_num, tool_tip):
+        href = ', {}, {}'.format(workbox_id, line_num)
+        cursor = self.console.textCursor()
+        # Insert hyperlink
+        fmt = cursor.charFormat()
+        fmt.setAnchor(True)
+        fmt.setAnchorHref(href)
+        fmt.setFontUnderline(True)
+        fmt.setToolTip(tool_tip)
+        cursor.insertText(text, fmt)
+        # Show the updated text output
+        QApplication.instance().processEvents()
+
+    def insert_text(self, text):
+        cursor = self.console.textCursor()
+        fmt = cursor.charFormat()
+        fmt.setAnchor(False)
+        fmt.setAnchorHref('')
+        fmt.setFontUnderline(False)
+        fmt.setToolTip('')
+        cursor.insertText(text, fmt)
+        # Show the updated text output
+        QApplication.instance().processEvents()

preditor/gui/fuzzy_search/fuzzy_search.py

@@ -0,0 +1,97 @@
+from __future__ import absolute_import
+
+from functools import partial
+
+from Qt.QtCore import QModelIndex, QPoint, Qt, Signal
+from Qt.QtWidgets import QFrame, QLineEdit, QListView, QShortcut, QVBoxLayout
+
+from ..group_tab_widget.grouped_tab_models import GroupTabFuzzyFilterProxyModel
+
+
+class FuzzySearch(QFrame):
+    canceled = Signal("QModelIndex")
+    """Passes the original QModelIndex for the tab that was selected when the
+    widget was first shown. This lets you reset back to the orignal state."""
+    highlighted = Signal("QModelIndex")
+    """Emitted when the user navitages to the given index, but hasn't selected."""
+    selected = Signal("QModelIndex")
+    """Emitted when the user selects a item."""
+
+    def __init__(self, model, parent=None, **kwargs):
+        super(FuzzySearch, self).__init__(parent=parent, **kwargs)
+        self.y_offset = 100
+        self.setMinimumSize(400, 200)
+        self.uiCloseSCT = QShortcut(
+            Qt.Key.Key_Escape,
+            self,
+            context=Qt.ShortcutContext.WidgetWithChildrenShortcut,
+        )
+        self.uiCloseSCT.activated.connect(self._canceled)
+
+        self.uiUpSCT = QShortcut(
+            Qt.Key.Key_Up, self, context=Qt.ShortcutContext.WidgetWithChildrenShortcut
+        )
+        self.uiUpSCT.activated.connect(partial(self.increment_selection, -1))
+        self.uiDownSCT = QShortcut(
+            Qt.Key.Key_Down, self, context=Qt.ShortcutContext.WidgetWithChildrenShortcut
+        )
+        self.uiDownSCT.activated.connect(partial(self.increment_selection, 1))
+
+        lyt = QVBoxLayout(self)
+        self.uiLineEDIT = QLineEdit(parent=self)
+        self.uiLineEDIT.textChanged.connect(self.update_completer)
+        self.uiLineEDIT.returnPressed.connect(self.activated)
+        lyt.addWidget(self.uiLineEDIT)
+        self.uiResultsLIST = QListView(self)
+        self.uiResultsLIST.activated.connect(self.activated)
+        self.proxy_model = GroupTabFuzzyFilterProxyModel(self)
+        self.proxy_model.setSourceModel(model)
+        self.uiResultsLIST.setModel(self.proxy_model)
+        lyt.addWidget(self.uiResultsLIST)
+
+        self.original_model_index = model.original_model_index
+
+    def activated(self):
+        current = self.uiResultsLIST.currentIndex()
+        self.selected.emit(current)
+        self.hide()
+
+    def increment_selection(self, direction):
+        current = self.uiResultsLIST.currentIndex()
+        col = 0
+        row = 0
+        if current.isValid():
+            col = current.column()
+            row = current.row() + direction
+        new = self.uiResultsLIST.model().index(row, col)
+        self.uiResultsLIST.setCurrentIndex(new)
+        self.highlighted.emit(new)
+
+    def update_completer(self, wildcard):
+        if wildcard:
+            if not self.uiResultsLIST.currentIndex().isValid():
+                new = self.uiResultsLIST.model().index(0, 0)
+                self.uiResultsLIST.setCurrentIndex(new)
+        else:
+            self.uiResultsLIST.clearSelection()
+            self.uiResultsLIST.setCurrentIndex(QModelIndex())
+        self.proxy_model.setFuzzySearch(wildcard)
+        self.highlighted.emit(self.uiResultsLIST.currentIndex())
+
+    def _canceled(self):
+        # Restore the original tab as the user didn't choose the new tab
+        self.canceled.emit(self.original_model_index)
+        self.hide()
+
+    def reposition(self):
+        pgeo = self.parent().geometry()
+        geo = self.geometry()
+        center = QPoint(pgeo.width() // 2, 0)
+        geo.moveCenter(center)
+        geo.setY(self.y_offset)
+        self.setGeometry(geo)
+
+    def popup(self):
+        self.show()
+        self.reposition()
+        self.uiLineEDIT.setFocus(Qt.FocusReason.PopupFocusReason)