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

{blurdev → preditor}/gui/__init__.py

@@ -1,125 +1,84 @@
-##
-#   \namespace  blurdev.gui
-#
-#   \remarks    Contains gui components and interfaces
-#
-#   \author     beta@blur.com
-#   \author     Blur Studio
-#   \date       06/15/10
-#
-
-from __future__ import absolute_import
-from Qt.QtCore import Property
-
-from .window import Window  # noqa: F401
-from .dialog import Dialog  # noqa: F401
-from functools import partial
-
-
-def QtPropertyInit(name, default, callback=None, typ=None):
-    """Initializes a default Property value with a usable getter and setter.
-
-    You can optionally pass a function that will get called any time the property
-    is set. If using the same callback for multiple properties, you may want to
-    use the blurdev.decorators.singleShot decorator to prevent your function getting
-    called multiple times at once. This callback must accept the attribute name and
-    value being set.
-
-    Example:
-        class TestClass(QWidget):
-            def __init__(self, *args, **kwargs):
-                super(TestClass, self).__init__(*args, **kwargs)
-
-            stdoutColor = QtPropertyInit('_stdoutColor', QColor(0, 0, 255))
-            pyForegroundColor = QtPropertyInit('_pyForegroundColor', QColor(0, 0, 255))
-
-    Args:
-        name(str): The name of internal attribute to store to and lookup from.
-        default: The property's default value.  This will also define the Property type
-            if typ is not set.
-        callback(callable): If provided this function is called when the property is
-            set.
-        typ (class, optional): If not None this value is used to specify the type of
-            the Property. This is useful when you need to specify a property as python's
-            object but pass a default value of a given class.
-
-    Returns:
-        Property
-    """
-
-    def _getattrDefault(default, self, attrName):
-        try:
-            value = getattr(self, attrName)
-        except AttributeError:
-            setattr(self, attrName, default)
-            return default
-        return value
-
-    def _setattrCallback(callback, attrName, self, value):
-        setattr(self, attrName, value)
-        if callback:
-            callback(self, attrName, value)
-
-    ga = partial(_getattrDefault, default)
-    sa = partial(_setattrCallback, callback, name)
-    # Use the default value's class if typ is not provided.
-    if typ is None:
-        typ = default.__class__
-    return Property(typ, fget=(lambda s: ga(s, name)), fset=(lambda s, v: sa(s, v)))
-
-
-def loadUi(filename, widget, uiname=''):
-    """use's Qt's uic loader to load dynamic interafces onto the inputed widget
-
-    Args:
-        filename (str): The python filename. Its basename will be split off, and a
-            ui folder will be added. The file ext will be changed to .ui
-        widget (QWidget): The basewidget the ui file will be loaded onto.
-        uiname (str, optional): Used instead of the basename. This is useful if
-            filename is not the same as the ui file you want to load.
-    """
-    from Qt import QtCompat
-    import os.path
-
-    # first, inherit the palette of the parent
-    if widget.parent():
-        widget.setPalette(widget.parent().palette())
-
-    if not uiname:
-        uiname = os.path.basename(filename).split('.')[0]
-
-    QtCompat.loadUi(os.path.split(filename)[0] + '/ui/%s.ui' % uiname, widget)
-
-
-def connectLogger(
-    parent, start=True, sequence='F2', text='Show Logger', objName='uiShowLoggerACT'
-):
-    """Optionally starts the logger, and creates a QAction on the provided parent with
-        the provided keyboard shortcut to run it.
-
-    Args:
-        parent: The parent widget, normally a window
-        start (bool, optional): Start logging immediately. Defaults to True. Disable if
-            you don't want to redirect immediately.
-        sequence (str, optional): A string representing the keyboard shortcut associated
-            with the QAction. Defaults to 'F2'
-        text (str, optional): The display text for the QAction. Defaults to 'Show Logger'
-        objName (str, optional): Set the QAction's objectName to this value. Defaults to
-            'uiShowLoggerACT'
-
-    Returns:
-        QAction: The created QAction
-    """
-    import blurdev
-    from Qt.QtGui import QKeySequence
-    from Qt.QtWidgets import QAction
-
-    if start:
-        blurdev.core.logger(parent)
-    # Create shortcuts for launching the logger
-    action = QAction(text, parent)
-    action.setObjectName(objName)
-    action.triggered.connect(blurdev.core.showLogger)
-    action.setShortcut(QKeySequence(sequence))
-    parent.addAction(action)
-    return action
+from __future__ import absolute_import
+
+from functools import partial
+
+from Qt.QtCore import Property
+
+from .dialog import Dialog  # noqa: F401
+from .window import Window  # noqa: F401
+
+
+def QtPropertyInit(name, default, callback=None, typ=None):
+    """Initializes a default Property value with a usable getter and setter.
+
+    You can optionally pass a function that will get called any time the property
+    is set. If using the same callback for multiple properties, you may want to
+    use the preditor.decorators.singleShot decorator to prevent your function getting
+    called multiple times at once. This callback must accept the attribute name and
+    value being set.
+
+    Example:
+        class TestClass(QWidget):
+            def __init__(self, *args, **kwargs):
+                super(TestClass, self).__init__(*args, **kwargs)
+
+            stdoutColor = QtPropertyInit('_stdoutColor', QColor(0, 0, 255))
+            pyForegroundColor = QtPropertyInit('_pyForegroundColor', QColor(0, 0, 255))
+
+    Args:
+        name(str): The name of internal attribute to store to and lookup from.
+        default: The property's default value.  This will also define the Property type
+            if typ is not set.
+        callback(callable): If provided this function is called when the property is
+            set.
+        typ (class, optional): If not None this value is used to specify the type of
+            the Property. This is useful when you need to specify a property as python's
+            object but pass a default value of a given class.
+
+    Returns:
+        Property
+    """
+
+    def _getattrDefault(default, self, attrName):
+        try:
+            value = getattr(self, attrName)
+        except AttributeError:
+            setattr(self, attrName, default)
+            return default
+        return value
+
+    def _setattrCallback(callback, attrName, self, value):
+        setattr(self, attrName, value)
+        if callback:
+            callback(self, attrName, value)
+
+    ga = partial(_getattrDefault, default)
+    sa = partial(_setattrCallback, callback, name)
+    # Use the default value's class if typ is not provided.
+    if typ is None:
+        typ = default.__class__
+    return Property(typ, fget=(lambda s: ga(s, name)), fset=(lambda s, v: sa(s, v)))
+
+
+def loadUi(filename, widget, uiname=''):
+    """use's Qt's uic loader to load dynamic interafces onto the inputed widget
+
+    Args:
+        filename (str): The python filename. Its basename will be split off, and a
+            ui folder will be added. The file ext will be changed to .ui
+        widget (QWidget): The basewidget the ui file will be loaded onto.
+        uiname (str, optional): Used instead of the basename. This is useful if
+            filename is not the same as the ui file you want to load.
+    """
+    import os.path
+
+    from Qt import QtCompat
+
+    # first, inherit the palette of the parent
+    if widget.parent():
+        widget.setPalette(widget.parent().palette())
+
+    if not uiname:
+        uiname = os.path.basename(filename).split('.')[0]
+
+    QtCompat.loadUi(os.path.split(filename)[0] + '/ui/%s.ui' % uiname, widget)

preditor/gui/app.py

@@ -0,0 +1,159 @@
+from __future__ import absolute_import
+
+import logging
+import os
+
+import Qt
+from Qt.QtGui import QIcon
+from Qt.QtWidgets import QApplication, QDialog, QMainWindow, QSplashScreen
+
+from .. import DEFAULT_CORE_NAME, resourcePath, settings
+
+logger = logging.getLogger(__name__)
+
+
+class App(object):
+    """Used to create and configure the QApplication instance.
+
+    Args:
+        name (str, optional): Set the QApplication application name to this value.
+        args (list, optional): The arguments used to instantiate the QApplication
+            if one isn't already initialized.
+        app (QApplication, optional): An instance of a QApplication to use
+            instead of creating one.
+
+    Raises:
+        RuntimeError: If DISPLAY is not set when running on linux, or the
+            current application isn't a instance of QApplication(ie using a
+            QCoreApplication).
+    """
+
+    def __init__(self, name=None, args=None, app=None):
+        # Used to track if this instance had to create the QApplication or if it
+        # was already created
+        self.app_created = False
+        # If we made the QApplication, did we call exec_ already?
+        self.app_has_exec = False
+
+        if app is None:
+            app = QApplication.instance()
+
+        self.app = app
+
+        if not self.app:
+            # Check for headless environment's
+            if settings.OS_TYPE == 'Linux' and os.environ.get('DISPLAY') is None:
+                raise RuntimeError(
+                    'The PrEditor gui can not run in a headless environment.'
+                )
+
+            if args is None:
+                args = []
+            # create a new application
+            if self.app is None:
+                args.extend(self.dpi_awareness_args())
+                self.app = QApplication(args)
+                self.app_created = True
+                # If we are creating the application, configure it
+                self.configure_standalone()
+
+        if not isinstance(self.app, QApplication):
+            raise RuntimeError(
+                "PrEditor's gui can only be run using a QApplication instance."
+            )
+
+        if self.app and name:
+            # If a application name was passed, update the QApplication's
+            # application name.
+            self.app.setApplicationName(name)
+            self.set_app_id(name)
+
+    def configure_standalone(self):
+        """Update the QApplication for standalone running. Updates the icon and
+        sets its style to default_style_name."""
+        self.app.setWindowIcon(QIcon(resourcePath('img/preditor.png')))
+        self.app.setStyle(self.default_style_name())
+
+    @staticmethod
+    def default_style_name():
+        """The default style name used when setting up the QApplication.
+
+        In Qt4 this is Plastique, in Qt5 this is Fusion.
+        """
+
+        if Qt.IsPyQt4 or Qt.IsPySide:
+            return 'Plastique'
+        return 'Fusion'
+
+    @classmethod
+    def dpi_awareness_args(cls):
+        """On windows sets dpiawareness platform flag to 0 to enable
+        per-monitor scaling support in Qt.
+
+        Returns:
+            args: Extend the arguments used to intialize the QApplication.
+        """
+        if settings.OS_TYPE == "Windows" and Qt.IsPyQt5:
+            # Make Qt automatically scale based on the monitor the window is
+            # currently located.
+            return ["--platform", "windows:dpiawareness=0"]
+        return []
+
+    @classmethod
+    def root_window(cls):
+        """Returns the currently active window. Attempts to find the top level
+        QMainWindow or QDialog for the current Qt application.
+        """
+        inst = QApplication.instance()
+        if inst:
+            root_window = inst.activeWindow()
+            # Ignore QSplashScreen's, they should never be considered the root window.
+            if isinstance(root_window, QSplashScreen):
+                root_window = None
+
+            # If the application does not have focus try to find A top level widget
+            # that doesn't have a parent and is a QMainWindow or QDialog
+            if root_window is None:
+                windows = []
+                dialogs = []
+                for w in inst.topLevelWidgets():
+                    if w.parent() is None:
+                        if isinstance(w, QMainWindow):
+                            windows.append(w)
+                        elif isinstance(w, QDialog):
+                            dialogs.append(w)
+                if windows:
+                    root_window = windows[0]
+                elif dialogs:
+                    root_window = dialogs[0]
+
+            # grab the root window
+            if root_window:
+                while root_window.parent():
+                    parent = root_window.parent()
+                    if isinstance(parent, QSplashScreen):
+                        return root_window
+                    else:
+                        root_window = parent
+        return root_window
+
+    @classmethod
+    def set_app_id(cls, app_id=DEFAULT_CORE_NAME):
+        if settings.OS_TYPE == "Windows":
+            # Set the app user model id here not in the window class so it doesn't
+            # try to set the app id for applications that already set the app id.
+            try:
+                from casement.app_id import AppId
+            except ImportError:
+                logger.debug(
+                    "Unable to configure taskbar grouping, use `pip install "
+                    "casement` to enable this."
+                )
+            else:
+                AppId.set_for_application(app_id)
+
+    def start(self):
+        """Exec's the QApplication if it hasn't already been started."""
+        if self.app_created and self.app and not self.app_has_exec:
+            self.app_has_exec = True
+            self.app.exec_()