PrEditor 1.0.0__py3-none-any.whl

preditor/gui/dialog.py

@@ -0,0 +1,178 @@
+from __future__ import absolute_import
+
+from Qt.QtCore import Qt
+from Qt.QtWidgets import QDialog
+
+from .. import config, relativePath
+
+
+class Dialog(QDialog):
+    _instance = None
+
+    @classmethod
+    def instance(cls, parent=None):
+        """If you only want to have one instance of a dialog, use this method instead
+        of creating a new dialog. It will only create a new instance of the class if
+        the class variable _instance is none.
+
+        Args:
+            parent (QWidget, optional):The parent widget
+
+        Returns:
+            Dialog:
+        """
+        if not cls._instance:
+            cls._instance = cls(parent=parent)
+            # protect the memory
+            cls._instance.setAttribute(Qt.WA_DeleteOnClose, False)
+        return cls._instance
+
+    def __init__(
+        self, parent=None, flags=Qt.WindowMinMaxButtonsHint | Qt.WindowCloseButtonHint
+    ):
+        # if there is no root, create
+        if not parent:
+            parent = config.root_window()
+
+        # create a QDialog
+        if flags:
+            QDialog.__init__(self, parent, flags)
+        else:
+            QDialog.__init__(self, parent)
+
+        # INFO
+        #
+        # As far as we can tell, the purpose for this class is keeping live
+        # references to the subclasses so they don't get garbage collected, all while
+        # getting around having to actively maintain a list of running dialogs.
+        #
+        # Generally, setting WA_DeleteOnClose to False, and keeping the _instance
+        # variable around will do the trick for pseudo-singleton dialogs. (created with
+        # instance=True)
+        #
+        # However, for non-instanced dialogs where multiples are allowed, deleteOnClose
+        # is set to True and no _instance variable is set.  Because there are no live
+        # references to the dialog, it is closed and garbage collected almost
+        # immediately in certain programs (xsi, maya).
+        #
+        # The current workaround is to manually set WA_DeleteOnClose to False, however
+        # this causes any subclasses to stick around in memory even when the
+        # window/dialog is closed. So you also have to manually set WA_DeleteOnClose to
+        # True in the sub-classed .closeEvent() method before you call super()
+        #
+        # It is completely possible to write some code that would automatically handle
+        # this, and it is CERTAINLY something we can/will be doing in the future, but
+        # for now we're not quite sure how that would affect the production tools.
+        # Technically this is a problem, but there are currently no consequences from an
+        # artist standpoint because we have more than enough memory to hold all those
+        # dead dialogs
+
+        # set the delete attribute to clean up the window once it is closed
+        self.setAttribute(Qt.WA_DeleteOnClose, True)
+
+        # set this property to true to properly handle tracking events to control
+        # keyboard overrides
+        self.setMouseTracking(True)
+
+        # If this value is set to False calling setGeometry on this dialog will not
+        # adjust the geometry to ensure the dialog is on a valid screen.
+        self.checkScreenGeo = True
+        # attempt to set the dialog icon
+        import os
+        import sys
+
+        from Qt.QtGui import QIcon
+
+        try:
+            path = relativePath(
+                os.path.abspath(sys.modules[self.__class__.__module__].__file__),
+                'img/icon.png',
+            )
+            if os.path.exists(path):
+                self.setWindowIcon(QIcon(path))
+        except (AttributeError, KeyError):
+            pass
+
+    def _shouldDisableAccelerators(self, old, now):
+        """Used to enable typing in DCC's that require it(Max 2018).
+
+        Args:
+            old (QWidget or None): The QWidget that lost focus.
+            new (QWidget or None): The QWidget that gained focus.
+
+        Returns:
+            bool: If accelerators should be disabled.
+        """
+        # By default we always want to disable accelerators.
+        return True
+
+    def closeEvent(self, event):
+        # ensure this object gets deleted
+        wwidget = None
+        if self.testAttribute(Qt.WA_DeleteOnClose):
+            # collect the win widget to uncache it
+            if self.parent() and self.parent().inherits('QWinWidget'):
+                wwidget = self.parent()
+
+        QDialog.closeEvent(self, event)
+
+        # uncache the win widget if necessary
+        if wwidget:
+            from .winwidget import WinWidget
+
+            WinWidget.uncache(wwidget)
+
+    def exec_(self):
+        # do not use the DeleteOnClose attribute when executing a dialog as often times
+        # a user will be accessing information from the dialog instance after it closes.
+        # This function properly transfers ownership of the dialog instance back to
+        # Python anyway
+
+        self.setAttribute(Qt.WA_DeleteOnClose, False)
+
+        # execute the dialog
+        return QDialog.exec_(self)
+
+    def setGeometry(self, *args):
+        """
+        Sets the dialog's geometry, It will also check if the geometry is visible on any
+        monitors. If it is not it will move the dialog so it is visible. This can be
+        disabled by setting self.checkScreenGeo to False
+        """
+        super(Dialog, self).setGeometry(*args)
+        if self.checkScreenGeo:
+            from ..utils.cute import ensureWindowIsVisible
+
+            ensureWindowIsVisible(self)
+
+    def shutdown(self):
+        # use a @classmethod to make inheritance magically work
+        self._shutdown(self)
+
+    @classmethod
+    def _shutdown(cls, this):
+        """
+        If this item is the class instance properly close it and remove it from memory
+        so it can be recreated.
+        """
+        # allow the global instance to be cleared
+        if this == cls._instance:
+            cls._instance = None
+            this.setAttribute(Qt.WA_DeleteOnClose, True)
+        try:
+            this.close()
+        except RuntimeError:
+            pass
+
+    @classmethod
+    def instance_shutdown(cls):
+        """Call shutdown on this class instance only if the class was instantiated.
+
+        Returns:
+            bool: if cls.instance().shutdown() needed to be called.
+        """
+        instance = cls._instance
+        if instance:
+            instance.shutdown()
+            return True
+        return False

preditor/gui/drag_tab_bar.py

@@ -0,0 +1,190 @@
+from __future__ import absolute_import
+
+from Qt.QtCore import QByteArray, QMimeData, QPoint, QRect, Qt
+from Qt.QtGui import QCursor, QDrag, QPixmap, QRegion
+from Qt.QtWidgets import QInputDialog, QMenu, QTabBar
+
+
+class DragTabBar(QTabBar):
+    """A QTabBar that allows you to drag and drop its tabs to other DragTabBar's
+    while still allowing you to move tabs normally.
+
+    In most cases you should use `install_tab_widget` to create and add this TabBar
+    to a QTabWidget. It takes care of enabling usability features of QTabWidget's.
+
+    Args:
+        mime_type (str, optional): Only accepts dropped tabs that implement this
+            Mime Type. Tabs dragged off of this TabBar will have this Mime Type
+            implemented.
+
+    Based on code by ARussel: https://forum.qt.io/post/420469
+    """
+
+    def __init__(self, parent=None, mime_type='DragTabBar'):
+        super(DragTabBar, self).__init__(parent=parent)
+        self.setAcceptDrops(True)
+        self.setMouseTracking(True)
+        self._mime_data = None
+        self._context_menu_tab = -1
+        self.mime_type = mime_type
+
+    def mouseMoveEvent(self, event):  # noqa: N802
+
+        if not self._mime_data:
+            return super(DragTabBar, self).mouseMoveEvent(event)
+
+        # Check if the mouse has moved outside of the widget, if not, let
+        # the QTabBar handle the internal tab movement.
+        event_pos = event.pos()
+        global_pos = self.mapToGlobal(event_pos)
+        bar_geo = QRect(self.mapToGlobal(self.pos()), self.size())
+        inside = bar_geo.contains(global_pos)
+        if inside:
+            return super(DragTabBar, self).mouseMoveEvent(event)
+
+        # The user has moved the tab outside of the QTabBar, remove the tab from
+        # this tab bar and store it in the MimeData, initiating a drag event.
+        widget = self._mime_data.property('widget')
+        tab_index = self.parentWidget().indexOf(widget)
+        self.parentWidget().removeTab(tab_index)
+        pos_in_tab = self.mapFromGlobal(global_pos)
+        drag = QDrag(self)
+        drag.setMimeData(self._mime_data)
+        drag.setPixmap(self._mime_data.imageData())
+        drag.setHotSpot(event_pos - pos_in_tab)
+        cursor = QCursor(Qt.OpenHandCursor)
+        drag.setDragCursor(cursor.pixmap(), Qt.MoveAction)
+        action = drag.exec_(Qt.MoveAction)
+        # If the user didn't successfully add this to a new tab widget, restore
+        # the tab to the original location.
+        if action == Qt.IgnoreAction:
+            original_tab_index = self._mime_data.property('original_tab_index')
+            self.parentWidget().insertTab(
+                original_tab_index, widget, self._mime_data.text()
+            )
+
+        self._mime_data = None
+
+    def mousePressEvent(self, event):  # noqa: N802
+        if event.button() == Qt.LeftButton and not self._mime_data:
+            tab_index = self.tabAt(event.pos())
+
+            # While we don't remove the tab on mouse press, capture its tab image
+            # and attach it to the mouse. This also stores info needed to handle
+            # moving the tab to a new QTabWidget, and undoing the move if the
+            # user cancels the drop.
+            tab_rect = self.tabRect(tab_index)
+            pixmap = QPixmap(tab_rect.size())
+            self.render(pixmap, QPoint(), QRegion(tab_rect))
+
+            self._mime_data = QMimeData()
+            self._mime_data.setData(self.mime_type, QByteArray())
+            self._mime_data.setText(self.tabText(tab_index))
+            self._mime_data.setProperty('original_tab_index', tab_index)
+            self._mime_data.setImageData(pixmap)
+            widget = self.parentWidget().widget(tab_index)
+            self._mime_data.setProperty('widget', widget)
+
+            # By default if there are no tabs, the tab bar is hidden. This
+            # prevents users from re-adding tabs to the tab bar as only it
+            # accepts the tab drops. This preserves the tab bar height
+            # after it was drawn with a tab so it should automatically stay
+            # the same visual height.
+            if not self.minimumHeight():
+                self.setMinimumHeight(self.height())
+
+        super(DragTabBar, self).mousePressEvent(event)
+
+    def mouseReleaseEvent(self, event):  # noqa: N802
+        self._mime_data = None
+        super(DragTabBar, self).mouseReleaseEvent(event)
+
+    def dragEnterEvent(self, event):  # noqa: N802
+        # if event.mimeData().hasFormat(self.mime_type):
+        event.accept()
+
+    def dragLeaveEvent(self, event):  # noqa: N802
+        event.accept()
+
+    def dragMoveEvent(self, event):  # noqa: N802
+        # If this is not a tab of the same mime type, make the tab under the mouse
+        # the current tab so users can easily drop inside that tab.
+        if not event.mimeData().hasFormat(self.mime_type):
+            event.accept()
+            tab_index = self.tabAt(event.pos())
+            if tab_index == -1:
+                tab_index = self.count() - 1
+            if self.currentIndex() != tab_index:
+                self.setCurrentIndex(tab_index)
+
+    def dropEvent(self, event):  # noqa: N802
+        if not event.mimeData().hasFormat(self.mime_type):
+            return
+        if event.source().parentWidget() == self:
+            return
+
+        event.setDropAction(Qt.MoveAction)
+        event.accept()
+        counter = self.count()
+
+        mime_data = event.mimeData()
+        if counter == 0:
+            self.parent().addTab(mime_data.property('widget'), mime_data.text())
+        else:
+            self.parent().insertTab(
+                counter + 1, mime_data.property('widget'), mime_data.text()
+            )
+
+    def rename_tab(self):
+        """Used by the tab_menu to rename the tab at index `_context_menu_tab`."""
+        if self._context_menu_tab != -1:
+            current = self.tabText(self._context_menu_tab)
+            msg = 'Rename the {} tab to:'.format(current)
+            name, success = QInputDialog.getText(self, 'Rename Tab', msg, text=current)
+            if success:
+                self.setTabText(self._context_menu_tab, name)
+
+    def tab_menu(self, pos, popup=True):
+        """Creates the custom context menu for the tab bar. To customize the menu
+        call super setting `popup=False`. This will return the menu for
+        customization and you will then need to call popup on the menu.
+
+        This method sets the tab index the user right clicked on in the variable
+        `_context_menu_tab`. This can be used in the triggered QAction methods."""
+
+        self._context_menu_tab = self.tabAt(pos)
+        if self._context_menu_tab == -1:
+            return
+        menu = QMenu(self)
+        act = menu.addAction('Rename')
+        act.triggered.connect(self.rename_tab)
+
+        if popup:
+            menu.popup(self.mapToGlobal(pos))
+
+        return menu
+
+    @classmethod
+    def install_tab_widget(cls, tab_widget, mime_type='DragTabBar', menu=True):
+        """Creates and returns a instance of DragTabBar and installs it on the
+        QTabWidget. This enables movable tabs, and enables document mode.
+        Document mode makes the tab bar expand to the size of the QTabWidget so
+        drag drop operations are more intuitive.
+
+        Args:
+            tab_widget (QTabWidget): The QTabWidget to install the tab bar on.
+            mime_data (str, optional): This TabBar will only accept tab drop
+                operations with this mime type.
+            menu (bool, optional): Install a custom context menu on the bar bar.
+                Override `tab_menu` to customize the menu.
+        """
+        bar = cls(tab_widget, mime_type=mime_type)
+        tab_widget.setTabBar(bar)
+        tab_widget.setMovable(True)
+        tab_widget.setDocumentMode(True)
+
+        if menu:
+            bar.setContextMenuPolicy(Qt.CustomContextMenu)
+            bar.customContextMenuRequested.connect(bar.tab_menu)
+
+        return bar

preditor/gui/editor_chooser.py

@@ -0,0 +1,57 @@
+from __future__ import absolute_import
+
+from Qt.QtCore import Slot
+from Qt.QtGui import QIcon
+from Qt.QtWidgets import QWidget
+
+from .. import plugins, resourcePath
+from ..gui import loadUi
+
+
+class EditorChooser(QWidget):
+    """A widget that lets the user choose from a a list of available editors."""
+
+    def __init__(self, parent=None, editor_name=None):
+        super(EditorChooser, self).__init__(parent=parent)
+        loadUi(__file__, self)
+        icon = QIcon(resourcePath('img/warning-big.png'))
+        self.uiWarningIconLBL.setPixmap(icon.pixmap(icon.availableSizes()[0]))
+        if editor_name:
+            self.set_editor_name(editor_name)
+
+    def editor_name(self):
+        return self.uiWorkboxEditorDDL.currentText()
+
+    def set_editor_name(self, name):
+        index = self.uiWorkboxEditorDDL.findText(name)
+        if index == -1:
+            self.uiWorkboxEditorDDL.addItem(name)
+            index = self.uiWorkboxEditorDDL.findText(name)
+        self.uiWorkboxEditorDDL.setCurrentIndex(index)
+
+    @Slot()
+    def refresh(self):
+        warning = "Choose an editor to enable Workboxs."
+        editor_name = self.editor_name()
+        if editor_name:
+            _, editor = plugins.editor(editor_name)
+            warning = editor._warning_text
+        self.uiWarningIconLBL.setVisible(bool(warning))
+        self.uiWarningTextLBL.setVisible(bool(warning))
+        self.uiWarningTextLBL.setText(warning)
+
+    def refresh_editors(self):
+        current = self.editor_name()
+        self.uiWorkboxEditorDDL.blockSignals(True)
+        self.uiWorkboxEditorDDL.clear()
+        for name, _ in sorted(set(plugins.editors())):
+            self.uiWorkboxEditorDDL.addItem(name)
+
+        self.uiWorkboxEditorDDL.setCurrentIndex(
+            self.uiWorkboxEditorDDL.findText(current)
+        )
+        self.uiWorkboxEditorDDL.blockSignals(False)
+
+    def showEvent(self, event):  # noqa: N802
+        super(EditorChooser, self).showEvent(event)
+        self.refresh_editors()

preditor/gui/errordialog.py

@@ -0,0 +1,68 @@
+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 . import Dialog, QtPropertyInit, 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.RichText)
+        self.uiIconLBL.setPixmap(
+            QPixmap(
+                os.path.join(
+                    os.path.dirname(pfile),
+                    'resource',
+                    'img',
+                    'warning-big.png',
+                )
+            ).scaledToHeight(64, Qt.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,125 @@
+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_Escape), self, context=Qt.WidgetWithChildrenShortcut
+        )
+
+        self.uiCloseSCT.activated.connect(self.hide)
+
+        self.uiCaseSensitiveSCT = QShortcut(
+            QKeySequence(Qt.AltModifier | Qt.Key_C),
+            self,
+            context=Qt.WidgetWithChildrenShortcut,
+        )
+        self.uiCaseSensitiveSCT.activated.connect(self.uiCaseSensitiveBTN.toggle)
+
+        self.uiRegexSCT = QShortcut(
+            QKeySequence(Qt.AltModifier | Qt.Key_R),
+            self,
+            context=Qt.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
+
+        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))
+                workbox_id = '{},{}'.format(group_index, tab_index)
+                self.find_in_editor(editor, path, workbox_id)
+
+        self.insert_text(
+            '\n{} matches in {} workboxes\n'.format(
+                self.finder.match_count, self.match_files_count
+            )
+        )
+
+    def find_in_editor(self, editor, path, workbox_id):
+        # Ensure the editor text is loaded and get its raw text
+        editor.__show__()
+        text = editor.__text__()
+
+        # Use the finder to check for matches
+        found = self.finder.search_text(text, path, workbox_id)
+        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()