PrEditor 0.0.0.dev1__py2.py3-none-any.whl → 0.1.0__py2.py3-none-any.whl

{blurdev → preditor}/gui/dialog.py

@@ -1,216 +1,200 @@
-##
-# 	\namespace	blurdev.gui.dialog
-#
-# 	\remarks	Defines the main Dialog instance for this system
-#
-# 	\author		beta@blur.com
-# 	\author		Blur Studio
-# 	\date		12/05/08
-#
-
-from __future__ import absolute_import
-from Qt.QtWidgets import QDialog
-from Qt.QtCore import Qt
-
-
-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:
-            import blurdev
-
-            cls._instance = cls(parent=parent)
-            # protect the memory
-            cls._instance.setAttribute(Qt.WA_DeleteOnClose, False)
-            # but make sure that if we reload the environment, everything gets deleted
-            # properly
-            blurdev.core.aboutToClearPaths.connect(cls._instance.shutdown)
-        return cls._instance
-
-    def __init__(
-        self, parent=None, flags=Qt.WindowMinMaxButtonsHint | Qt.WindowCloseButtonHint
-    ):
-        import blurdev
-
-        # if there is no root, create
-        if not parent:
-            parent = blurdev.core.rootWindow()
-
-        # 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
-        # If this value is set to True the dialog will listen for
-        # blurdev.core.aboutToClearPaths and call shutdown on the dialog.
-        self.aboutToClearPathsEnabled = True
-        # attempt to set the dialog icon
-        import os
-        import sys
-        from Qt.QtGui import QIcon
-
-        try:
-            path = blurdev.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)
-
-        # only disconnect here if deleting on close
-        if self.aboutToClearPathsEnabled and self.testAttribute(Qt.WA_DeleteOnClose):
-            import blurdev
-
-            try:
-                blurdev.core.aboutToClearPaths.disconnect(self.shutdown)
-            except TypeError:
-                pass
-
-    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 cute.functions import ensureWindowIsVisible
-
-            ensureWindowIsVisible(self)
-
-    def showEvent(self, event):
-        # listen for aboutToClearPaths signal if requested
-        # but only connect here if deleting on close
-        if self.aboutToClearPathsEnabled and self.testAttribute(Qt.WA_DeleteOnClose):
-            import blurdev
-
-            blurdev.core.aboutToClearPaths.connect(self.shutdown)
-        super(Dialog, self).showEvent(event)
-
-    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:
-            import blurdev
-
-            cls._instance = None
-            if this.aboutToClearPathsEnabled:
-                blurdev.core.aboutToClearPaths.disconnect(this.shutdown)
-            this.setAttribute(Qt.WA_DeleteOnClose, True)
-        try:
-            this.close()
-        except RuntimeError:
-            pass
-
-    @classmethod
-    def instanceShutdown(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
+from __future__ import absolute_import
+
+from Qt.QtCore import Qt
+from Qt.QtWidgets import QDialog
+
+from .. import core, relativePath, root_window
+
+
+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)
+            # but make sure that if we reload the environment, everything gets deleted
+            # properly
+            core.aboutToClearPaths.connect(cls._instance.shutdown)
+        return cls._instance
+
+    def __init__(
+        self, parent=None, flags=Qt.WindowMinMaxButtonsHint | Qt.WindowCloseButtonHint
+    ):
+        # if there is no root, create
+        if not parent:
+            parent = 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
+        # If this value is set to True the dialog will listen for
+        # core.aboutToClearPaths and call shutdown on the dialog.
+        self.aboutToClearPathsEnabled = 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)
+
+        # only disconnect here if deleting on close
+        if self.aboutToClearPathsEnabled and self.testAttribute(Qt.WA_DeleteOnClose):
+            try:
+                core.aboutToClearPaths.disconnect(self.shutdown)
+            except TypeError:
+                pass
+
+    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 showEvent(self, event):
+        # listen for aboutToClearPaths signal if requested
+        # but only connect here if deleting on close
+        if self.aboutToClearPathsEnabled and self.testAttribute(Qt.WA_DeleteOnClose):
+            core.aboutToClearPaths.connect(self.shutdown)
+        super(Dialog, self).showEvent(event)
+
+    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
+            if this.aboutToClearPathsEnabled:
+                core.aboutToClearPaths.disconnect(this.shutdown)
+            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