nodeeditor-qtpy 0.8.1__py3-none-any.whl

nodeeditor/node_editor_window.py

@@ -0,0 +1,448 @@
+# -*- coding: utf-8 -*-
+"""
+A module containing the Main Window class
+"""
+import os
+import orjson as json
+from orjson import OPT_INDENT_2, JSONDecodeError
+from qtpy.QtCore import QSize, QSettings, QPoint
+from qtpy.QtWidgets import QMainWindow, QLabel, QAction, QMessageBox, QFileDialog, QApplication, QMenu, QMenuBar
+from nodeeditor.node_editor_widget import NodeEditorWidget
+
+from typing import TYPE_CHECKING, List, Optional, Tuple, Any, cast
+
+
+if TYPE_CHECKING:
+    from nodeeditor.node_graphics_view import QDMGraphicsView
+    from nodeeditor.node_edge import Edge
+    from nodeeditor.node_socket import Socket
+
+
+class NodeEditorWindow(QMainWindow):
+    """The Main Window of NodeEditor.
+
+    Holds the file and edit menus, the actions behind them and the
+    :class:`~nodeeditor.node_editor_widget.NodeEditorWidget` that draws the graph.
+
+    :Instance Attributes:
+
+    - **name_company** - name of the company, used for permanent profile settings
+    - **name_product** - name of this App, used for permanent profile settings
+    """
+
+    NodeEditorWidget_class = NodeEditorWidget
+
+    """Class representing NodeEditor's Main Window"""
+
+    def __init__(self) -> None:
+        """
+        :Instance Attributes:
+
+        - **name_company** - name of the company, used for permanent profile settings
+        - **name_product** - name of this App, used for permanent profile settings
+        """
+        super().__init__()
+
+        self.name_company = 'Trigger'
+        self.name_product = 'NodeEditor'
+
+        self.initUI()
+
+    def initUI(self) -> None:
+        """Set up this ``QMainWindow``. Create :class:`~nodeeditor.node_editor_widget.NodeEditorWidget`, Actions and Menus"""
+        self.createActions()
+        self.createMenus()
+
+        # create node editor widget
+        self.nodeeditor = self.__class__.NodeEditorWidget_class(self)
+        self.nodeeditor.scene.addHasBeenModifiedListener(self.setTitle)
+        self.setCentralWidget(self.nodeeditor)
+
+        self.createStatusBar()
+
+        # set window properties
+        # self.setGeometry(200, 200, 800, 600)
+        self.setTitle()
+        self.show()
+
+    def sizeHint(self):
+        """The preferred size of the main window.
+
+        :return: the default window size
+        :rtype: ``QSize``
+        """
+        return QSize(800, 600)
+
+    def createStatusBar(self) -> None:
+        """Create Status bar and connect to `Graphics View` scenePosChanged event"""
+        self.statusBar().showMessage("")
+        self.status_mouse_pos = QLabel("")
+        self.statusBar().addPermanentWidget(self.status_mouse_pos)
+        self.nodeeditor.view.scenePosChanged.connect(self.onScenePosChanged)
+
+    # type: ignore[override]
+    def createActions(self) -> None:
+        """Create basic `File` and `Edit` actions"""
+        self.actNew = QAction('&New', self, shortcut='Ctrl+N',
+                              statusTip="Create new graph", triggered=self.onFileNew)
+        self.actOpen = QAction('&Open', self, shortcut='Ctrl+O',
+                               statusTip="Open file", triggered=self.onFileOpen)
+        self.actSave = QAction('&Save', self, shortcut='Ctrl+S',
+                               statusTip="Save file", triggered=self.onFileSave)
+        self.actSaveAs = QAction('Save &As...', self, shortcut='Ctrl+Shift+S',
+                                 statusTip="Save file as...", triggered=self.onFileSaveAs)
+        self.actExit = QAction('E&xit', self, shortcut='Ctrl+Q',
+                               statusTip="Exit application", triggered=self.close)
+
+        self.actUndo = QAction('&Undo', self, shortcut='Ctrl+Z',
+                               statusTip="Undo last operation", triggered=self.onEditUndo)
+        self.actRedo = QAction('&Redo', self, shortcut='Ctrl+Shift+Z',
+                               statusTip="Redo last operation", triggered=self.onEditRedo)
+        self.actCut = QAction('Cu&t', self, shortcut='Ctrl+X',
+                              statusTip="Cut to clipboard", triggered=self.onEditCut)
+        self.actCopy = QAction('&Copy', self, shortcut='Ctrl+C',
+                               statusTip="Copy to clipboard", triggered=self.onEditCopy)
+        self.actPaste = QAction('&Paste', self, shortcut='Ctrl+V',
+                                statusTip="Paste from clipboard", triggered=self.onEditPaste)
+        self.actDelete = QAction('&Delete', self, shortcut='Del',
+                                 statusTip="Delete selected items", triggered=self.onEditDelete)
+
+        self.actGroup = QAction('&Group selected', self, shortcut='G',
+                                statusTip="Group selected nodes", triggered=self.onGroupSelected)
+        self.actUngroup = QAction('&Ungroup', self, shortcut='U',
+                                  statusTip="Ungroup selected groups (keep nodes)", triggered=self.onUngroupSelected)
+        try:
+            self.actUngroup.setShortcuts(['U', 'Shift+G'])
+        except Exception:
+            pass
+        self.actCollapseGroup = QAction('&Collapse/Expand group', self, shortcut='C',
+                                        statusTip="Collapse/expand selected groups", triggered=self.onToggleCollapseSelected)
+
+    def createMenus(self) -> None:
+        """Create Menus for `File` and `Edit`"""
+        self.createFileMenu()
+        self.createEditMenu()
+
+    def createFileMenu(self) -> None:
+        """Create the `File` menu and fill it with the file actions"""
+        menubar: QMenuBar = self.menuBar()
+        self.fileMenu: QMenu = menubar.addMenu('&File')
+        self.fileMenu.addAction(self.actNew)
+        self.fileMenu.addSeparator()
+        self.fileMenu.addAction(self.actOpen)
+        self.fileMenu.addAction(self.actSave)
+        self.fileMenu.addAction(self.actSaveAs)
+        self.fileMenu.addSeparator()
+        self.fileMenu.addAction(self.actExit)
+
+    def createEditMenu(self) -> None:
+        """Create the `Edit` menu and fill it with the edit and grouping actions"""
+        menubar: QMenuBar = self.menuBar()
+        self.editMenu: QMenu = menubar.addMenu('&Edit')
+        self.editMenu.addAction(self.actUndo)
+        self.editMenu.addAction(self.actRedo)
+        self.editMenu.addSeparator()
+        self.editMenu.addAction(self.actCut)
+        self.editMenu.addAction(self.actCopy)
+        self.editMenu.addAction(self.actPaste)
+        self.editMenu.addSeparator()
+        self.editMenu.addAction(self.actDelete)
+        self.editMenu.addSeparator()
+        self.editMenu.addAction(self.actGroup)
+        self.editMenu.addAction(self.actUngroup)
+        self.editMenu.addAction(self.actCollapseGroup)
+
+    def setTitle(self) -> None:
+        """Function responsible for setting window title"""
+        title = "Node Editor - "
+        title += self.getCurrentNodeEditorWidget().getUserFriendlyFilename()
+
+        self.setWindowTitle(title)
+
+    def closeEvent(self, event) -> None:
+        """Handle close event. Ask before we loose work"""
+        if self.maybeSave():
+            event.accept()
+        else:
+            event.ignore()
+
+    def isModified(self) -> bool:
+        """Has current :class:`~nodeeditor.node_scene.Scene` been modified?
+
+        :return: ``True`` if current :class:`~nodeeditor.node_scene.Scene` has been modified
+        :rtype: ``bool``
+        """
+        nodeeditor = self.getCurrentNodeEditorWidget()
+        return nodeeditor.scene.isModified() if nodeeditor else False
+
+    def getCurrentNodeEditorWidget(self) -> NodeEditorWidget:
+        """get current :class:`~nodeeditor.node_editor_widget`
+
+        :return: get current :class:`~nodeeditor.node_editor_widget`
+        :rtype: :class:`~nodeeditor.node_editor_widget`
+        """
+        return cast(NodeEditorWidget, self.centralWidget())
+
+    def maybeSave(self) -> bool:
+        """If current `Scene` is modified, ask a dialog to save the changes. Used before
+        closing window / mdi child document
+
+        :return: ``True`` if we can continue in the `Close Event` and shutdown. ``False`` if we should cancel
+        :rtype: ``bool``
+        """
+        if not self.isModified():
+            return True
+
+        res = QMessageBox.warning(self, "About to loose your work?",
+                                  "The document has been modified.\n Do you want to save your changes?",
+                                  QMessageBox.StandardButton.Save | QMessageBox.StandardButton.Discard | QMessageBox.StandardButton.Cancel
+                                  )
+
+        if res == QMessageBox.StandardButton.Save:
+            return self.onFileSave()
+        elif res == QMessageBox.StandardButton.Cancel:
+            return False
+
+        return True
+
+    def onScenePosChanged(self, x: int, y: int) -> None:
+        """Handle event when cursor position changed on the `Scene`
+
+        :param x: new cursor x position
+        :type x:
+        :param y: new cursor y position
+        :type y:
+        """
+        self.status_mouse_pos.setText("Scene Pos: [%d, %d]" % (x, y))
+
+    def getFileDialogDirectory(self) -> str:
+        """Returns starting directory for ``QFileDialog`` file open/save"""
+        return ''
+
+    def getFileDialogFilter(self) -> str:
+        """Returns ``str`` standard file open/save filter for ``QFileDialog``"""
+        return 'Design (*.tds);;All Files (*)'
+
+    def onFileNew(self) -> None:
+        """Hande File New operation"""
+        if self.maybeSave():
+            self.getCurrentNodeEditorWidget().fileNew()
+            self.setTitle()
+
+    def onFileOpen(self) -> None:
+        """Handle File Open operation"""
+        if self.maybeSave():
+            fname, filter = QFileDialog.getOpenFileName(
+                self, 'Open graph from file', self.getFileDialogDirectory(), self.getFileDialogFilter())
+            if fname != '' and os.path.isfile(fname):
+                self.getCurrentNodeEditorWidget().fileLoad(fname)
+                self.setTitle()
+
+    def onFileSave(self):
+        """Handle File Save operation"""
+        current_nodeeditor = self.getCurrentNodeEditorWidget()
+        if current_nodeeditor is not None:
+            if not current_nodeeditor.isFilenameSet():
+                return self.onFileSaveAs()
+
+            current_nodeeditor.fileSave()
+            self.statusBar().showMessage("Successfully saved %s" %
+                                         current_nodeeditor.filename, 5000)
+
+            # support for MDI app
+            if hasattr(current_nodeeditor, "setTitle"):
+                current_nodeeditor.setTitle()
+            else:
+                self.setTitle()
+            return True
+
+    def onFileSaveAs(self) -> bool:
+        """Handle File Save As operation"""
+        current_nodeeditor = self.getCurrentNodeEditorWidget()
+        if current_nodeeditor is not None:
+            fname, filter = QFileDialog.getSaveFileName(
+                self, 'Save design to file', self.getFileDialogDirectory(), self.getFileDialogFilter())
+            if fname == '':
+                return False
+
+            self.onBeforeSaveAs(current_nodeeditor, fname)
+            current_nodeeditor.fileSave(fname)
+            self.statusBar().showMessage("Successfully saved as %s" %
+                                         current_nodeeditor.filename, 5000)
+
+            # support for MDI app
+            if hasattr(current_nodeeditor, "setTitle"):
+                current_nodeeditor.setTitle()
+            else:
+                self.setTitle()
+            return True
+
+    def onBeforeSaveAs(self, current_nodeeditor: 'NodeEditorWidget', filename: str) -> None:
+        """
+        Event triggered after choosing filename and before actual fileSave(). We are passing current_nodeeditor because
+        we will loose focus after asking with QFileDialog and therefore getCurrentNodeEditorWidget will return None
+        """
+        pass
+
+    def onEditUndo(self) -> None:
+        """Handle Edit Undo operation"""
+        if self.getCurrentNodeEditorWidget():
+            self.getCurrentNodeEditorWidget().scene.undo()
+
+    def onEditRedo(self) -> None:
+        """Handle Edit Redo operation"""
+        if self.getCurrentNodeEditorWidget():
+            self.getCurrentNodeEditorWidget().scene.redo()
+
+    def onEditDelete(self) -> None:
+        """Handle Delete Selected operation"""
+        if self.getCurrentNodeEditorWidget():
+            self.getCurrentNodeEditorWidget().scene.getView().deleteSelected()
+
+    def _groupingFocusInTextEdit(self) -> bool:
+        """Guard plain-letter group shortcuts so typing in node widgets still works."""
+        try:
+            from qtpy.QtWidgets import QLineEdit, QTextEdit, QPlainTextEdit
+            w = QApplication.focusWidget()
+            return isinstance(w, (QLineEdit, QTextEdit, QPlainTextEdit))
+        except Exception:
+            return False
+
+    def _selectedLogicNodes(self, scene):
+        nodes = []
+        try:
+            for item in list(scene.getSelectedItems()):
+                try:
+                    n = getattr(item, 'node', None)
+                    if n is not None and n not in nodes:
+                        nodes.append(n)
+                except Exception:
+                    continue
+        except Exception:
+            pass
+        return nodes
+
+    def _selectedGroups(self, scene):
+        try:
+            from nodeeditor.node_group import Group
+        except Exception:
+            return []
+        try:
+            return [it for it in list(scene.getSelectedItems()) if isinstance(it, Group)]
+        except Exception:
+            return []
+
+    def onGroupSelected(self) -> None:
+        """Group currently selected nodes (needs 2+). Shortcut G."""
+        if self._groupingFocusInTextEdit():
+            return
+        editor = self.getCurrentNodeEditorWidget()
+        if not editor:
+            return
+        scene = editor.scene
+        nodes = self._selectedLogicNodes(scene)
+        if len(nodes) < 2:
+            try:
+                self.statusBar().showMessage("Select 2+ nodes to group", 3000)
+            except Exception:
+                pass
+            return
+        try:
+            from nodeeditor.node_group import Group
+            group = Group(scene, title=f"Group ({len(nodes)} nodes)")
+            for node in nodes:
+                group.addNode(node)
+            group.updateBounds()
+            scene.history.storeHistory(f"Created group with {len(nodes)} nodes", setModified=True)
+        except Exception:
+            pass
+
+    def onUngroupSelected(self) -> None:
+        """Ungroup selected groups, keep nodes. Shortcut U / Shift+G."""
+        if self._groupingFocusInTextEdit():
+            return
+        editor = self.getCurrentNodeEditorWidget()
+        if not editor:
+            return
+        scene = editor.scene
+        groups = self._selectedGroups(scene)
+        if not groups:
+            return
+        for grp in list(groups):
+            try:
+                grp.ungroup()
+            except Exception:
+                continue
+        try:
+            scene.history.storeHistory("Ungrouped", setModified=True)
+        except Exception:
+            pass
+
+    def onToggleCollapseSelected(self) -> None:
+        """Collapse/expand selected groups. Shortcut C."""
+        if self._groupingFocusInTextEdit():
+            return
+        editor = self.getCurrentNodeEditorWidget()
+        if not editor:
+            return
+        scene = editor.scene
+        groups = self._selectedGroups(scene)
+        if not groups:
+            return
+        for grp in list(groups):
+            try:
+                grp.toggleCollapse()
+            except Exception:
+                continue
+        try:
+            scene.history.storeHistory("Toggled group collapse", setModified=True)
+        except Exception:
+            pass
+
+    def onEditCut(self) -> None:
+        """Handle Edit Cut to clipboard operation"""
+        if self.getCurrentNodeEditorWidget():
+            data = self.getCurrentNodeEditorWidget(
+            ).scene.clipboard.serializeSelected(delete=True)
+            str_data = json.dumps(data, option=OPT_INDENT_2).decode("utf-8")
+            QApplication.instance().clipboard().setText(str_data)
+
+    def onEditCopy(self) -> None:
+        """Handle Edit Copy to clipboard operation"""
+        if self.getCurrentNodeEditorWidget():
+            data = self.getCurrentNodeEditorWidget(
+            ).scene.clipboard.serializeSelected(delete=False)
+            str_data = json.dumps(data, option=OPT_INDENT_2).decode("utf-8")
+            QApplication.instance().clipboard().setText(str_data)
+
+    def onEditPaste(self):
+        """Handle Edit Paste from clipboard operation"""
+        if self.getCurrentNodeEditorWidget():
+            raw_data = QApplication.instance().clipboard().text()
+
+            try:
+                data = json.loads(raw_data)
+            except JSONDecodeError as e:
+                print("Pasting of not valid json data!", e)
+                return
+
+            # check if the json data are correct
+            if 'nodes' not in data:
+                print("JSON does not contain any nodes!")
+                return
+
+            return self.getCurrentNodeEditorWidget().scene.clipboard.deserializeFromClipboard(data)
+
+    def readSettings(self) -> None:
+        """Read the permanent profile settings for this app"""
+        settings = QSettings(self.name_company, self.name_product)
+        pos = settings.value('pos', QPoint(200, 200))
+        size = settings.value('size', QSize(400, 400))
+        self.move(pos)
+        self.resize(size)
+
+    def writeSettings(self) -> None:
+        """Write the permanent profile settings for this app"""
+        settings = QSettings(self.name_company, self.name_product)
+        settings.setValue('pos', self.pos())
+        settings.setValue('size', self.size())