opencue-cuegui 1.13.6__py3-none-any.whl

cuegui/AbstractDialog.py

@@ -0,0 +1,86 @@
+#  Copyright Contributors to the OpenCue Project
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+
+"""Base class for dialog windows."""
+
+
+from __future__ import division
+from __future__ import print_function
+from __future__ import absolute_import
+from builtins import str
+
+from qtpy import QtCore
+from qtpy import QtWidgets
+
+
+class AbstractDialog(QtWidgets.QDialog):
+    """Base class for dialog windows."""
+
+    def __init__(self, parent=None):
+        QtWidgets.QDialog.__init__(self, parent)
+
+    @staticmethod
+    def _newCheckBoxSelectionMatrix(title, allowedOptions, checkedOptions, parent=None):
+        return CheckBoxSelectionMatrix(title, allowedOptions, checkedOptions, parent)
+
+    def _newDialogButtonBox(self, buttons, orientation=QtCore.Qt.Horizontal):
+        buttonBox = QtWidgets.QDialogButtonBox(buttons, orientation, self)
+        # pylint: disable=no-member
+        buttonBox.accepted.connect(self.accept)
+        buttonBox.rejected.connect(self.reject)
+        # pylint: enable=no-member
+        return buttonBox
+
+    def _addWidgetRow(self, *widgets):
+        __hlayout = QtWidgets.QHBoxLayout()
+        for widget in widgets:
+            __hlayout.addWidget(widget)
+        self.layout().addLayout(__hlayout)
+
+
+class CheckBoxSelectionMatrix(QtWidgets.QWidget):
+    """Widget for displaying a matrix of checkboxes."""
+
+    def __init__(self, title, allowedOptions, checkedOptions, parent=None):
+        QtWidgets.QWidget.__init__(self, parent)
+        layout = QtWidgets.QVBoxLayout(self)
+
+        self.__group = QtWidgets.QGroupBox(title, self)
+        self.__group_layout = QtWidgets.QGridLayout()
+
+        self.__checkBoxes = []
+        for index, item in enumerate(allowedOptions):
+            box = QtWidgets.QCheckBox(item, self.__group)
+            box.setChecked(item in checkedOptions)
+            self.__checkBoxes.append(box)
+            self.__group_layout.addWidget(box, index // 2, index % 2)
+
+        self.__group.setLayout(self.__group_layout)
+        layout.addWidget(self.__group)
+        layout.setContentsMargins(0,0,0,0)
+        layout.addStretch()
+
+    def checkedBoxes(self):
+        """Gets all checked boxes."""
+        return [cb for cb in self.__checkBoxes if cb.isChecked()]
+
+    def checkedOptions(self):
+        """Gets text value of all checked boxes."""
+        return [str(cb.text()) for cb in self.__checkBoxes if cb.isChecked()]
+
+    def checkBoxes(self, names):
+        """Sets checked state for checkboxes representing the named values."""
+        for box in self.__checkBoxes:
+            box.setChecked(str(box.text()) in names)

cuegui/AbstractDockWidget.py

@@ -0,0 +1,71 @@
+#  Copyright Contributors to the OpenCue Project
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+
+"""Base class for all CueGUI widgets.
+
+Extends QDockWidget to provide a standard setup."""
+
+
+from __future__ import absolute_import
+from __future__ import print_function
+from __future__ import division
+
+from qtpy import QtCore
+from qtpy import QtWidgets
+
+import cuegui.Plugins
+
+
+class AbstractDockWidget(cuegui.Plugins.Plugin, QtWidgets.QDockWidget):
+    """Base class for all CueGUI widgets.
+
+    Extends QDockWidget to provide a standard setup."""
+
+    closed = QtCore.Signal(object)
+    enabled = QtCore.Signal()
+
+    def __init__(self, parent, name, area = QtCore.Qt.LeftDockWidgetArea):
+        QtWidgets.QDockWidget.__init__(self, name, parent)
+        cuegui.Plugins.Plugin.__init__(self)
+
+        self.parent = parent
+
+        self.setAllowedAreas(QtCore.Qt.AllDockWidgetAreas)
+        self.setFeatures(
+            QtWidgets.QDockWidget.DockWidgetClosable | QtWidgets.QDockWidget.DockWidgetMovable)
+        self.setObjectName(name)
+        parent.addDockWidget(area, self)
+
+        # Setup main vertical layout
+        self.__layout = QtWidgets.QVBoxLayout()
+        self.__layout.setContentsMargins(0, 0, 0, 0)
+
+        # Required to get layout on DockWidget
+        self.setWidget(QtWidgets.QWidget())
+        self.widget().setLayout(self.__layout)
+
+    def closeEvent(self, event):
+        """Delete event and emit close signal"""
+        del event
+        self.closed.emit(self)
+
+    def showEvent(self, event):
+        """Delete event and emit enabled signal"""
+        del event
+        self.enabled.emit()
+
+    def layout(self):
+        """Returns the layout"""
+        return self.__layout

cuegui/AbstractGraphWidget.py

@@ -0,0 +1,126 @@
+#  Copyright Contributors to the OpenCue Project
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+
+"""Base class for CueGUI graph widgets."""
+
+from qtpy import QtCore
+from qtpy import QtWidgets
+
+from NodeGraphQtPy import NodeGraph
+from NodeGraphQtPy.errors import NodeRegistrationError
+from cuegui.nodegraph import CueLayerNode
+from cuegui import app
+
+
+class AbstractGraphWidget(QtWidgets.QWidget):
+    """Base class for CueGUI graph widgets"""
+
+    def __init__(self, parent=None):
+        super(AbstractGraphWidget, self).__init__(parent=parent)
+        self.graph = NodeGraph()
+        self.setupUI()
+
+        self.timer = QtCore.QTimer(self)
+        # pylint: disable=no-member
+        self.timer.timeout.connect(self.update)
+        self.timer.setInterval(1000 * 20)
+
+        self.graph.node_selection_changed.connect(self.onNodeSelectionChanged)
+        app().quit.connect(self.timer.stop)
+
+    def setupUI(self):
+        """Setup the UI."""
+        try:
+            self.graph.register_node(CueLayerNode)
+        except NodeRegistrationError:
+            pass
+        self.graph.viewer().installEventFilter(self)
+
+        layout = QtWidgets.QVBoxLayout(self)
+        layout.addWidget(self.graph.viewer())
+
+    def onNodeSelectionChanged(self):
+        """Slot run when a node is selected.
+
+        Updates the nodes to ensure they're visualising current data.
+        Can be used to notify other widgets of object selection.
+        """
+        self.update()
+
+    def handleSelectObjects(self, rpcObjects):
+        """Select incoming objects in graph.
+        """
+        received = [o.name() for o in rpcObjects]
+        current = [rpcObject.name() for rpcObject in self.selectedObjects()]
+        if received == current:
+            #  prevent recursing
+            return
+
+        for node in self.graph.all_nodes():
+            node.set_selected(False)
+        for rpcObject in rpcObjects:
+            node = self.graph.get_node_by_name(rpcObject.name())
+            node.set_selected(True)
+
+    def selectedObjects(self):
+        """Return the selected nodes rpcObjects in the graph.
+        :rtype: [opencue.wrappers.layer.Layer]
+        :return: List of selected layers
+        """
+        rpcObjects = [n.rpcObject for n in self.graph.selected_nodes()]
+        return rpcObjects
+
+    def eventFilter(self, target, event):
+        """Override eventFilter
+
+        Centre nodes in graph viewer on 'F' key press.
+
+        @param target: widget event occurred on
+        @type  target: QtWidgets.QWidget
+        @param event: Qt event
+        @type  event: QtCore.QEvent
+        """
+        if hasattr(self, "graph"):
+            viewer = self.graph.viewer()
+            if target == viewer:
+                if event.type() == QtCore.QEvent.KeyPress:
+                    if event.key() == QtCore.Qt.Key_F:
+                        self.graph.center_on()
+                    if event.key() == QtCore.Qt.Key_L:
+                        self.graph.auto_layout_nodes()
+
+        return super(AbstractGraphWidget, self).eventFilter(target, event)
+
+    def clearGraph(self):
+        """Clear all nodes from the graph
+        """
+        for node in self.graph.all_nodes():
+            for port in node.output_ports():
+                port.unlock()
+            for port in node.input_ports():
+                port.unlock()
+        self.graph.clear_session()
+
+    def createGraph(self):
+        """Create the graph to visualise OpenCue objects
+        """
+        raise NotImplementedError()
+
+    def update(self):
+        """Update nodes with latest data
+
+        This is run every 20 seconds by the timer.
+        """
+        raise NotImplementedError()