class EDict(dict): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.stack = QUndoStack() def _realSet(self, key, val): super().__setitem__(key, val) def __setitem__(self, key, val): if key in self.keys(): self.stack.push(ModifyCommand(self, key, val)) else: self.stack.push(AppendCommand(self, key, val)) def undoText(self): return self.stack.undoText() def redoText(self): return self.stack.redoText() def undo(self): self.stack.undo() def redo(self): self.stack.redo()
class stackable: def __init__(self): self.stack = QUndoStack() def _myWrapper(self, func): def inner(thisDict, key, val): if key in thisDict.keys(): print('Overwriting Key: {}'.format(key)) self.stack.push(ModifyCommand(thisDict, key, val)) else: self.stack.push(AppendCommand(thisDict, key, val)) return inner def _delWrapper(self, func): def inner(dict, key): dict._realDelItem(key) return inner
class UndoableDict(PathDict): """ The UndoableDict class implements a PathDict-based class with undo/redo functionality based on QUndoStack. """ def __init__(self, *args, **kwargs): self.stack = QUndoStack() super().__init__(*args, **kwargs) # Public methods def __setitem__(self, key: str, val: Any) -> NoReturn: """Calls the undoable command to override PathDict assignment to self[key] implementation and pushes this command on the stack.""" if key in self: self.stack.push(_SetItemCommand(self, key, val)) else: self.stack.push(_AddItemCommand(self, key, val)) def setItemByPath(self, keys: list, value: Any) -> NoReturn: """Calls the undoable command to set a value in a nested object by key sequence and pushes this command on the stack.""" self.stack.push(_SetItemCommand(self, keys, value))
class NodeGraph(QtCore.QObject): def __init__(self, parent=None): super(NodeGraph, self).__init__(parent) self._model = NodeGraphModel() self._viewer = NodeViewer() self._undo_stack = QUndoStack(self) self._init_actions() self._wire_signals() def _wire_signals(self): self._viewer.moved_nodes.connect(self._on_nodes_moved) self._viewer.search_triggered.connect(self._on_search_triggered) self._viewer.connection_changed.connect(self._on_connection_changed) def _init_actions(self): # setup tab search shortcut. tab = QAction('Search Nodes', self) tab.setShortcut('tab') tab.triggered.connect(self._toggle_tab_search) self._viewer.addAction(tab) setup_actions(self) def _toggle_tab_search(self): """ toggle the tab search widget. """ self._viewer.tab_search_set_nodes(NodeVendor.names) self._viewer.tab_search_toggle() def _on_nodes_moved(self, node_data): """ called when selected nodes in the viewer has changed position. Args: node_data (dict): {<node_view>: <previous_pos>} """ self._undo_stack.beginMacro('moved nodes') for node_view, prev_pos in node_data.items(): node = self._model.nodes[node_view.id] self._undo_stack.push(NodeMovedCmd(node, node.pos(), prev_pos)) self._undo_stack.endMacro() def _on_search_triggered(self, node_type, pos): """ called when the tab search widget is triggered in the viewer. Args: node_type (str): node identifier. pos (tuple): x,y position for the node. """ self.create_node(node_type, pos=pos) def _on_connection_changed(self, disconnected, connected): """ called when a pipe connection has been changed in the viewer. Args: disconnected (list[list[widgets.port.PortItem]): pair list of port view items. connected (list[list[widgets.port.PortItem]]): pair list of port view items. """ if not (disconnected or connected): return label = 'connected node(s)' if connected else 'disconnected node(s)' ptypes = {'in': 'inputs', 'out': 'outputs'} self._undo_stack.beginMacro(label) for p1_view, p2_view in disconnected: node1 = self._model.nodes[p1_view.node.id] node2 = self._model.nodes[p2_view.node.id] port1 = getattr(node1, ptypes[p1_view.port_type])()[p1_view.name] port2 = getattr(node2, ptypes[p2_view.port_type])()[p2_view.name] port1.disconnect_from(port2) for p1_view, p2_view in connected: node1 = self._model.nodes[p1_view.node.id] node2 = self._model.nodes[p2_view.node.id] port1 = getattr(node1, ptypes[p1_view.port_type])()[p1_view.name] port2 = getattr(node2, ptypes[p2_view.port_type])()[p2_view.name] port1.connect_to(port2) self._undo_stack.endMacro() @property def model(self): """ Return the node graph model. Returns: NodeGraphModel: model object. """ return self._model def show(self): """ Show node graph viewer widget. """ self._viewer.show() def hide(self): """ Hide node graph viewer widget. """ self._viewer.hide() def close(self): """ Close node graph viewer widget. """ self._viewer.close() def viewer(self): """ Return the node graph viewer widget object. Returns: NodeGraphQt.widgets.viewer.NodeViewer: viewer widget. """ return self._viewer def scene(self): """ Return the scene object. Returns: NodeGraphQt.widgets.scene.NodeScene: node scene. """ return self._viewer.scene() def undo_stack(self): """ Returns the undo stack used in the node graph Returns: QUndoStack: undo stack. """ return self._undo_stack def begin_undo(self, name='undo'): """ Start of an undo block followed by a end_undo(). Args: name (str): name for the undo block. """ self._undo_stack.beginMacro(name) def end_undo(self): """ End of an undo block started by begin_undo(). """ self._undo_stack.endMacro() def context_menu(self): """ Returns a node graph context menu object. Returns: ContextMenu: node graph context menu object instance. """ return self._viewer.context_menu() def acyclic(self): """ Returns true if the current node graph is acyclic. Returns: bool: true if acyclic. """ return self._model.acyclic def set_acyclic(self, mode=True): """ Set the node graph to be acyclic or not. (default=True) Args: mode (bool): false to disable acyclic. """ self._model.acyclic = mode self._viewer.acyclic = mode def set_pipe_layout(self, layout='curved'): """ Set node graph pipes to be drawn straight or curved by default all pipes are set curved. (default='curved') Args: layout (str): 'straight' or 'curved' """ self._viewer.set_pipe_layout(layout) def fit_to_selection(self): """ Sets the zoom level to fit selected nodes. If no nodes are selected then all nodes in the graph will be framed. """ nodes = self.selected_nodes() or self.all_nodes() if not nodes: return self._viewer.zoom_to_nodes([n.view for n in nodes]) def reset_zoom(self): """ Reset the zoom level """ self._viewer.reset_zoom() def set_zoom(self, zoom=0): """ Set the zoom factor of the Node Graph the default is 0.0 Args: zoom (float): zoom factor max zoom out -0.9 max zoom in 2.0 """ self._viewer.set_zoom(zoom) def get_zoom(self): """ Get the current zoom level of the node graph. Returns: float: the current zoom level. """ return self._viewer.get_zoom() def center_on(self, nodes=None): """ Center the node graph on the given nodes or all nodes by default. Args: nodes (list[NodeGraphQt.Node]): a list of nodes. """ self._viewer.center_selection(nodes) def center_selection(self): """ Center the node graph on the current selected nodes. """ nodes = self._viewer.selected_nodes() self._viewer.center_selection(nodes) def registered_nodes(self): """ Return a list of all node types that have been registered. To register a node see "NodeGraphWidget.register_node()" Returns: list[str]: node types. """ return sorted(NodeVendor.nodes.keys()) def register_node(self, node, alias=None): """ Register a node. Args: node (NodeGraphQt.Node): node object. alias (str): custom alias name for the node type. """ NodeVendor.register_node(node, alias) def create_node(self, node_type, name=None, selected=True, color=None, pos=None): """ Create a new node in the node graph. To list all node types see "NodeGraphWidget.registered_nodes()" Args: node_type (str): node instance type. name (str): set name of the node. selected (bool): set created node to be selected. color (tuple or str): node color (255, 255, 255) or '#FFFFFF'. pos (tuple): set position of the node (x, y). Returns: NodeGraphQt.Node: created instance of a node. """ NodeInstance = NodeVendor.create_node_instance(node_type) if NodeInstance: node = NodeInstance() node._graph = self node.update() self._undo_stack.beginMacro('created node') self._undo_stack.push(NodeAddedCmd(self, node, pos)) if name: node.set_name(name) else: node.set_name(node.NODE_NAME) if color: if isinstance(color, str): color = color[1:] if color[0] is '#' else color color = tuple(int(color[i:i + 2], 16) for i in (0, 2, 4)) node.set_color(*color) node.set_selected(selected) self._undo_stack.endMacro() return node raise Exception('\n\n>> Cannot find node:\t"{}"\n'.format(node_type)) def add_node(self, node): """ Add a node into the node graph. Args: node (NodeGraphQt.Node): node object. """ assert isinstance(node, NodeObject), 'node must be a Node instance.' node._graph = self node.NODE_NAME = self.get_unique_name(node.NODE_NAME) node.model.name = node.NODE_NAME node.update() self._undo_stack.push(NodeAddedCmd(self, node)) def delete_node(self, node): """ Remove the node from the node graph. Args: node (NodeGraphQt.Node): node object. """ assert isinstance(node, NodeObject), \ 'node must be a instance of a NodeObject.' self._undo_stack.push(NodeRemovedCmd(self, node)) def delete_nodes(self, nodes): """ Remove a list of nodes from the node graph. Args: nodes (list[NodeGraphQt.Node]): list of node instances. """ self._undo_stack.beginMacro('deleted nodes') [self.delete_node(n) for n in nodes] self._undo_stack.endMacro() def all_nodes(self): """ Return all nodes in the node graph. Returns: list[NodeGraphQt.Node]: list of nodes. """ return list(self._model.nodes.values()) def selected_nodes(self): """ Return all selected nodes that are in the node graph. Returns: list[NodeGraphQt.Node]: list of nodes. """ nodes = [] for item in self._viewer.selected_nodes(): node = self._model.nodes[item.id] nodes.append(node) return nodes def select_all(self): """ Select all nodes in the current node graph. """ self._undo_stack.beginMacro('select all') for node in self.all_nodes(): node.set_selected(True) self._undo_stack.endMacro() def clear_selection(self): """ Clears the selection in the node graph. """ self._undo_stack.beginMacro('deselected nodes') for node in self.all_nodes(): node.set_selected(False) self._undo_stack.endMacro() def get_node_by_id(self, node_id=None): """ Get the node object by it's id. Args: node_id (str): node id Returns: NodeGraphQt.NodeObject: node object. """ return self._model.nodes.get(node_id) def get_node_by_name(self, name): """ Returns node object that matches the name. Args: name (str): name of the node. Returns: NodeGraphQt.Node: node object. """ for node_id, node in self._model.nodes.items(): if node.name() == name: return node def get_unique_name(self, name): """ return a unique node name for the node. Args: name (str): node name. Returns: str: unique node name. """ name = ' '.join(name.split()) node_names = [n.name() for n in self.all_nodes()] if name not in node_names: return name regex = re.compile('[\w ]+(?: )*(\d+)') search = regex.search(name) if not search: for x in range(1, len(node_names) + 1): new_name = '{} {}'.format(name, x) if new_name not in node_names: return new_name version = search.group(1) name = name[:len(version) * -1].strip() for x in range(1, len(node_names) + 1): new_name = '{} {}'.format(name, x) if new_name not in node_names: return new_name def current_session(self): """ returns the file path to the currently loaded session. Returns: str: path to the currently loaded session """ return self._model.session def clear_session(self): """ clear the loaded node layout session. """ for n in self.all_nodes(): self.delete_node(n) self._undo_stack.clear() self._model.session = None def _serialize(self, nodes): """ serialize nodes to a dict. Args: nodes (list[NodeGraphQt.Nodes]): list of node instances. Returns: dict: serialized data. """ serial_data = {'nodes': {}, 'connections': []} nodes_data = {} for n in nodes: # update the node model. n.update_model() nodes_data.update(n.model.to_dict) for n_id, n_data in nodes_data.items(): serial_data['nodes'][n_id] = n_data inputs = n_data.pop('inputs') if n_data.get('inputs') else {} outputs = n_data.pop('outputs') if n_data.get('outputs') else {} for pname, conn_data in inputs.items(): for conn_id, prt_names in conn_data.items(): for conn_prt in prt_names: pipe = { 'in': [n_id, pname], 'out': [conn_id, conn_prt] } if pipe not in serial_data['connections']: serial_data['connections'].append(pipe) for pname, conn_data in outputs.items(): for conn_id, prt_names in conn_data.items(): for conn_prt in prt_names: pipe = { 'out': [n_id, pname], 'in': [conn_id, conn_prt] } if pipe not in serial_data['connections']: serial_data['connections'].append(pipe) if not serial_data['connections']: serial_data.pop('connections') return serial_data def _deserialize(self, data, relative_pos=False, pos=None): """ deserialize node data. Args: data (dict): node data. relative_pos (bool): position node relative to the cursor. Returns: list[NodeGraphQt.Nodes]: list of node instances. """ nodes = {} # build the nodes. for n_id, n_data in data.get('nodes', {}).items(): identifier = n_data['type'] NodeInstance = NodeVendor.create_node_instance(identifier) if NodeInstance: node = NodeInstance() node._graph = self name = self.get_unique_name(n_data.get('name', node.NODE_NAME)) n_data['name'] = name # set properties. for prop, val in node.model.properties.items(): if prop in n_data.keys(): setattr(node.model, prop, n_data[prop]) # set custom properties. for prop, val in n_data.get('custom', {}).items(): if prop in node.model.custom_properties.keys(): node.model.custom_properties[prop] = val node.update() self._undo_stack.push( NodeAddedCmd(self, node, n_data.get('pos'))) nodes[n_id] = node # build the connections. for connection in data.get('connections', []): nid, pname = connection.get('in', ('', '')) in_node = nodes.get(nid) if not in_node: continue in_port = in_node.inputs().get(pname) if in_node else None nid, pname = connection.get('out', ('', '')) out_node = nodes.get(nid) if not out_node: continue out_port = out_node.outputs().get(pname) if out_node else None if in_port and out_port: self._undo_stack.push(PortConnectedCmd(in_port, out_port)) node_objs = list(nodes.values()) if relative_pos: self._viewer.move_nodes([n.view for n in node_objs]) [setattr(n.model, 'pos', n.view.pos) for n in node_objs] elif pos: self._viewer.move_nodes([n.view for n in node_objs], pos=pos) return node_objs def save_session(self, file_path): """ Saves the current node graph session layout to a JSON formatted file. Args: file_path (str): path to the saved node layout. """ serliazed_data = self._serialize(self.selected_nodes()) file_path = file_path.strip() with open(file_path, 'w') as file_out: json.dump(serliazed_data, file_out, indent=2, separators=(',', ':')) def load_session(self, file_path): """ Load node graph session layout file. Args: file_path (str): path to the serialized layout file. """ file_path = file_path.strip() if not os.path.isfile(file_path): raise IOError('file does not exist.') self.clear_session() try: with open(file_path) as data_file: layout_data = json.load(data_file) except Exception as e: layout_data = None print('Cannot read data from file.\n{}'.format(e)) if not layout_data: return self._deserialize(layout_data) self._undo_stack.clear() self._model.session = file_path def copy_nodes(self, nodes=None): """ copy nodes to the clipboard by default this method copies the selected nodes from the node graph. Args: nodes (list[NodeGraphQt.Node]): list of node instances. """ nodes = nodes or self.selected_nodes() if not nodes: return False clipboard = QClipboard() serial_data = self._serialize(nodes) serial_str = json.dumps(serial_data) if serial_str: clipboard.setText(serial_str) return True return False def paste_nodes(self): """ Pastes nodes from the clipboard. """ clipboard = QClipboard() cb_string = clipboard.text() if not cb_string: return self._undo_stack.beginMacro('pasted nodes') serial_data = json.loads(cb_string) self.clear_selection() nodes = self._deserialize(serial_data, True) [n.set_selected(True) for n in nodes] self._undo_stack.endMacro() def duplicate_nodes(self, nodes): """ Create duplicates nodes. Args: nodes (list[NodeGraphQt.Node]): list of node objects. Returns: list[NodeGraphQt.Node]: list of duplicated node instances. """ if not nodes: return self._undo_stack.beginMacro('duplicated nodes') self.clear_selection() serial = self._serialize(nodes) new_nodes = self._deserialize(serial) offset = 50 for n in new_nodes: x, y = n.pos() n.set_pos(x + offset, y + offset) n.set_property('selected', True) self._undo_stack.endMacro() return new_nodes def disable_nodes(self, nodes, mode=None): """ Disable/Enable specified nodes. Args: nodes (list[NodeGraphQt.Node]): list of node instances. mode (bool): (optional) disable state of the nodes. """ if not nodes: return if mode is None: mode = not nodes[0].disabled() if len(nodes) > 1: text = {False: 'enabled', True: 'disabled'}[mode] text = '{} ({}) nodes'.format(text, len(nodes)) self._undo_stack.beginMacro(text) [n.set_disabled(mode) for n in nodes] self._undo_stack.endMacro() return nodes[0].set_disabled(mode)
class MainWindow(QMainWindow): _tr = QCoreApplication.translate def __init__(self, parent=None): super().__init__(parent) # 调用父类构造函数,创建窗体 self.__scene = None # 创建QGraphicsScene self.__view = None # 创建图形视图组件 self.ui = Ui_MainWindow() # 创建UI对象 self.ui.setupUi(self) # 构造UI界面 self.operatorFile = OperatorFile(self) self.__translator = None title = self.tr("基于Python的图的绘制及相关概念的可视化展示") self.setWindowTitle(title) self.ui.nodeDetails.setEnabled(False) self.ui.edgeDetails.setEnabled(False) self.ui.actionSave.setEnabled(False) self.edgeModel = QStandardItemModel(5, 5, self) self.edgeSelectionModel = QItemSelectionModel(self.edgeModel) self.edgeModel.dataChanged.connect(self.do_updateEdgeWeight) self.nodeModel = QStandardItemModel(5, 4, self) self.nodeSelectionModel = QItemSelectionModel(self.nodeModel) self.nodeModel.dataChanged.connect(self.do_updateNodeWeight) self.spinWeight = WeightSpinDelegate(0, 200, 1, self) self.ui.tabWidget.setVisible(False) self.ui.tabWidget.clear() self.ui.tabWidget.setTabsClosable(True) self.ui.tabWidget.setDocumentMode(True) self.setCentralWidget(self.ui.tabWidget) self.setAutoFillBackground(True) self.__buildStatusBar() # 构造状态栏 self.__buildUndoCommand() # 初始化撤销重做系统 self.__initModeMenu() self.__lastColumnFlag = Qt.NoItemFlags self.iniGraphicsSystem() self.__ItemId = 0 # 绘图项自定义数据的key self.__ItemDesc = 1 # 绘图项自定义数据的key self.__nodeNum = 0 # 结点的序号 self.__edgeNum = 0 # 边的序号 self.__textNum = 0 self.lastColumnFlags = (Qt.ItemIsSelectable | Qt.ItemIsUserCheckable | Qt.ItemIsEnabled) self.__graph = Graph() ## ==============自定义功能函数============ def nodeNum(self): return self.__nodeNum def edgeNum(self): return self.__edgeNum def scene(self): self.viewAndScene() return self.__scene def view(self): self.viewAndScene() return self.__view def graph(self): return self.__graph def __buildStatusBar(self): ##构造状态栏 self.__labViewCord = QLabel(self._tr("MainWindow", "视图坐标:")) self.__labViewCord.setMinimumWidth(150) self.ui.statusbar.addWidget(self.__labViewCord) self.__labSceneCord = QLabel(self._tr("MainWindow", "场景坐标:")) self.__labSceneCord.setMinimumWidth(150) self.ui.statusbar.addWidget(self.__labSceneCord) self.__labItemCord = QLabel(self._tr("MainWindow", "图元坐标:")) self.__labItemCord.setMinimumWidth(150) self.ui.statusbar.addWidget(self.__labItemCord) self.__labItemInfo = QLabel(self._tr("MainWindow", "图元信息: ")) self.ui.statusbar.addPermanentWidget(self.__labItemInfo) self.__labModeInfo = QLabel(self._tr("MainWindow", "有向图模式")) self.ui.statusbar.addPermanentWidget(self.__labModeInfo) def __buildUndoCommand(self): self.undoStack = QUndoStack() self.addAction(self.ui.actionUndo) self.addAction(self.ui.actionRedo) self.ui.undoView.setStack(self.undoStack) def __setItemProperties(self, item, desc): ##item是具体类型的QGraphicsItem self.__nodeNum = len(self.singleItems(BezierNode)) self.__edgeNum = len(self.singleItems(BezierEdge)) self.__textNum = len(self.singleItems(BezierText)) item.setFlag(QGraphicsItem.ItemIsFocusable) item.setFlag(QGraphicsItem.ItemIsMovable) item.setFlag(QGraphicsItem.ItemIsSelectable) item.setPos(-150 + randint(1, 200), -200 + randint(1, 200)) if type(item) is BezierNode: newNum = self.checkSort(self.__scene.uniqueIdList(BezierNode)) if newNum is not None: item.setData(self.__ItemId, newNum) item.textCp.setPlainText("V" + str(newNum)) else: item.setData(self.__ItemId, self.__nodeNum) item.textCp.setPlainText("V" + str(self.__nodeNum)) self.__nodeNum = 1 + self.__nodeNum elif type(item) is BezierEdge: newNum = self.checkSort(self.__scene.uniqueIdList(BezierEdge)) if newNum is not None: item.setData(self.__ItemId, newNum) item.textCp.setPlainText("e" + str(newNum)) else: item.setData(self.__ItemId, self.__edgeNum) item.textCp.setPlainText("e" + str(self.__edgeNum)) self.__edgeNum = 1 + self.__edgeNum elif type(item) is BezierText: newNum = self.checkSort(self.__scene.uniqueIdList(BezierText)) if newNum is not None: item.setData(self.__ItemId, newNum) else: item.setData(self.__ItemId, self.__textNum) self.__textNum = 1 + self.__textNum item.setData(self.__ItemDesc, desc) # 图件描述 self.__scene.addItem(item) self.__scene.clearSelection() item.setSelected(True) def __setBrushColor(self, item): ##设置填充颜色 color = item.brush().__color() color = QColorDialog.getColor(color, self, self._tr("MainWindow", "选择填充颜色")) if color.isValid(): item.setBrush(QBrush(color)) def __initFileMenu(self): self.ui.actionOpen.triggered.connect(self.do_open_file) self.ui.actionSave.triggered.connect(self.do_save_file) self.ui.actionQuit.triggered.connect(self.close) def __initModeMenu(self): modeMenuGroup = QActionGroup(self) modeMenuGroup.addAction(self.ui.actionDigraph_Mode) modeMenuGroup.addAction(self.ui.actionRedigraph_Mode) def __updateEdgeView(self): edges = self.singleItems(BezierEdge) if len(edges): self.ui.edgeDetails.setEnabled(True) else: return edgeColCount = 5 self.edgeModel.clear() edgeHeaderList = [ self._tr("MainWindow", 'ID'), self._tr("MainWindow", '始点'), self._tr("MainWindow", '终点'), self._tr("MainWindow", '坐标'), self._tr("MainWindow", '权重') ] self.edgeModel.setHorizontalHeaderLabels(edgeHeaderList) self.edgeSelectionModel.currentChanged.connect(self.do_curEdgeChanged) self.ui.edgeDetails.setModel(self.edgeModel) self.ui.edgeDetails.setSelectionModel(self.edgeSelectionModel) self.ui.edgeDetails.verticalHeader().setSectionResizeMode( QHeaderView.Fixed) self.ui.edgeDetails.horizontalHeader().setSectionResizeMode( QHeaderView.ResizeToContents) self.ui.edgeDetails.horizontalHeader().setSectionResizeMode( QHeaderView.ResizeToContents) self.ui.edgeDetails.setAlternatingRowColors(True) self.edgeModel.setRowCount(len(edges)) self.ui.edgeDetails.setItemDelegateForColumn(4, self.spinWeight) edges.reverse() for i in range(len(edges)): edge: BezierEdge = edges[i] sourceNode = f'V{edge.sourceNode.data(self.__ItemId)}' if edge.sourceNode else None destNode = f'V{edge.destNode.data(self.__ItemId)}' if edge.destNode else None strList = [ f"e{edge.data(self.__ItemId)}", sourceNode, destNode, f"x:{edge.pos().x()},y:{edge.pos().y()}", f"{edge.weight()}" ] for j in range(edgeColCount): item = QStandardItem(strList[j]) if j != edgeColCount - 1: item.setFlags(self.__lastColumnFlag) self.edgeModel.setItem(i, j, item) def __updateNodeView(self): nodes = self.singleItems(BezierNode) if len(nodes): self.ui.nodeDetails.setEnabled(True) else: return nodeColCount = 4 self.nodeModel.clear() nodeHeaderList = [ self._tr("MainWindow", 'ID'), self._tr("MainWindow", '边数'), self._tr("MainWindow", '坐标'), self._tr("MainWindow", '权重') ] if self.ui.actionDigraph_Mode.isChecked(): nodeHeaderList.append(self._tr("MainWindow", '出度')) nodeHeaderList.append(self._tr("MainWindow", '入度')) nodeColCount += 2 else: nodeHeaderList.append(self._tr("MainWindow", "度")) nodeColCount += 1 self.nodeModel.setHorizontalHeaderLabels(nodeHeaderList) self.nodeModel.setRowCount(len(nodes)) self.nodeSelectionModel.currentChanged.connect(self.do_curNodeChanged) self.ui.nodeDetails.setModel(self.nodeModel) self.ui.nodeDetails.setSelectionModel(self.nodeSelectionModel) self.ui.nodeDetails.verticalHeader().setSectionResizeMode( QHeaderView.Fixed) self.ui.nodeDetails.horizontalHeader().setSectionResizeMode( QHeaderView.ResizeToContents) self.ui.nodeDetails.setAlternatingRowColors(True) self.ui.nodeDetails.setItemDelegateForColumn(3, self.spinWeight) nodes.reverse() for i in range(len(nodes)): node: BezierNode = nodes[i] strList = [ f"V{node.data(self.__ItemId)}", str(len(node.bezierEdges)), f"x:{node.pos().x()},y:{node.pos().y()}", str(node.weight()) ] if self.ui.actionDigraph_Mode.isChecked(): strList.append( f'{node.degrees(self.ui.actionDigraph_Mode.isChecked())[1]}' ) strList.append( f'{node.degrees(self.ui.actionDigraph_Mode.isChecked())[0]}' ) else: strList.append( f'{node.degrees(self.ui.actionDigraph_Mode.isChecked())}') for j in range(nodeColCount): item = QStandardItem(strList[j]) if j != 3: item.setFlags(self.__lastColumnFlag) self.nodeModel.setItem(i, j, item) def iniGraphicsSystem(self, name=None): ##初始化 Graphics View系统 scene = GraphicsScene() # 创建QGraphicsScene view = GraphicsView(self, scene) # 创建图形视图组件 view.mouseMove.connect(self.do_mouseMove) # 鼠标移动 view.mouseClicked.connect(self.do_mouseClicked) # 左键按下 scene.itemMoveSignal.connect(self.do_shapeMoved) scene.itemLock.connect(self.do_nodeLock) scene.isHasItem.connect(self.do_checkIsHasItems) if name: title = name else: text = self.tr('未命名') title = f'{text}{self.ui.tabWidget.count()}' curIndex = self.ui.tabWidget.addTab(view, title) self.ui.tabWidget.setCurrentIndex(curIndex) self.ui.tabWidget.setVisible(True) ## 4个信号与槽函数的关联 # self.view.mouseDoubleClick.connect(self.do_mouseDoubleClick) # 鼠标双击 # self.view.keyPress.connect(self.do_keyPress) # 左键按下 def singleItems(self, className) -> list: self.viewAndScene() return self.__scene.singleItems(className) def connectGraph(self): self.__graph.setMode(self.ui.actionDigraph_Mode.isChecked()) items = self.__scene.uniqueItems() nodeList = [] edgeList = [] if not len(items): return for item in items: if type(item) is BezierNode: nodeList.append(item) elif type(item) is BezierEdge: edgeList.append(item) for node in nodeList: self.__graph.addVertex(node.data(self.__ItemId)) badEdgeList = [] for i in range(len(edgeList)): for edge in edgeList: edge: BezierEdge if edge.data(self.__ItemId) == i: if edge.sourceNode and edge.destNode: self.__graph.addEdge( edge.sourceNode.data(self.__ItemId), edge.destNode.data(self.__ItemId), edge.weight()) else: badEdgeList.append(edge) if len(badEdgeList) != 0: self.disconnectGraph() string = "" for x in range(len(badEdgeList)): demo = "、" if x == len(badEdgeList) - 1: demo = "" string = f'{string}e{badEdgeList[x].data(self.__ItemId)}{demo}' QMessageBox.warning( self, self._tr("MainWindow", "连接故障!"), self._tr("MainWindow", "警告,") + string + self._tr("MainWindow", "的连接不完整")) return False return True def disconnectGraph(self): self.__graph.clearAllData() def viewAndScene(self): if self.ui.tabWidget.count(): self.__view: GraphicsView = self.ui.tabWidget.currentWidget() self.__scene = self.__view.scene() def standardGraphData(self): mode = int(self.ui.actionDigraph_Mode.isChecked()) nodes = self.__scene.singleItems(BezierNode) edges = self.__scene.singleItems(BezierEdge) texts = self.__scene.singleItems(BezierText) nodeDataList = [] edgeDataList = [] textDataList = [] for node in nodes: node: BezierNode data = [ node.data(self.__ItemId), node.weight(), node.pos().x(), node.pos().y() ] nodeDataList.append(data) for edge in edges: edge: BezierEdge data = [edge.data(self.__ItemId)] if edge.sourceNode: data.append(edge.sourceNode.data(self.__ItemId)) else: data.append(-1) if edge.destNode: data.append(edge.destNode.data(self.__ItemId)) else: data.append(-1) data = data + [ edge.weight(), edge.beginCp.point().x(), edge.beginCp.point().y(), edge.edge1Cp.point().x(), edge.edge1Cp.point().y(), edge.edge2Cp.point().x(), edge.edge2Cp.point().y(), edge.endCp.point().x(), edge.endCp.point().y(), edge.scenePos().x(), edge.scenePos().y() ] edgeDataList.append(data) for text in texts: text: BezierText data = [ text.data(self.__ItemId), text.toPlainText(), text.scenePos().x(), text.scenePos().y() ] textDataList.append(data) nodeDataList.reverse() edgeDataList.reverse() textDataList.reverse() return [mode, nodeDataList, edgeDataList, textDataList] def reverseStandardData(self, excelData): graphName = excelData[0] mode = excelData[1] nodes = [] edges = [] texts = [] self.ui.actionDigraph_Mode.setChecked(bool(mode)) for nodeDetail in excelData[2]: node = BezierNode() node.textCp.setPlainText(f"V{nodeDetail[0]}") node.setData(self.__ItemId, nodeDetail[0]) nodeText = self._tr("MainWindow", "顶点") node.setData(self.__ItemDesc, nodeText) if len(nodeDetail) < 3: for i in range(2): intRandom = randint(-400, 400) nodeDetail.append(intRandom) node.setPos(QPointF(nodeDetail[2], nodeDetail[3])) node.weightCp.setPlainText(str(nodeDetail[1])) nodes.append(node) for edgeDetail in excelData[3]: edge = BezierEdge() edge.setData(self.__ItemId, edgeDetail[0]) edge.setData(self.__ItemDesc, "边") edge.textCp.setPlainText(f"e{edgeDetail[0]}") edge.weightCp.setPlainText(str(edgeDetail[3])) if len(edgeDetail) <= 4: for i in range(10): intRandom = randint(-400, 400) edgeDetail.append(intRandom) edge.setPos(QPointF(edgeDetail[12], edgeDetail[13])) if edgeDetail[1] >= 0: for node in nodes: node: BezierNode if node.data(self.__ItemId) == edgeDetail[1]: edge.setSourceNode(node) node.addBezierEdge(edge, ItemType.SourceType) line = QLineF(edge.mapFromScene(node.pos()), edge.edge1Cp.point()) length = line.length() edgeOffset = QPointF(line.dx() * 10 / length, line.dy() * 10 / length) source = edge.mapFromScene(node.pos()) + edgeOffset edge.setSpecialControlPoint(source, ItemType.SourceType) edge.beginCp.setVisible(False) else: edge.setSpecialControlPoint( QPointF(edgeDetail[4], edgeDetail[5]), ItemType.SourceType) if edgeDetail[2] >= 0: for node in nodes: node: BezierNode if node.data(self.__ItemId) == edgeDetail[2]: edge.setDestNode(node) node.addBezierEdge(edge, ItemType.DestType) line = QLineF(edge.mapFromScene(node.pos()), edge.edge2Cp.point()) length = line.length() edgeOffset = QPointF(line.dx() * 10 / length, line.dy() * 10 / length) if mode: dest = edge.mapFromScene( node.pos()) + edgeOffset * 2.3 else: dest = edge.mapFromScene(node.pos()) + edgeOffset edge.setSpecialControlPoint(dest, ItemType.DestType) edge.endCp.setVisible(False) else: edge.setSpecialControlPoint( QPointF(edgeDetail[10], edgeDetail[11]), ItemType.DestType) edge.setEdgeControlPoint(QPointF(edgeDetail[6], edgeDetail[7]), ItemType.SourceType) edge.setEdgeControlPoint(QPointF(edgeDetail[8], edgeDetail[9]), ItemType.DestType) edge.centerCp.setPoint(edge.updateCenterPos()) edges.append(edge) if len(excelData) <= 4: return [graphName, nodes + edges] for textDetail in excelData[4]: text = BezierText(str(textDetail[1])) text.setData(self.__ItemId, textDetail[0]) text.setData(self.__ItemDesc, "文本") text.setPos(textDetail[2], textDetail[3]) texts.append(text) return [graphName, nodes + edges + texts] def setTranslator(self, translator, language): self.__translator = translator if language == 'EN': self.ui.actionSetEnglish.setChecked(True) else: self.ui.actionSetChinese.setChecked(True) @classmethod def checkSort(cls, index: list): index.sort() for i in range(len(index)): if i != index[i]: return i # ==============event处理函数========================== # def closeEvent(self, event): # 退出函数 # # msgBox = QMessageBox() # msgBox.setWindowTitle('关闭') # msgBox.setText("是否保存") # msgBox.setIcon(QMessageBox.Question) # btn_Do_notSave = msgBox.addButton('不保存', QMessageBox.AcceptRole) # btn_cancel = msgBox.addButton('取消', QMessageBox.RejectRole) # btn_save = msgBox.addButton('保存', QMessageBox.AcceptRole) # msgBox.setDefaultButton(btn_save) # msgBox.exec_() # # if msgBox.clickedButton() == btn_Do_notSave: # event.accept() # elif msgBox.clickedButton() == btn_cancel: # event.ignore() # elif msgBox.clickedButton() == btn_save: # self.do_save_file() # event.accept() # def contextMenuEvent(self, event): # 右键菜单功能 # rightMouseMenu = QMenu(self) # # rightMouseMenu.addAction(self.ui.actionNew) # rightMouseMenu.addAction(self.ui.actionOpen) # # self.action = rightMouseMenu.exec_(self.mapToGlobal(event.pos())) # ==========由connectSlotsByName()自动连接的槽函数============ @Slot() # 新建画板 def on_actionNew_triggered(self): self.iniGraphicsSystem() @Slot() # 添加边 def on_actionArc_triggered(self): # 添加曲线 item = BezierEdge() item.setGraphMode(self.ui.actionDigraph_Mode.isChecked()) self.__setItemProperties(item, self._tr("MainWindow", "边")) self.do_addItem(item) self.__updateEdgeView() self.__updateNodeView() @Slot() # 添加顶点 def on_actionCircle_triggered(self): # 添加原点 self.viewAndScene() item = BezierNode() self.__setItemProperties(item, self._tr("MainWindow", "顶点")) self.do_addItem(item) self.__updateNodeView() self.__updateEdgeView() @Slot() # 添加注释 def on_actionAdd_Annotation_triggered(self): self.viewAndScene() strText, OK = QInputDialog.getText(self, self._tr("MainWindow", "输入"), self._tr("MainWindow", "请输入文字")) if not OK: return item = BezierText(strText) self.__setItemProperties(item, self._tr("MainWindow", "注释")) self.do_addItem(item) @Slot(bool) # 显示和隐藏结点权重 def on_actionShowNodesWeight_toggled(self, check: bool): nodes = self.__scene.singleItems(BezierNode) for node in nodes: node: BezierNode node.weightCp.setVisible(check) # if check: # self.ui.actionShowNodesWeight.setText("隐藏顶点权重") # else: # self.ui.actionShowNodesWeight.setText("显示顶点权重") @Slot(bool) # 显示和隐藏边权重 def on_actionShowEdgesWeight_toggled(self, check: bool): edges = self.__scene.singleItems(BezierEdge) for edge in edges: edge: BezierEdge edge.weightCp.setVisible(check) # if check: # self.ui.actionShowEdgesWeight.setText("隐藏边权重") # else: # self.ui.actionShowEdgesWeight.setText("显示边权重") @Slot(bool) # 显示和隐藏边的控制点 def on_actionHideControlPoint_toggled(self, check: bool): edges = self.__scene.singleItems(BezierEdge) for edge in edges: edge: BezierEdge for point in edge.pointList: point.setVisible(check) if edge.sourceNode: edge.beginCp.setVisible(False) if edge.destNode: edge.endCp.setVisible(False) @Slot() # 简单通路 def on_actionEasy_Pathway_triggered(self): self.viewAndScene() items = self.__scene.nodeList if len(items) == 0: QMessageBox.warning(self, self._tr("MainWindow", "警告"), self._tr("MainWindow", "对不起,你没有选择起始节点")) return elif len(items) != 2: QMessageBox.warning(self, self._tr("MainWindow", "警告"), self._tr("MainWindow", "选择的起始点数目不符合要求")) return if self.connectGraph(): PathWay = ShowDataWidget(self, items, self.__graph, name=self._tr("MainWindow", "简单通路")) PathWay.pathSignal.connect(self.do_ShowSelectPath) if PathWay.easyPath(): PathWay.updateToolWidget() PathWay.show() self.disconnectGraph() @Slot() # 简单回路 def on_actionEasy_Loop_triggered(self): self.viewAndScene() items = self.__scene.nodeList if len(items) == 0: QMessageBox.warning(self, self._tr("MainWindow", "警告"), self._tr("MainWindow", "对不起,你没有选择起点")) return if self.connectGraph(): LoopWay = ShowDataWidget(self, items, self.__graph, name=self._tr("MainWindow", "简单回路")) LoopWay.pathSignal.connect(self.do_ShowSelectPath) if LoopWay.easyLoop(): LoopWay.updateToolWidget(mode=1) LoopWay.show() self.disconnectGraph() @Slot() # 初级通路 def on_actionPrimary_Pathway_triggered(self): items = self.__scene.nodeList if len(items) == 0: QMessageBox.warning(self, self._tr("MainWindow", "警告"), self._tr("MainWindow", "对不起,你没有选择起始节点")) return elif len(items) != 2: QMessageBox.warning(self, self._tr("MainWindow", "警告"), self._tr("MainWindow", "选择的起始点数目不符合要求")) return if self.connectGraph(): PathWay = ShowDataWidget(self, items, self.__graph, name="初级通路") PathWay.pathSignal.connect(self.do_ShowSelectPath) if PathWay.primaryPath(): PathWay.updateToolWidget(path=1) PathWay.show() self.disconnectGraph() @Slot() # 初级回路 def on_actionPrimary_Loop_triggered(self): items = self.__scene.nodeList if len(items) == 0: QMessageBox.warning(self, self._tr("MainWindow", "警告"), self._tr("MainWindow", "对不起,你没有选择起点")) return if self.connectGraph(): LoopWay = ShowDataWidget(self, items, self.__graph, name=self._tr("MainWindow", "初级回路")) LoopWay.pathSignal.connect(self.do_ShowSelectPath) if LoopWay.primaryLoop(): LoopWay.updateToolWidget(mode=1, path=1) LoopWay.show() self.disconnectGraph() @Slot() # 邻接矩阵 边数 def on_action_EdgeNum_triggered(self): self.viewAndScene() items = self.__scene.singleItems(BezierNode) if len(items) == 0: QMessageBox.warning(self, self._tr("MainWindow", "警告"), self._tr("MainWindow", "图中没有结点")) return if self.connectGraph(): MatrixTable = ShowMatrixWidget(self, self.__graph, self._tr("MainWindow", "邻接矩阵"), 0) MatrixTable.show() @Slot() # 邻接矩阵 权重 def on_actionWeight_triggered(self): self.viewAndScene() items = self.__scene.singleItems(BezierNode) if len(items) == 0: QMessageBox.warning(self, self._tr("MainWindow", "警告"), self._tr("MainWindow", "图中没有结点")) return if self.connectGraph(): if not self.__graph.multipleOrSimple(): MatrixTable = ShowMatrixWidget(self, self.__graph, self._tr("MainWindow", "邻接矩阵"), 1) MatrixTable.show() else: QMessageBox.information(self, "Sorry", "这个图不是简单图") self.disconnectGraph() @Slot() # 可达矩阵 def on_actionReachable_Matrix_triggered(self): self.viewAndScene() items = self.__scene.singleItems(BezierNode) if len(items) == 0: QMessageBox.warning(self, self._tr("MainWindow", "警告"), self._tr("MainWindow", "图中没有结点")) return if self.connectGraph(): MatrixTable = ShowMatrixWidget(self, self.__graph, self._tr("MainWindow", "可达矩阵")) MatrixTable.show() @Slot() # 关联矩阵 def on_actionIncidence_Matrix_Undigraph_triggered(self): self.viewAndScene() items = self.__scene.singleItems(BezierNode) if len(items) == 0: QMessageBox.warning(self, self._tr("MainWindow", "警告"), self._tr("MainWindow", "图中没有结点")) return if self.ui.actionDigraph_Mode.isChecked(): items = self.singleItems(BezierEdge) badNodeList = [] badNodes = '' for x in range(len(items)): if items[x].sourceNode is not None and items[ x].destNode is not None: if items[x].sourceNode == items[x].destNode: badNodeList.append(items[x]) demo = "、" if x == len(items) - 1: demo = "" badNodes = f"{badNodes}V{items[x].sourceNode.data(self.__ItemId)}{demo}" if len(badNodeList): text = self._tr("MainWindow", '有向图的关联矩阵需要有向图无环,而') text1 = self._tr("MainWindow", '存在环!') QMessageBox.warning(self, self._tr("MainWindow", "致命错误"), f"{text}{badNodes}{text1}") return if self.connectGraph(): MatrixTable = ShowMatrixWidget(self, self.__graph, self._tr("MainWindow", "关联矩阵")) MatrixTable.show() @Slot() # 图的连通性 def on_actionConnectivity_triggered(self): name = '' if self.connectGraph(): num = self.__graph.connectivity() if num is False: name = self._tr("MainWindow", '此图为非连通图') elif num == 2: name = self._tr("MainWindow", "此图为单向连通图") elif num == 3: name = self._tr("MainWindow", "此图为强连通图") elif num == 1: name = self._tr("MainWindow", '此图为连通图') QMessageBox.information(self, self._tr("MainWindow", "图的连通性"), name) self.disconnectGraph() @Slot() # 完全图判定 def on_actionCompleteGraph_triggered(self): if self.connectGraph(): edge = self.__graph.completeGraph() if edge: name = self._tr("MainWindow", "此图为完全图") else: name = self._tr("MainWindow", '此图不是完全图') QMessageBox.information(self, self._tr("MainWindow", "完全图判定"), name) self.disconnectGraph() @Slot() # 简单图多重图判定 def on_actionMultipleOrSimple_triggered(self): if self.connectGraph(): edges = self.__graph.multipleOrSimple() if not edges: QMessageBox.information(self, self._tr("MainWindow", "简单图与多重图的判定"), self._tr("MainWindow", "此图为简单图")) else: parallelSides = ShowDataWidget( self, edges, self.__graph, self._tr("MainWindow", "简单图与多重图的判定")) parallelSides.multipleOrSimple() parallelSides.show() @Slot() # 最短路径 def on_actionShortestPath_triggered(self): items = self.__scene.nodeList if len(items) == 0: QMessageBox.warning(self, self._tr("MainWindow", "警告"), self._tr("MainWindow", "对不起,你没有选择结点")) return if self.connectGraph(): ShortestPath = ShowDataWidget(self, items, self.__graph, name=self._tr("MainWindow", "最短路径")) ShortestPath.pathSignal.connect(self.do_ShowSelectPath) if ShortestPath.shortestPath(): ShortestPath.updateToolWidget(mode=1, path=2) ShortestPath.show() @Slot() # 撤销 def on_actionUndo_triggered(self): # 撤销 self.undoStack.undo() self.__updateEdgeView() self.__updateNodeView() @Slot() # 重做 def on_actionRedo_triggered(self): # 重做 self.viewAndScene() self.undoStack.redo() self.__updateEdgeView() self.__updateNodeView() @Slot() # 帮助 def on_actionHelp_Document_triggered(self): open("https://github.com/BBlance/Discrete_math.graph_theory") # @Slot() # def on_actionPen_Color_triggered(self): # 画笔颜色 # iniColor = self.view.getPenColor() # color = QColorDialog.getColor(iniColor, self, "选择颜色") # if color.isValid(): # self.view.setPenColor(color) # @Slot() # def on_actionPen_Thickness_triggered(self): # 画笔粗细 # self.viewAndScene() # iniThickness = self.__view.getPenThickness() # intPenStyle = self.__view.getPenStyle() # thicknessDialog = ThicknessDialog(None, self._tr("MainWindow", "画笔粗细与样式"), iniThickness, intPenStyle) # ret = thicknessDialog.exec_() # thickness = thicknessDialog.getThickness() # penStyle = thicknessDialog.getPenStyle() # self.__view.setPenStyle(penStyle) # self.__view.setPenThickness(thickness) @Slot() def on_actionBackground_Color_triggered(self): self.viewAndScene() # iniColor = self.__view.getBackgroundColor() # color = QColorDialog.getColor(iniColor, self, "选择颜色") # if color.isValid(): # self.__view.setBackgroundBrush(color) for item in self.standardGraphData(): print(item) # @Slot(bool) # def on_actionProperty_And_History_triggered(self, checked): # self.ui.dockWidget.setVisible(checked) @Slot() # 保存文件 def on_actionSave_triggered(self): self.viewAndScene() tableName = self.ui.tabWidget.tabText(self.ui.tabWidget.currentIndex()) filename = self.operatorFile.saveGraphData(self.standardGraphData(), tableName) if filename: index = self.ui.tabWidget.currentIndex() self.ui.tabWidget.setTabText(index, filename.baseName()) @Slot() # 读取文件 def on_actionOpen_triggered(self): graph = self.operatorFile.openGraphData() if graph: graph = self.reverseStandardData(graph) self.iniGraphicsSystem(graph[0]) for item in graph[1]: self.__scene.addItem(item) self.__updateNodeView() self.__updateEdgeView() self.__scene.update() @Slot() # 另存为 def on_actionSave_As_triggered(self): filename = self.operatorFile.saveExcelAs(self.standardGraphData()) if filename: index = self.ui.tabWidget.currentIndex() self.ui.tabWidget.setTabText(index, filename.baseName()) @Slot() # 导出数据 def on_actionOutputData_triggered(self): data = self.standardGraphData() data = data[:3] dataCpoy = [data[0], [], []] for node in data[1]: node = node[:2] dataCpoy[1].append(node) for edge in data[2]: edge = edge[:4] dataCpoy[2].append(edge) if self.operatorFile.outputData(dataCpoy): title = self.tr("恭喜") strInfo = self.tr("数据导出成功") QMessageBox.information(self, title, strInfo) @Slot() # 导入数据 def on_actionImportData_triggered(self): data = self.operatorFile.inputData() if data: graph = self.reverseStandardData(data) self.iniGraphicsSystem(graph[0]) for item in graph[1]: self.__scene.addItem(item) self.__updateNodeView() self.__updateEdgeView() self.__scene.update() @Slot() def on_actionSave_Image_triggered(self): self.viewAndScene() savePath, fileType = QFileDialog.getSaveFileName( self, self._tr("MainWindow", '保存图片'), '.\\', '*bmp;;*.png') filename = os.path.basename(savePath) if filename != "": self.__view.saveImage(savePath, fileType) @Slot() def on_actionDelete_triggered(self): self.viewAndScene() self.do_deleteItem() @Slot(bool) def on_actionDigraph_Mode_toggled(self, checked: bool): self.__labModeInfo.setText(self._tr("MainWindow", "有向图模式")) self.__graph.setMode(checked) items = self.__scene.singleItems(BezierEdge) for item in items: item: BezierEdge item.setGraphMode(True) item.update() @Slot(bool) def on_actionRedigraph_Mode_toggled(self, checked: bool): self.__labModeInfo.setText(self._tr("MainWindow", "无向图模式")) self.__graph.setMode(checked) items = self.__scene.singleItems(BezierEdge) for item in items: item: BezierEdge item.setGraphMode(False) item.update() @Slot(int) def on_tabWidget_currentChanged(self, index): # ui.tabWidget当前页面变化 self.viewAndScene() if self.__view and self.__scene: self.__updateEdgeView() self.__updateNodeView() hasTabs = self.ui.tabWidget.count() > 0 # 再无页面时 self.ui.tabWidget.setVisible(hasTabs) self.ui.dockWidget.setVisible(hasTabs) self.ui.actionProperty_And_History.setChecked(hasTabs) @Slot(int) def on_tabWidget_tabCloseRequested(self, index): # 分页关闭时关闭窗体 if index < 0: return view = self.ui.tabWidget.widget(index) view.close() # self.__view = None # self.__scene = None # =============自定义槽函数=============================== def do_nodeLock(self, item): self.__updateNodeView() self.__updateEdgeView() def do_mouseMove(self, point): ##鼠标移动 ##鼠标移动事件,point是 GraphicsView的坐标,物理坐标 view = self._tr("MainWindow", '视图坐标:') scene = self._tr("MainWindow", '场景坐标:') self.__labViewCord.setText("%s%d,%d" % (view, point.x(), point.y())) pt = self.ui.tabWidget.currentWidget().mapToScene(point) # 转换到Scene坐标 self.__labSceneCord.setText("%s%.0f,%.0f" % (scene, pt.x(), pt.y())) def do_mouseClicked(self, point): ##鼠标单击 pt = self.__view.mapToScene(point) # 转换到Scene坐标 item = self.__scene.itemAt(pt, self.__view.transform()) # 获取光标下的图形项 if item is None: return pm = item.mapFromScene(pt) # 转换为绘图项的局部坐标 itemInfo = self._tr("MainWindow", "Item 坐标:") self.__labItemCord.setText("%s%.0f,%.0f" % (itemInfo, pm.x(), pm.y())) data = f"{item.data(self.__ItemDesc)}, ItemId={item.data(self.__ItemId)}" if type(item) is BezierEdge: data = f"{data},EdgeId=e{item.data(self.__ItemId)}" elif type(item) is BezierNode: data = f"{data}, NodeId=V{item.data(self.__ItemId)}" self.__labItemInfo.setText(data) def do_mouseDoubleClick(self, point): ##鼠标双击 pt = self.__view.mapToScene(point) # 转换到Scene坐标,QPointF item = self.__scene.itemAt(pt, self.__view.transform()) # 获取光标下的绘图项 if item is None: return className = str(type(item)) # 将类名称转换为字符串 if className.find("QGraphicsRectItem") >= 0: # 矩形框 self.__setBrushColor(item) elif className.find( "QGraphicsEllipseItem") >= 0: # 椭圆和圆都是 QGraphicsEllipseItem self.__setBrushColor(item) elif className.find("QGraphicsPolygonItem") >= 0: # 梯形和三角形 self.__setBrushColor(item) elif className.find("QGraphicsLineItem") >= 0: # 直线,设置线条颜色 pen = item.pen() color = item.pen().__color() color = QColorDialog.getColor(color, self, "选择线条颜色") if color.isValid(): pen.setColor(color) item.setPen(pen) elif className.find("QGraphicsTextItem") >= 0: # 文字,设置字体 font = item.font() font, OK = QFontDialog.getFont(font) if OK: item.setFont(font) def do_addItem(self, item): add = AddCommand(self, self.__scene, item) self.undoStack.push(add) def do_shapeMoved(self, item, pos): move = MoveCommand(item, pos) self.undoStack.push(move) def do_deleteItem(self): items = self.__scene.selectedItems() cnt = len(items) for i in range(cnt): item = items[i] if str(type(item)).find("BezierNode") >= 0: item: BezierNode for edge in item.bezierEdges: for node, itemType in edge.items(): if itemType == ItemType.SourceType: node.setSourceNode(None) elif itemType == ItemType.DestType: node.setDestNode(None) self.__nodeNum -= 1 elif str(type(item)).find("BezierEdge") >= 0: item: BezierEdge sourceNode: BezierNode = item.sourceNode destNode: BezierNode = item.destNode if sourceNode: sourceNodeList = sourceNode.bezierEdges for sourceEdge in sourceNodeList: for edge in sourceEdge.keys(): if item is edge: sourceNodeList.remove(sourceEdge) if destNode: destNodeList = destNode.bezierEdges for destEdge in destNodeList: for edge in destEdge.keys(): if item is edge: destNodeList.remove(destEdge) self.__edgeNum -= 1 self.__scene.removeItem(item) # 删除绘图项 def do_curEdgeChanged(self, current, previous): if current is not None: text = f"当前单元格{current.row()},{current.column()}" item = self.edgeModel.itemFromIndex(current) def do_curNodeChanged(self, current, previous): if current is not None: text = f"当前单元格{current.row()},{current.column()}" item = self.nodeModel.itemFromIndex(current) def do_updateEdgeWeight(self, topLeft, bottomRight): if topLeft.column() == 4: edges = self.__scene.singleItems(BezierEdge) for edge in edges: edge: BezierEdge if edge.textCp.toPlainText() == self.edgeModel.index( topLeft.row(), 0, QModelIndex()).data(): edge.weightCp.setPlainText(str(topLeft.data())) self.__scene.update() def do_updateNodeWeight(self, topLeft, bottomRight): if topLeft.column() == 3: nodes = self.__scene.singleItems(BezierNode) for node in nodes: node: BezierNode if node.textCp.toPlainText() == self.nodeModel.index( topLeft.row(), 0, QModelIndex()).data(): node.weightCp.setPlainText(str(topLeft.data())) self.__scene.update() def do_ShowSelectPath(self, pathList: list): self.__scene.clearSelection() items = self.__scene.uniqueItems() for item in items: if item.textCp.toPlainText() in pathList: item.setSelected(True) def do_checkIsHasItems(self, num): if num: self.ui.actionSave.setEnabled(True) else: self.ui.actionSave.setEnabled(False)
class Flow(QGraphicsView): def __init__(self, main_window, parent_script, config=None): super(Flow, self).__init__() # SHORTCUTS place_new_node_shortcut = QShortcut(QKeySequence('Shift+P'), self) place_new_node_shortcut.activated.connect( self.place_new_node_by_shortcut) move_selected_nodes_left_shortcut = QShortcut( QKeySequence('Shift+Left'), self) move_selected_nodes_left_shortcut.activated.connect( self.move_selected_nodes_left) move_selected_nodes_up_shortcut = QShortcut(QKeySequence('Shift+Up'), self) move_selected_nodes_up_shortcut.activated.connect( self.move_selected_nodes_up) move_selected_nodes_right_shortcut = QShortcut( QKeySequence('Shift+Right'), self) move_selected_nodes_right_shortcut.activated.connect( self.move_selected_nodes_right) move_selected_nodes_down_shortcut = QShortcut( QKeySequence('Shift+Down'), self) move_selected_nodes_down_shortcut.activated.connect( self.move_selected_nodes_down) select_all_shortcut = QShortcut(QKeySequence('Ctrl+A'), self) select_all_shortcut.activated.connect(self.select_all) copy_shortcut = QShortcut(QKeySequence.Copy, self) copy_shortcut.activated.connect(self.copy) cut_shortcut = QShortcut(QKeySequence.Cut, self) cut_shortcut.activated.connect(self.cut) paste_shortcut = QShortcut(QKeySequence.Paste, self) paste_shortcut.activated.connect(self.paste) # UNDO/REDO self.undo_stack = QUndoStack(self) self.undo_action = self.undo_stack.createUndoAction(self, 'undo') self.undo_action.setShortcuts(QKeySequence.Undo) self.redo_action = self.undo_stack.createRedoAction(self, 'redo') self.redo_action.setShortcuts(QKeySequence.Redo) undo_shortcut = QShortcut(QKeySequence.Undo, self) undo_shortcut.activated.connect(self.undo_activated) redo_shortcut = QShortcut(QKeySequence.Redo, self) redo_shortcut.activated.connect(self.redo_activated) # GENERAL ATTRIBUTES self.parent_script = parent_script self.all_node_instances: [NodeInstance] = [] self.all_node_instance_classes = main_window.all_node_instance_classes # ref self.all_nodes = main_window.all_nodes # ref self.gate_selected: PortInstanceGate = None self.dragging_connection = False self.ignore_mouse_event = False # for stylus - see tablet event self.last_mouse_move_pos: QPointF = None self.node_place_pos = QPointF() self.left_mouse_pressed_in_flow = False self.mouse_press_pos: QPointF = None self.tablet_press_pos: QPointF = None self.auto_connection_gate = None # stores the gate that we may try to auto connect to a newly placed NI self.panning = False self.pan_last_x = None self.pan_last_y = None self.current_scale = 1 self.total_scale_div = 1 # SETTINGS self.algorithm_mode = Flow_AlgorithmMode() self.viewport_update_mode = Flow_ViewportUpdateMode() # CREATE UI scene = QGraphicsScene(self) scene.setItemIndexMethod(QGraphicsScene.NoIndex) scene.setSceneRect(0, 0, 10 * self.width(), 10 * self.height()) self.setScene(scene) self.setCacheMode(QGraphicsView.CacheBackground) self.setViewportUpdateMode(QGraphicsView.BoundingRectViewportUpdate) self.setRenderHint(QPainter.Antialiasing) self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse) self.setDragMode(QGraphicsView.RubberBandDrag) scene.selectionChanged.connect(self.selection_changed) self.setAcceptDrops(True) self.centerOn( QPointF(self.viewport().width() / 2, self.viewport().height() / 2)) # NODE CHOICE WIDGET self.node_choice_proxy = FlowProxyWidget(self) self.node_choice_proxy.setZValue(1000) self.node_choice_widget = NodeChoiceWidget( self, main_window.all_nodes) # , main_window.node_images) self.node_choice_proxy.setWidget(self.node_choice_widget) self.scene().addItem(self.node_choice_proxy) self.hide_node_choice_widget() # ZOOM WIDGET self.zoom_proxy = FlowProxyWidget(self) self.zoom_proxy.setFlag(QGraphicsItem.ItemIgnoresTransformations, True) self.zoom_proxy.setZValue(1001) self.zoom_widget = FlowZoomWidget(self) self.zoom_proxy.setWidget(self.zoom_widget) self.scene().addItem(self.zoom_proxy) self.set_zoom_proxy_pos() # STYLUS self.stylus_mode = '' self.current_drawing = None self.drawing = False self.drawings = [] self.stylus_modes_proxy = FlowProxyWidget(self) self.stylus_modes_proxy.setFlag( QGraphicsItem.ItemIgnoresTransformations, True) self.stylus_modes_proxy.setZValue(1001) self.stylus_modes_widget = FlowStylusModesWidget(self) self.stylus_modes_proxy.setWidget(self.stylus_modes_widget) self.scene().addItem(self.stylus_modes_proxy) self.set_stylus_proxy_pos() self.setAttribute(Qt.WA_TabletTracking) # DESIGN THEME Design.flow_theme_changed.connect(self.theme_changed) if config: config: dict # algorithm mode if config.keys().__contains__('algorithm mode'): if config['algorithm mode'] == 'data flow': self.parent_script.widget.ui.algorithm_data_flow_radioButton.setChecked( True) self.algorithm_mode.mode_data_flow = True else: # 'exec flow' self.parent_script.widget.ui.algorithm_exec_flow_radioButton.setChecked( True) self.algorithm_mode.mode_data_flow = False # viewport update mode if config.keys().__contains__('viewport update mode'): if config['viewport update mode'] == 'sync': self.parent_script.widget.ui.viewport_update_mode_sync_radioButton.setChecked( True) self.viewport_update_mode.sync = True else: # 'async' self.parent_script.widget.ui.viewport_update_mode_async_radioButton.setChecked( True) self.viewport_update_mode.sync = False node_instances = self.place_nodes_from_config(config['nodes']) self.connect_nodes_from_config(node_instances, config['connections']) if list(config.keys()).__contains__( 'drawings' ): # not all (old) project files have drawings arr self.place_drawings_from_config(config['drawings']) self.undo_stack.clear() def theme_changed(self, t): self.viewport().update() def algorithm_mode_data_flow_toggled(self, checked): self.algorithm_mode.mode_data_flow = checked def viewport_update_mode_sync_toggled(self, checked): self.viewport_update_mode.sync = checked def selection_changed(self): selected_items = self.scene().selectedItems() selected_node_instances = list( filter(find_NI_in_object, selected_items)) if len(selected_node_instances) == 1: self.parent_script.show_NI_code(selected_node_instances[0]) elif len(selected_node_instances) == 0: self.parent_script.show_NI_code(None) def contextMenuEvent(self, event): QGraphicsView.contextMenuEvent(self, event) # in the case of the menu already being shown by a widget under the mouse, the event is accepted here if event.isAccepted(): return for i in self.items(event.pos()): if find_type_in_object(i, NodeInstance): ni: NodeInstance = i menu: QMenu = ni.get_context_menu() menu.exec_(event.globalPos()) event.accept() def undo_activated(self): """Triggered by ctrl+z""" self.undo_stack.undo() self.viewport().update() def redo_activated(self): """Triggered by ctrl+y""" self.undo_stack.redo() self.viewport().update() def mousePressEvent(self, event): Debugger.debug('mouse press event received, point:', event.pos()) # to catch tablet events (for some reason, it results in a mousePrEv too) if self.ignore_mouse_event: self.ignore_mouse_event = False return # there might be a proxy widget meant to receive the event instead of the flow QGraphicsView.mousePressEvent(self, event) # to catch any Proxy that received the event. Checking for event.isAccepted() or what is returned by # QGraphicsView.mousePressEvent(...) both didn't work so far, so I do it manually if self.ignore_mouse_event: self.ignore_mouse_event = False return if event.button() == Qt.LeftButton: if self.node_choice_proxy.isVisible(): self.hide_node_choice_widget() else: if find_type_in_object(self.itemAt(event.pos()), PortInstanceGate): self.gate_selected = self.itemAt(event.pos()) self.dragging_connection = True self.left_mouse_pressed_in_flow = True elif event.button() == Qt.RightButton: if len(self.items(event.pos())) == 0: self.node_choice_widget.reset_list() self.show_node_choice_widget(event.pos()) elif event.button() == Qt.MidButton: self.panning = True self.pan_last_x = event.x() self.pan_last_y = event.y() event.accept() self.mouse_press_pos = self.mapToScene(event.pos()) def mouseMoveEvent(self, event): QGraphicsView.mouseMoveEvent(self, event) if self.panning: # middle mouse pressed self.pan(event.pos()) event.accept() self.last_mouse_move_pos = self.mapToScene(event.pos()) if self.dragging_connection: self.viewport().repaint() def mouseReleaseEvent(self, event): # there might be a proxy widget meant to receive the event instead of the flow QGraphicsView.mouseReleaseEvent(self, event) if self.ignore_mouse_event or \ (event.button() == Qt.LeftButton and not self.left_mouse_pressed_in_flow): self.ignore_mouse_event = False return elif event.button() == Qt.MidButton: self.panning = False # connection dropped over specific gate if self.dragging_connection and self.itemAt(event.pos()) and \ find_type_in_object(self.itemAt(event.pos()), PortInstanceGate): self.connect_gates__cmd(self.gate_selected, self.itemAt(event.pos())) # connection dropped over NodeInstance - auto connect elif self.dragging_connection and find_type_in_objects( self.items(event.pos()), NodeInstance): # find node instance ni_under_drop = None for item in self.items(event.pos()): if find_type_in_object(item, NodeInstance): ni_under_drop = item break # connect self.try_conn_gate_and_ni(self.gate_selected, ni_under_drop) # connection dropped somewhere else - show node choice widget elif self.dragging_connection: self.auto_connection_gate = self.gate_selected self.show_node_choice_widget(event.pos()) self.left_mouse_pressed_in_flow = False self.dragging_connection = False self.gate_selected = None self.viewport().repaint() def keyPressEvent(self, event): QGraphicsView.keyPressEvent(self, event) if event.isAccepted(): return if event.key() == Qt.Key_Escape: # do I need that... ? self.clearFocus() self.setFocus() return True elif event.key() == Qt.Key_Delete: self.remove_selected_components() def wheelEvent(self, event): if event.modifiers() == Qt.CTRL and event.angleDelta().x() == 0: self.zoom(event.pos(), self.mapToScene(event.pos()), event.angleDelta().y()) event.accept() return True QGraphicsView.wheelEvent(self, event) def tabletEvent(self, event): """tabletEvent gets called by stylus operations. LeftButton: std, no button pressed RightButton: upper button pressed""" # if in edit mode and not panning or starting a pan, pass on to std mouseEvent handlers above if self.stylus_mode == 'edit' and not self.panning and not \ (event.type() == QTabletEvent.TabletPress and event.button() == Qt.RightButton): return # let the mousePress/Move/Release-Events handle it if event.type() == QTabletEvent.TabletPress: self.tablet_press_pos = event.pos() self.ignore_mouse_event = True if event.button() == Qt.LeftButton: if self.stylus_mode == 'comment': new_drawing = self.create_and_place_drawing__cmd( self.mapToScene(self.tablet_press_pos), config=self.stylus_modes_widget.get_pen_settings()) self.current_drawing = new_drawing self.drawing = True elif event.button() == Qt.RightButton: self.panning = True self.pan_last_x = event.x() self.pan_last_y = event.y() elif event.type() == QTabletEvent.TabletMove: self.ignore_mouse_event = True if self.panning: self.pan(event.pos()) elif event.pointerType() == QTabletEvent.Eraser: if self.stylus_mode == 'comment': for i in self.items(event.pos()): if find_type_in_object(i, DrawingObject): self.remove_drawing(i) break elif self.stylus_mode == 'comment' and self.drawing: mapped = self.mapToScene( QPoint(event.posF().x(), event.posF().y())) # rest = QPointF(event.posF().x()%1, event.posF().y()%1) # exact = QPointF(mapped.x()+rest.x()%1, mapped.y()+rest.y()%1) # TODO: use exact position (event.posF() ). Problem: mapToScene() only uses QPoint, not QPointF. The # calculation above didn't work if self.current_drawing.try_to_append_point(mapped): self.current_drawing.stroke_weights.append( event.pressure()) self.current_drawing.update() self.viewport().update() elif event.type() == QTabletEvent.TabletRelease: if self.panning: self.panning = False if self.stylus_mode == 'comment' and self.drawing: Debugger.debug('drawing obj finished') self.current_drawing.finished() self.current_drawing = None self.drawing = False def dragEnterEvent(self, event): if event.mimeData().hasFormat('text/plain'): event.acceptProposedAction() def dragMoveEvent(self, event): if event.mimeData().hasFormat('text/plain'): event.acceptProposedAction() def dropEvent(self, event): text = event.mimeData().text() item: QListWidgetItem = event.mimeData() Debugger.debug('drop received in Flow:', text) j_obj = None type = '' try: j_obj = json.loads(text) type = j_obj['type'] except Exception: return if type == 'variable': self.show_node_choice_widget( event.pos(), # only show get_var and set_var nodes [ n for n in self.all_nodes if find_type_in_object(n, GetVariable_Node) or find_type_in_object(n, SetVariable_Node) ]) def drawBackground(self, painter, rect): painter.fillRect(rect.intersected(self.sceneRect()), QColor('#333333')) painter.setPen(Qt.NoPen) painter.drawRect(self.sceneRect()) self.set_stylus_proxy_pos( ) # has to be called here instead of in drawForeground to prevent lagging self.set_zoom_proxy_pos() def drawForeground(self, painter, rect): """Draws all connections and borders around selected items.""" pen = QPen() if Design.flow_theme == 'dark std': # pen.setColor('#BCBBF2') pen.setWidth(5) pen.setCapStyle(Qt.RoundCap) elif Design.flow_theme == 'dark tron': # pen.setColor('#452666') pen.setWidth(4) pen.setCapStyle(Qt.RoundCap) elif Design.flow_theme == 'ghostly' or Design.flow_theme == 'blender': pen.setWidth(2) pen.setCapStyle(Qt.RoundCap) # DRAW CONNECTIONS for ni in self.all_node_instances: for o in ni.outputs: for cpi in o.connected_port_instances: if o.type_ == 'data': pen.setStyle(Qt.DashLine) elif o.type_ == 'exec': pen.setStyle(Qt.SolidLine) path = self.connection_path( o.gate.get_scene_center_pos(), cpi.gate.get_scene_center_pos()) w = path.boundingRect().width() h = path.boundingRect().height() gradient = QRadialGradient(path.boundingRect().center(), pythagoras(w, h) / 2) r = 0 g = 0 b = 0 if Design.flow_theme == 'dark std': r = 188 g = 187 b = 242 elif Design.flow_theme == 'dark tron': r = 0 g = 120 b = 180 elif Design.flow_theme == 'ghostly' or Design.flow_theme == 'blender': r = 0 g = 17 b = 25 gradient.setColorAt(0.0, QColor(r, g, b, 255)) gradient.setColorAt(0.75, QColor(r, g, b, 200)) gradient.setColorAt(0.95, QColor(r, g, b, 0)) gradient.setColorAt(1.0, QColor(r, g, b, 0)) pen.setBrush(gradient) painter.setPen(pen) painter.drawPath(path) # DRAW CURRENTLY DRAGGED CONNECTION if self.dragging_connection: pen = QPen('#101520') pen.setWidth(3) pen.setStyle(Qt.DotLine) painter.setPen(pen) gate_pos = self.gate_selected.get_scene_center_pos() if self.gate_selected.parent_port_instance.direction == 'output': painter.drawPath( self.connection_path(gate_pos, self.last_mouse_move_pos)) else: painter.drawPath( self.connection_path(self.last_mouse_move_pos, gate_pos)) # DRAW SELECTED NIs BORDER for ni in self.selected_node_instances(): pen = QPen(QColor('#245d75')) pen.setWidth(3) painter.setPen(pen) painter.setBrush(Qt.NoBrush) size_factor = 1.2 x = ni.pos().x() - ni.boundingRect().width() / 2 * size_factor y = ni.pos().y() - ni.boundingRect().height() / 2 * size_factor w = ni.boundingRect().width() * size_factor h = ni.boundingRect().height() * size_factor painter.drawRoundedRect(x, y, w, h, 10, 10) # DRAW SELECTED DRAWINGS BORDER for p_o in self.selected_drawings(): pen = QPen(QColor('#a3cc3b')) pen.setWidth(2) painter.setPen(pen) painter.setBrush(Qt.NoBrush) size_factor = 1.05 x = p_o.pos().x() - p_o.width / 2 * size_factor y = p_o.pos().y() - p_o.height / 2 * size_factor w = p_o.width * size_factor h = p_o.height * size_factor painter.drawRoundedRect(x, y, w, h, 6, 6) painter.drawEllipse(p_o.pos().x(), p_o.pos().y(), 2, 2) def get_viewport_img(self): self.hide_proxies() img = QImage(self.viewport().rect().width(), self.viewport().height(), QImage.Format_ARGB32) img.fill(Qt.transparent) painter = QPainter(img) painter.setRenderHint(QPainter.Antialiasing) self.render(painter, self.viewport().rect(), self.viewport().rect()) self.show_proxies() return img def get_whole_scene_img(self): self.hide_proxies() img = QImage(self.sceneRect().width() / self.total_scale_div, self.sceneRect().height() / self.total_scale_div, QImage.Format_RGB32) img.fill(Qt.transparent) painter = QPainter(img) painter.setRenderHint(QPainter.Antialiasing) rect = QRectF() rect.setLeft(-self.viewport().pos().x()) rect.setTop(-self.viewport().pos().y()) rect.setWidth(img.rect().width()) rect.setHeight(img.rect().height()) # rect is right... but it only renders from the viewport's point down-and rightwards, not from topleft (0,0) ... self.render(painter, rect, rect.toRect()) self.show_proxies() return img # PROXY POSITIONS def set_zoom_proxy_pos(self): self.zoom_proxy.setPos( self.mapToScene(self.viewport().width() - self.zoom_widget.width(), 0)) def set_stylus_proxy_pos(self): self.stylus_modes_proxy.setPos( self.mapToScene( self.viewport().width() - self.stylus_modes_widget.width() - self.zoom_widget.width(), 0)) def hide_proxies(self): self.stylus_modes_proxy.hide() self.zoom_proxy.hide() def show_proxies(self): self.stylus_modes_proxy.show() self.zoom_proxy.show() # NODE CHOICE WIDGET def show_node_choice_widget(self, pos, nodes=None): """Opens the node choice dialog in the scene.""" # calculating position self.node_place_pos = self.mapToScene(pos) dialog_pos = QPoint(pos.x() + 1, pos.y() + 1) # ensure that the node_choice_widget stays in the viewport if dialog_pos.x() + self.node_choice_widget.width( ) / self.total_scale_div > self.viewport().width(): dialog_pos.setX(dialog_pos.x() - (dialog_pos.x() + self.node_choice_widget.width() / self.total_scale_div - self.viewport().width())) if dialog_pos.y() + self.node_choice_widget.height( ) / self.total_scale_div > self.viewport().height(): dialog_pos.setY(dialog_pos.y() - (dialog_pos.y() + self.node_choice_widget.height() / self.total_scale_div - self.viewport().height())) dialog_pos = self.mapToScene(dialog_pos) # open nodes dialog # the dialog emits 'node_chosen' which is connected to self.place_node, # so this all continues at self.place_node below self.node_choice_widget.update_list( nodes if nodes is not None else self.all_nodes) self.node_choice_widget.update_view() self.node_choice_proxy.setPos(dialog_pos) self.node_choice_proxy.show() self.node_choice_widget.refocus() def hide_node_choice_widget(self): self.node_choice_proxy.hide() self.node_choice_widget.clearFocus() self.auto_connection_gate = None # PAN def pan(self, new_pos): self.horizontalScrollBar().setValue( self.horizontalScrollBar().value() - (new_pos.x() - self.pan_last_x)) self.verticalScrollBar().setValue(self.verticalScrollBar().value() - (new_pos.y() - self.pan_last_y)) self.pan_last_x = new_pos.x() self.pan_last_y = new_pos.y() # ZOOM def zoom_in(self, amount): local_viewport_center = QPoint(self.viewport().width() / 2, self.viewport().height() / 2) self.zoom(local_viewport_center, self.mapToScene(local_viewport_center), amount) def zoom_out(self, amount): local_viewport_center = QPoint(self.viewport().width() / 2, self.viewport().height() / 2) self.zoom(local_viewport_center, self.mapToScene(local_viewport_center), -amount) def zoom(self, p_abs, p_mapped, angle): by = 0 velocity = 2 * (1 / self.current_scale) + 0.5 if velocity > 3: velocity = 3 direction = '' if angle > 0: by = 1 + (angle / 360 * 0.1 * velocity) direction = 'in' elif angle < 0: by = 1 - (-angle / 360 * 0.1 * velocity) direction = 'out' else: by = 1 scene_rect_width = self.mapFromScene( self.sceneRect()).boundingRect().width() scene_rect_height = self.mapFromScene( self.sceneRect()).boundingRect().height() if direction == 'in': if self.current_scale * by < 3: self.scale(by, by) self.current_scale *= by elif direction == 'out': if scene_rect_width * by >= self.viewport().size().width( ) and scene_rect_height * by >= self.viewport().size().height(): self.scale(by, by) self.current_scale *= by w = self.viewport().width() h = self.viewport().height() wf = self.mapToScene(QPoint(w - 1, 0)).x() - self.mapToScene( QPoint(0, 0)).x() hf = self.mapToScene(QPoint(0, h - 1)).y() - self.mapToScene( QPoint(0, 0)).y() lf = p_mapped.x() - p_abs.x() * wf / w tf = p_mapped.y() - p_abs.y() * hf / h self.ensureVisible(lf, tf, wf, hf, 0, 0) target_rect = QRectF(QPointF(lf, tf), QSizeF(wf, hf)) self.total_scale_div = target_rect.width() / self.viewport().width() self.ensureVisible(target_rect, 0, 0) # NODE PLACING: ----- def create_node_instance(self, node, config): return self.get_node_instance_class_from_node(node)(node, self, config) def add_node_instance(self, ni, pos=None): self.scene().addItem(ni) ni.enable_personal_logs() if pos: ni.setPos(pos) # select new NI self.scene().clearSelection() ni.setSelected(True) self.all_node_instances.append(ni) def add_node_instances(self, node_instances): for ni in node_instances: self.add_node_instance(ni) def remove_node_instance(self, ni): ni.about_to_remove_from_scene() # to stop running threads self.scene().removeItem(ni) self.all_node_instances.remove(ni) def place_new_node_by_shortcut(self): # Shift+P point_in_viewport = None selected_NIs = self.selected_node_instances() if len(selected_NIs) > 0: x = selected_NIs[-1].pos().x() + 150 y = selected_NIs[-1].pos().y() self.node_place_pos = QPointF(x, y) point_in_viewport = self.mapFromScene(QPoint(x, y)) else: # place in center viewport_x = self.viewport().width() / 2 viewport_y = self.viewport().height() / 2 point_in_viewport = QPointF(viewport_x, viewport_y).toPoint() self.node_place_pos = self.mapToScene(point_in_viewport) self.node_choice_widget.reset_list() self.show_node_choice_widget(point_in_viewport) def place_nodes_from_config(self, nodes_config, offset_pos: QPoint = QPoint(0, 0)): new_node_instances = [] for n_c in nodes_config: # find parent node by title, type, package name and description as identifiers parent_node_title = n_c['parent node title'] parent_node_package_name = n_c['parent node package'] parent_node = None for pn in self.all_nodes: pn: Node = pn if pn.title == parent_node_title and \ pn.package == parent_node_package_name: parent_node = pn break new_NI = self.create_node_instance(parent_node, n_c) self.add_node_instance( new_NI, QPoint(n_c['position x'], n_c['position y']) + offset_pos) new_node_instances.append(new_NI) return new_node_instances def place_node__cmd(self, node: Node, config=None): new_NI = self.create_node_instance(node, config) place_command = PlaceNodeInstanceInScene_Command( self, new_NI, self.node_place_pos) self.undo_stack.push(place_command) if self.auto_connection_gate: self.try_conn_gate_and_ni(self.auto_connection_gate, place_command.node_instance) return place_command.node_instance def remove_node_instance_triggered( self, node_instance): # called from context menu of NodeInstance if node_instance in self.selected_node_instances(): self.undo_stack.push( RemoveComponents_Command(self, self.scene().selectedItems())) else: self.undo_stack.push( RemoveComponents_Command(self, [node_instance])) def get_node_instance_class_from_node(self, node): return self.all_node_instance_classes[node] def get_custom_input_widget_classes(self): return self.parent_script.main_window.custom_node_input_widget_classes def connect_nodes_from_config(self, node_instances, connections_config): for c in connections_config: c_parent_node_instance_index = c['parent node instance index'] c_output_port_index = c['output port index'] c_connected_node_instance = c['connected node instance'] c_connected_input_port_index = c['connected input port index'] if c_connected_node_instance is not None: # which can be the case when pasting parent_node_instance = node_instances[ c_parent_node_instance_index] connected_node_instance = node_instances[ c_connected_node_instance] self.connect_gates( parent_node_instance.outputs[c_output_port_index].gate, connected_node_instance. inputs[c_connected_input_port_index].gate) # DRAWINGS def create_drawing(self, config=None): new_drawing = DrawingObject(self, config) return new_drawing def add_drawing(self, drawing_obj, pos=None): self.scene().addItem(drawing_obj) if pos: drawing_obj.setPos(pos) self.drawings.append(drawing_obj) def add_drawings(self, drawings): for d in drawings: self.add_drawing(d) def remove_drawing(self, drawing): self.scene().removeItem(drawing) self.drawings.remove(drawing) def place_drawings_from_config(self, drawings, offset_pos=QPoint(0, 0)): """ :param offset_pos: position difference between the center of all selected items when they were copied/cut and the current mouse pos which is supposed to be the new center :param drawings: the drawing objects """ new_drawings = [] for d_config in drawings: x = d_config['pos x'] + offset_pos.x() y = d_config['pos y'] + offset_pos.y() new_drawing = self.create_drawing(config=d_config) self.add_drawing(new_drawing, QPointF(x, y)) new_drawings.append(new_drawing) return new_drawings def create_and_place_drawing__cmd(self, pos, config=None): new_drawing_obj = self.create_drawing(config) place_command = PlaceDrawingObject_Command(self, pos, new_drawing_obj) self.undo_stack.push(place_command) return new_drawing_obj def move_selected_copmonents__cmd(self, x, y): new_rel_pos = QPointF(x, y) # if one node item would leave the scene (f.ex. pos.x < 0), stop left = False for i in self.scene().selectedItems(): new_pos = i.pos() + new_rel_pos if new_pos.x() - i.width / 2 < 0 or \ new_pos.x() + i.width / 2 > self.scene().width() or \ new_pos.y() - i.height / 2 < 0 or \ new_pos.y() + i.height / 2 > self.scene().height(): left = True break if not left: # moving the items items_group = self.scene().createItemGroup( self.scene().selectedItems()) items_group.moveBy(new_rel_pos.x(), new_rel_pos.y()) self.scene().destroyItemGroup(items_group) # saving the command self.undo_stack.push( MoveComponents_Command(self, self.scene().selectedItems(), p_from=-new_rel_pos, p_to=QPointF(0, 0))) self.viewport().repaint() def move_selected_nodes_left(self): self.move_selected_copmonents__cmd(-40, 0) def move_selected_nodes_up(self): self.move_selected_copmonents__cmd(0, -40) def move_selected_nodes_right(self): self.move_selected_copmonents__cmd(+40, 0) def move_selected_nodes_down(self): self.move_selected_copmonents__cmd(0, +40) def selected_components_moved(self, pos_diff): items_list = self.scene().selectedItems() self.undo_stack.push( MoveComponents_Command(self, items_list, p_from=-pos_diff, p_to=QPointF(0, 0))) def selected_node_instances(self): selected_NIs = [] for i in self.scene().selectedItems(): if find_type_in_object(i, NodeInstance): selected_NIs.append(i) return selected_NIs def selected_drawings(self): selected_drawings = [] for i in self.scene().selectedItems(): if find_type_in_object(i, DrawingObject): selected_drawings.append(i) return selected_drawings def select_all(self): for i in self.scene().items(): if i.ItemIsSelectable: i.setSelected(True) self.viewport().repaint() def select_components(self, comps): self.scene().clearSelection() for c in comps: c.setSelected(True) def copy(self): # ctrl+c data = { 'nodes': self.get_node_instances_json_data(self.selected_node_instances()), 'connections': self.get_connections_json_data(self.selected_node_instances()), 'drawings': self.get_drawings_json_data(self.selected_drawings()) } QGuiApplication.clipboard().setText(json.dumps(data)) def cut(self): # called from shortcut ctrl+x data = { 'nodes': self.get_node_instances_json_data(self.selected_node_instances()), 'connections': self.get_connections_json_data(self.selected_node_instances()), 'drawings': self.get_drawings_json_data(self.selected_drawings()) } QGuiApplication.clipboard().setText(json.dumps(data)) self.remove_selected_components() def paste(self): data = {} try: data = json.loads(QGuiApplication.clipboard().text()) except Exception as e: return self.clear_selection() # calculate offset positions = [] for d in data['drawings']: positions.append({'x': d['pos x'], 'y': d['pos y']}) for n in data['nodes']: positions.append({'x': n['position x'], 'y': n['position y']}) offset_for_middle_pos = QPointF(0, 0) if len(positions) > 0: rect = QRectF(positions[0]['x'], positions[0]['y'], 0, 0) for p in positions: x = p['x'] y = p['y'] if x < rect.left(): rect.setLeft(x) if x > rect.right(): rect.setRight(x) if y < rect.top(): rect.setTop(y) if y > rect.bottom(): rect.setBottom(y) offset_for_middle_pos = self.last_mouse_move_pos - rect.center() self.undo_stack.push(Paste_Command(self, data, offset_for_middle_pos)) def add_component(self, e): if find_type_in_object(e, NodeInstance): self.add_node_instance(e) elif find_type_in_object(e, DrawingObject): self.add_drawing(e) def remove_component(self, e): if find_type_in_object(e, NodeInstance): self.remove_node_instance(e) elif find_type_in_object(e, DrawingObject): self.remove_drawing(e) def remove_selected_components(self): self.undo_stack.push( RemoveComponents_Command(self, self.scene().selectedItems())) self.viewport().update() # NODE SELECTION: ---- def clear_selection(self): self.scene().clearSelection() # CONNECTIONS: ---- def connect_gates__cmd(self, parent_gate: PortInstanceGate, child_gate: PortInstanceGate): self.undo_stack.push( ConnectGates_Command(self, parent_port=parent_gate.parent_port_instance, child_port=child_gate.parent_port_instance)) def connect_gates(self, parent_gate: PortInstanceGate, child_gate: PortInstanceGate): parent_port_instance: PortInstance = parent_gate.parent_port_instance child_port_instance: PortInstance = child_gate.parent_port_instance # if they, their directions and their parent node instances are not equal and if their types are equal if parent_port_instance.direction != child_port_instance.direction and \ parent_port_instance.parent_node_instance != child_port_instance.parent_node_instance and \ parent_port_instance.type_ == child_port_instance.type_: try: # remove connection if port instances are already connected index = parent_port_instance.connected_port_instances.index( child_port_instance) parent_port_instance.connected_port_instances.remove( child_port_instance) parent_port_instance.disconnected() child_port_instance.connected_port_instances.remove( parent_port_instance) child_port_instance.disconnected() except ValueError: # connect port instances # remove all connections from parent port instance if it's a data input if parent_port_instance.direction == 'input' and parent_port_instance.type_ == 'data': for cpi in parent_port_instance.connected_port_instances: self.connect_gates__cmd( parent_gate, cpi.gate) # actually disconnects the gates # remove all connections from child port instance it it's a data input if child_port_instance.direction == 'input' and child_port_instance.type_ == 'data': for cpi in child_port_instance.connected_port_instances: self.connect_gates__cmd( child_gate, cpi.gate) # actually disconnects the gates parent_port_instance.connected_port_instances.append( child_port_instance) child_port_instance.connected_port_instances.append( parent_port_instance) parent_port_instance.connected() child_port_instance.connected() self.viewport().repaint() def try_conn_gate_and_ni(self, parent_gate: PortInstanceGate, child_ni: NodeInstance): parent_port_instance: PortInstance = parent_gate.parent_port_instance if parent_port_instance.direction == 'output': for inp in child_ni.inputs: if parent_port_instance.type_ == inp.type_: self.connect_gates__cmd(parent_gate, inp.gate) return elif parent_port_instance.direction == 'input': for out in child_ni.outputs: if parent_port_instance.type_ == out.type_: self.connect_gates__cmd(parent_gate, out.gate) return @staticmethod def connection_path(p1: QPointF, p2: QPointF): """Returns the nice looking QPainterPath of a connection for two given points.""" path = QPainterPath() path.moveTo(p1) distance_x = abs(p1.x()) - abs(p2.x()) distance_y = abs(p1.y()) - abs(p2.y()) if ((p1.x() < p2.x() - 30) or math.sqrt((distance_x**2) + (distance_y**2)) < 100) and (p1.x() < p2.x()): path.cubicTo(p1.x() + ((p2.x() - p1.x()) / 2), p1.y(), p1.x() + ((p2.x() - p1.x()) / 2), p2.y(), p2.x(), p2.y()) elif p2.x() < p1.x() - 100 and abs(distance_x) / 2 > abs(distance_y): path.cubicTo(p1.x() + 100 + (p1.x() - p2.x()) / 10, p1.y(), p1.x() + 100 + (p1.x() - p2.x()) / 10, p1.y() - (distance_y / 2), p1.x() - (distance_x / 2), p1.y() - (distance_y / 2)) path.cubicTo(p2.x() - 100 - (p1.x() - p2.x()) / 10, p2.y() + (distance_y / 2), p2.x() - 100 - (p1.x() - p2.x()) / 10, p2.y(), p2.x(), p2.y()) else: path.cubicTo(p1.x() + 100 + (p1.x() - p2.x()) / 3, p1.y(), p2.x() - 100 - (p1.x() - p2.x()) / 3, p2.y(), p2.x(), p2.y()) return path # GET JSON DATA def get_json_data(self): flow_dict = { 'algorithm mode': 'data flow' if self.algorithm_mode.mode_data_flow else 'exec flow', 'viewport update mode': 'sync' if self.viewport_update_mode.sync else 'async', 'nodes': self.get_node_instances_json_data(self.all_node_instances), 'connections': self.get_connections_json_data(self.all_node_instances), 'drawings': self.get_drawings_json_data(self.drawings) } return flow_dict def get_node_instances_json_data(self, node_instances): script_node_instances_list = [] for ni in node_instances: node_instance_dict = ni.get_json_data() script_node_instances_list.append(node_instance_dict) return script_node_instances_list def get_connections_json_data(self, node_instances, only_with_connections_to=None): script_ni_connections_list = [] for ni in node_instances: for out in ni.outputs: if len(out.connected_port_instances) > 0: for connected_port in out.connected_port_instances: # this only applies when saving config data through deleting node instances: if only_with_connections_to is not None and \ connected_port.parent_node_instance not in only_with_connections_to and \ ni not in only_with_connections_to: continue # because I am not allowed to save connections between nodes connected to each other and both # connected to the deleted node, only the connections to the deleted node shall be saved connection_dict = { 'parent node instance index': node_instances.index(ni), 'output port index': ni.outputs.index(out) } # yes, very important: when copying components, there might be connections going outside the # selected lists, these should be ignored. When saving a project, all components are considered, # so then the index values will never be none connected_ni_index = node_instances.index(connected_port.parent_node_instance) if \ node_instances.__contains__(connected_port.parent_node_instance) else \ None connection_dict[ 'connected node instance'] = connected_ni_index connected_ip_index = connected_port.parent_node_instance.inputs.index(connected_port) if \ connected_ni_index is not None else None connection_dict[ 'connected input port index'] = connected_ip_index script_ni_connections_list.append(connection_dict) return script_ni_connections_list def get_drawings_json_data(self, drawings): drawings_list = [] for drawing in drawings: drawing_dict = drawing.get_json_data() drawings_list.append(drawing_dict) return drawings_list
#self.setText(" undo command {} - {}:{} = ".format(self._dictionary, self._key, self._value)) dictionary[self._key] = self._old_value def redo(self, dictionary): #self.setText(" do/redo command {} + {}:{} = ".format(self._dictionary, self._key, self._value)) dictionary[self._key] = self._new_value if __name__ == '__main__': undo_stack = QUndoStack() dictionary = {"a": "AAA", "b": "BBB"} print('* initial dict', dictionary) undo_stack.push(AppendCommand(dictionary, "c", "CCC")) print(undo_stack.undoText(), dictionary) undo_stack.push(AppendCommand(dictionary, "d", "DDD")) print(undo_stack.undoText(), dictionary) undo_stack.undo() print(undo_stack.redoText(), dictionary) undo_stack.undo() print(undo_stack.redoText(), dictionary) undo_stack.redo() print(undo_stack.undoText(), dictionary) undo_stack.push(ModifyCommand(dictionary, "a", "---"))
class NodeGraph(QtCore.QObject): """ base node graph controller. Args: tab_search_key(str): hotkey for the tab search widget (default: "tab"). """ #: signal for when a node has been created in the node graph. node_created = QtCore.Signal(NodeObject) #: signal for when a node is selected. node_selected = QtCore.Signal(NodeObject) #: signal for when a node has been connected. port_connected = QtCore.Signal(Port, Port) #: signal for when drop data has been added to the graph. data_dropped = QtCore.Signal(QtCore.QMimeData, QtCore.QPoint) def __init__(self, parent=None, tab_search_key='tab'): super(NodeGraph, self).__init__(parent) self.setObjectName('NodeGraphQt') self._model = NodeGraphModel() self._viewer = NodeViewer() self._vendor = NodeVendor() self._undo_stack = QUndoStack(self) tab = QAction('Search Nodes', self) tab.setShortcut(tab_search_key) tab.triggered.connect(self._toggle_tab_search) self._viewer.addAction(tab) self._wire_signals() def _wire_signals(self): # internal signals. self._viewer.search_triggered.connect(self._on_search_triggered) self._viewer.connection_changed.connect(self._on_connection_changed) self._viewer.moved_nodes.connect(self._on_nodes_moved) # pass through signals. self._viewer.node_selected.connect(self._on_node_selected) self._viewer.data_dropped.connect(self._on_node_data_dropped) def _toggle_tab_search(self): """ toggle the tab search widget. """ self._viewer.tab_search_set_nodes(self._vendor.names) self._viewer.tab_search_toggle() def _on_node_selected(self, node_id): """ called when a node in the viewer is selected on left click. (emits the node object when the node is clicked) Args: node_id (str): node id emitted by the viewer. """ node = self.get_node_by_id(node_id) self.node_selected.emit(node) def _on_node_data_dropped(self, data, pos): """ called when data has been dropped on the viewer. Args: data (QtCore.QMimeData): mime data. pos (QtCore.QPoint): scene position relative to the drop. """ self.data_dropped.emit(data, pos) def _on_nodes_moved(self, node_data): """ called when selected nodes in the viewer has changed position. Args: node_data (dict): {<node_view>: <previous_pos>} """ self._undo_stack.beginMacro('moved nodes') for node_view, prev_pos in node_data.items(): node = self._model.nodes[node_view.id] self._undo_stack.push(NodeMovedCmd(node, node.pos(), prev_pos)) self._undo_stack.endMacro() def _on_search_triggered(self, node_type, pos): """ called when the tab search widget is triggered in the viewer. Args: node_type (str): node identifier. pos (tuple): x,y position for the node. """ self.create_node(node_type, pos=pos) def _on_connection_changed(self, disconnected, connected): """ called when a pipe connection has been changed in the viewer. Args: disconnected (list[list[widgets.port.PortItem]): pair list of port view items. connected (list[list[widgets.port.PortItem]]): pair list of port view items. """ if not (disconnected or connected): return label = 'connected node(s)' if connected else 'disconnected node(s)' ptypes = {'in': 'inputs', 'out': 'outputs'} self._undo_stack.beginMacro(label) for p1_view, p2_view in disconnected: node1 = self._model.nodes[p1_view.node.id] node2 = self._model.nodes[p2_view.node.id] port1 = getattr(node1, ptypes[p1_view.port_type])()[p1_view.name] port2 = getattr(node2, ptypes[p2_view.port_type])()[p2_view.name] port1.disconnect_from(port2) for p1_view, p2_view in connected: node1 = self._model.nodes[p1_view.node.id] node2 = self._model.nodes[p2_view.node.id] port1 = getattr(node1, ptypes[p1_view.port_type])()[p1_view.name] port2 = getattr(node2, ptypes[p2_view.port_type])()[p2_view.name] port1.connect_to(port2) self._undo_stack.endMacro() @property def model(self): """ Returns the model used to store the node graph data. Returns: NodeGraphQt.base.model.NodeGraphModel: node graph model. """ return self._model def show(self): """ Show node graph viewer widget this is just a convenience function to :meth:`NodeGraph.viewer().show()`. """ self._viewer.show() def close(self): """ Close node graph NodeViewer widget this is just a convenience function to :meth:`NodeGraph.viewer().close()`. """ self._viewer.close() def viewer(self): """ Return the node graph viewer widget. Returns: NodeGraphQt.widgets.viewer.NodeViewer: viewer widget. """ return self._viewer def scene(self): """ Return the scene object. Returns: NodeGraphQt.widgets.scene.NodeScene: node scene. """ return self._viewer.scene() def undo_stack(self): """ Returns the undo stack used in the node graph Returns: QtWidgets.QUndoStack: undo stack. """ return self._undo_stack def clear_undo_stack(self): """ Clears the undo stack. (convenience function to :meth:`NodeGraph.undo_stack().clear`) """ self._undo_stack.clear() def begin_undo(self, name='undo'): """ Start of an undo block followed by a :meth:`NodeGraph.end_undo()`. Args: name (str): name for the undo block. """ self._undo_stack.beginMacro(name) def end_undo(self): """ End of an undo block started by :meth:`NodeGraph.begin_undo()`. """ self._undo_stack.endMacro() def context_menu(self): """ Returns the node graph root context menu object. Returns: Menu: context menu object. """ return Menu(self._viewer, self._viewer.context_menu()) def acyclic(self): """ Returns true if the current node graph is acyclic. Returns: bool: true if acyclic (default: True). """ return self._model.acyclic def set_acyclic(self, mode=True): """ Set the node graph to be acyclic or not. (default=True) Args: mode (bool): false to disable acyclic. """ self._model.acyclic = mode self._viewer.acyclic = mode def set_pipe_layout(self, layout='curved'): """ Set node graph pipes to be drawn straight or curved by default all pipes are set curved. (default='curved') Args: layout (str): 'straight' or 'curved' """ self._viewer.set_pipe_layout(layout) def fit_to_selection(self): """ Sets the zoom level to fit selected nodes. If no nodes are selected then all nodes in the graph will be framed. """ nodes = self.selected_nodes() or self.all_nodes() if not nodes: return self._viewer.zoom_to_nodes([n.view for n in nodes]) def reset_zoom(self): """ Reset the zoom level """ self._viewer.reset_zoom() def set_zoom(self, zoom=0): """ Set the zoom factor of the Node Graph the default is 0.0 Args: zoom (float): zoom factor (max zoom out -0.9 / max zoom in 2.0) """ self._viewer.set_zoom(zoom) def get_zoom(self): """ Get the current zoom level of the node graph. Returns: float: the current zoom level. """ return self._viewer.get_zoom() def center_on(self, nodes=None): """ Center the node graph on the given nodes or all nodes by default. Args: nodes (list[NodeGraphQt.Node]): a list of nodes. """ self._viewer.center_selection(nodes) def center_selection(self): """ Centers on the current selected nodes. """ nodes = self._viewer.selected_nodes() self._viewer.center_selection(nodes) def registered_nodes(self): """ Return a list of all node types that have been registered. To register a node see :meth:`NodeGraph.register_node` Returns: list[str]: list of node type identifiers. """ return sorted(self._vendor.nodes.keys()) def register_node(self, node, alias=None): """ Register the node to the node graph vendor. Args: node (NodeGraphQt.NodeObject): node. alias (str): custom alias name for the node type. """ self._vendor.register_node(node, alias) def create_node(self, node_type, name=None, selected=True, color=None, pos=None): """ Create a new node in the node graph. (To list all node types see :meth:`NodeGraph.registered_nodes`) Args: node_type (str): node instance type. name (str): set name of the node. selected (bool): set created node to be selected. color (tuple or str): node color (255, 255, 255) or '#FFFFFF'. pos (list[int, int]): initial x, y position for the node (default: (0, 0)). Returns: NodeGraphQt.Node: the created instance of the node. """ NodeCls = self._vendor.create_node_instance(node_type) if NodeCls: node = NodeCls() node._graph = self node.model._graph_model = self.model wid_types = node.model.__dict__.pop('_TEMP_property_widget_types') prop_attrs = node.model.__dict__.pop('_TEMP_property_attrs') graph_attrs = self.model.node_property_attrs if node.type not in graph_attrs.keys(): graph_attrs[node.type] = { n: { 'widget_type': wt } for n, wt in wid_types.items() } for pname, pattrs in prop_attrs.items(): graph_attrs[node.type][pname].update(pattrs) node.NODE_NAME = self.get_unique_name(name or node.NODE_NAME) node.model.name = node.NODE_NAME node.model.selected = selected if color: if isinstance(color, str): color = color[1:] if color[0] is '#' else color color = tuple(int(color[i:i + 2], 16) for i in (0, 2, 4)) node.model.color = color if pos: node.model.pos = [float(pos[0]), float(pos[1])] node.update() undo_cmd = NodeAddedCmd(self, node, node.model.pos) undo_cmd.setText('created node') self._undo_stack.push(undo_cmd) self.node_created.emit(node) return node raise Exception('\n\n>> Cannot find node:\t"{}"\n'.format(node_type)) def add_node(self, node): """ Add a node into the node graph. Args: node (NodeGraphQt.Node): node object. """ assert isinstance(node, NodeObject), 'node must be a Node instance.' wid_types = node.model.__dict__.pop('_TEMP_property_widget_types') prop_attrs = node.model.__dict__.pop('_TEMP_property_attrs') graph_attrs = self.model.node_property_attrs if node.type not in graph_attrs.keys(): graph_attrs[node.type] = { n: { 'widget_type': wt } for n, wt in wid_types.items() } for pname, pattrs in prop_attrs.items(): graph_attrs[node.type][pname].update(pattrs) node._graph = self node.NODE_NAME = self.get_unique_name(node.NODE_NAME) node.model._graph_model = self.model node.model.name = node.NODE_NAME node.update() self._undo_stack.push(NodeAddedCmd(self, node)) def delete_node(self, node): """ Remove the node from the node graph. Args: node (NodeGraphQt.Node): node object. """ assert isinstance(node, NodeObject), \ 'node must be a instance of a NodeObject.' self._undo_stack.push(NodeRemovedCmd(self, node)) def delete_nodes(self, nodes): """ Remove a list of specified nodes from the node graph. Args: nodes (list[NodeGraphQt.Node]): list of node instances. """ self._undo_stack.beginMacro('deleted nodes') [self.delete_node(n) for n in nodes] self._undo_stack.endMacro() def all_nodes(self): """ Return all nodes in the node graph. Returns: list[NodeGraphQt.Node]: list of nodes. """ return list(self._model.nodes.values()) def selected_nodes(self): """ Return all selected nodes that are in the node graph. Returns: list[NodeGraphQt.Node]: list of nodes. """ nodes = [] for item in self._viewer.selected_nodes(): node = self._model.nodes[item.id] nodes.append(node) return nodes def select_all(self): """ Select all nodes in the node graph. """ self._undo_stack.beginMacro('select all') for node in self.all_nodes(): node.set_selected(True) self._undo_stack.endMacro() def clear_selection(self): """ Clears the selection in the node graph. """ self._undo_stack.beginMacro('deselected nodes') for node in self.all_nodes(): node.set_selected(False) self._undo_stack.endMacro() def get_node_by_id(self, node_id=None): """ Returns the node from the node id string. Args: node_id (str): node id (:meth:`NodeObject.id`) Returns: NodeGraphQt.NodeObject: node object. """ return self._model.nodes.get(node_id) def get_node_by_name(self, name): """ Returns node that matches the name. Args: name (str): name of the node. Returns: NodeGraphQt.NodeObject: node object. """ for node_id, node in self._model.nodes.items(): if node.name() == name: return node def get_unique_name(self, name): """ Creates a unique node name to avoid having nodes with the same name. Args: name (str): node name. Returns: str: unique node name. """ name = ' '.join(name.split()) node_names = [n.name() for n in self.all_nodes()] if name not in node_names: return name regex = re.compile('[\w ]+(?: )*(\d+)') search = regex.search(name) if not search: for x in range(1, len(node_names) + 1): new_name = '{} {}'.format(name, x) if new_name not in node_names: return new_name version = search.group(1) name = name[:len(version) * -1].strip() for x in range(1, len(node_names) + 1): new_name = '{} {}'.format(name, x) if new_name not in node_names: return new_name def current_session(self): """ Returns the file path to the currently loaded session. Returns: str: path to the currently loaded session """ return self._model.session def clear_session(self): """ Clears the current node graph session. """ for n in self.all_nodes(): self.delete_node(n) self._undo_stack.clear() self._model.session = None def _serialize(self, nodes): """ serialize nodes to a dict. (used internally by the node graph) Args: nodes (list[NodeGraphQt.Nodes]): list of node instances. Returns: dict: serialized data. """ serial_data = {'nodes': {}, 'connections': []} nodes_data = {} for n in nodes: # update the node model. n.update_model() nodes_data.update(n.model.to_dict) for n_id, n_data in nodes_data.items(): serial_data['nodes'][n_id] = n_data inputs = n_data.pop('inputs') if n_data.get('inputs') else {} outputs = n_data.pop('outputs') if n_data.get('outputs') else {} for pname, conn_data in inputs.items(): for conn_id, prt_names in conn_data.items(): for conn_prt in prt_names: pipe = { 'in': [n_id, pname], 'out': [conn_id, conn_prt] } if pipe not in serial_data['connections']: serial_data['connections'].append(pipe) for pname, conn_data in outputs.items(): for conn_id, prt_names in conn_data.items(): for conn_prt in prt_names: pipe = { 'out': [n_id, pname], 'in': [conn_id, conn_prt] } if pipe not in serial_data['connections']: serial_data['connections'].append(pipe) if not serial_data['connections']: serial_data.pop('connections') return serial_data def _deserialize(self, data, relative_pos=False, pos=None): """ deserialize node data. (used internally by the node graph) Args: data (dict): node data. relative_pos (bool): position node relative to the cursor. Returns: list[NodeGraphQt.Nodes]: list of node instances. """ nodes = {} # build the nodes. for n_id, n_data in data.get('nodes', {}).items(): identifier = n_data['type'] NodeCls = self._vendor.create_node_instance(identifier) if NodeCls: node = NodeCls() node._graph = self name = self.get_unique_name(n_data.get('name', node.NODE_NAME)) n_data['name'] = name # set properties. for prop, val in node.model.properties.items(): if prop in n_data.keys(): setattr(node.model, prop, n_data[prop]) # set custom properties. for prop, val in n_data.get('custom', {}).items(): if prop in node.model.custom_properties.keys(): node.model.custom_properties[prop] = val node.update() self._undo_stack.push( NodeAddedCmd(self, node, n_data.get('pos'))) nodes[n_id] = node # build the connections. for connection in data.get('connections', []): nid, pname = connection.get('in', ('', '')) in_node = nodes.get(nid) if not in_node: continue in_port = in_node.inputs().get(pname) if in_node else None nid, pname = connection.get('out', ('', '')) out_node = nodes.get(nid) if not out_node: continue out_port = out_node.outputs().get(pname) if out_node else None if in_port and out_port: self._undo_stack.push(PortConnectedCmd(in_port, out_port)) node_objs = list(nodes.values()) if relative_pos: self._viewer.move_nodes([n.view for n in node_objs]) [setattr(n.model, 'pos', n.view.pos) for n in node_objs] elif pos: self._viewer.move_nodes([n.view for n in node_objs], pos=pos) return node_objs def serialize_session(self): """ Serializes the current node graph layout to a dictionary. Returns: dict: serialized session of the current node layout. """ return self._serialize(self.all_nodes()) def save_session(self, file_path): """ Saves the current node graph session layout to a `JSON` formatted file. Args: file_path (str): path to the saved node layout. """ serliazed_data = self._serialize(self.all_nodes()) file_path = file_path.strip() with open(file_path, 'w') as file_out: json.dump(serliazed_data, file_out, indent=2, separators=(',', ':')) def load_session(self, file_path): """ Load node graph session layout file. Args: file_path (str): path to the serialized layout file. """ file_path = file_path.strip() if not os.path.isfile(file_path): raise IOError('file does not exist.') self.clear_session() try: with open(file_path) as data_file: layout_data = json.load(data_file) except Exception as e: layout_data = None print('Cannot read data from file.\n{}'.format(e)) if not layout_data: return self._deserialize(layout_data) self._undo_stack.clear() self._model.session = file_path def copy_nodes(self, nodes=None): """ Copy nodes to the clipboard. Args: nodes (list[NodeGraphQt.Node]): list of nodes (default: selected nodes). """ nodes = nodes or self.selected_nodes() if not nodes: return False clipboard = QApplication.clipboard() serial_data = self._serialize(nodes) serial_str = json.dumps(serial_data) if serial_str: clipboard.setText(serial_str) return True return False def paste_nodes(self): """ Pastes nodes copied from the clipboard. """ clipboard = QApplication.clipboard() cb_string = clipboard.text() if not cb_string: return self._undo_stack.beginMacro('pasted nodes') serial_data = json.loads(cb_string) self.clear_selection() nodes = self._deserialize(serial_data, True) [n.set_selected(True) for n in nodes] self._undo_stack.endMacro() def duplicate_nodes(self, nodes): """ Create duplicate copy from the list of nodes. Args: nodes (list[NodeGraphQt.Node]): list of nodes. Returns: list[NodeGraphQt.Node]: list of duplicated node instances. """ if not nodes: return self._undo_stack.beginMacro('duplicated nodes') self.clear_selection() serial = self._serialize(nodes) new_nodes = self._deserialize(serial) offset = 50 for n in new_nodes: x, y = n.pos() n.set_pos(x + offset, y + offset) n.set_property('selected', True) self._undo_stack.endMacro() return new_nodes def disable_nodes(self, nodes, mode=None): """ Set weather to Disable or Enable specified nodes. see: :meth:`NodeObject.set_disabled` Args: nodes (list[NodeGraphQt.Node]): list of node instances. mode (bool): (optional) disable state of the nodes. """ if not nodes: return if mode is None: mode = not nodes[0].disabled() if len(nodes) > 1: text = {False: 'enabled', True: 'disabled'}[mode] text = '{} ({}) nodes'.format(text, len(nodes)) self._undo_stack.beginMacro(text) [n.set_disabled(mode) for n in nodes] self._undo_stack.endMacro() return nodes[0].set_disabled(mode) def question_dialog(self, text, title='Node Graph'): """ Prompts a question open dialog with "Yes" and "No" buttons in the node graph. (convenience function to :meth:`NodeGraph.viewer().question_dialog`) Args: text (str): question text. title (str): dialog window title. Returns: bool: true if user clicked yes. """ self._viewer.question_dialog(text, title) def message_dialog(self, text, title='Node Graph'): """ Prompts a file open dialog in the node graph. (convenience function to :meth:`NodeGraph.viewer().message_dialog`) Args: text (str): message text. title (str): dialog window title. """ self._viewer.message_dialog(text, title) def load_dialog(self, current_dir=None, ext=None): """ Prompts a file open dialog in the node graph. (convenience function to :meth:`NodeGraph.viewer().load_dialog`) Args: current_dir (str): path to a directory. ext (str): custom file type extension (default: json) Returns: str: selected file path. """ return self._viewer.load_dialog(current_dir, ext) def save_dialog(self, current_dir=None, ext=None): """ Prompts a file save dialog in the node graph. (convenience function to :meth:`NodeGraph.viewer().save_dialog`) Args: current_dir (str): path to a directory. ext (str): custom file type extension (default: json) Returns: str: selected file path. """ return self._viewer.save_dialog(current_dir, ext)
class URList(UserList): class __SingleStackCommand__(QUndoCommand): def __init__(self, myList: 'URList', key: Union[int, slice], value: Any): QUndoCommand.__init__(self) self._list = myList self._key = key try: self._old_value = self._list[key] except IndexError: self._old_value = None self._new_value = value def undo(self) -> NoReturn: if self._old_value is None: del self._list[self._key] else: self._list.__realsetitem__(self._key, self._old_value) def redo(self) -> NoReturn: self._list.__realsetitem__(self._key, self._new_value) class __MultiStackCommand__(QUndoCommand): def __init__(self, myList: 'URList', key: Union[int, slice]): QUndoCommand.__init__(self) self._key = key self._list = myList def undo(self) -> NoReturn: self._list[self._key].undo() def redo(self) -> NoReturn: self._list[self._key].redo() def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.__stack__ = QUndoStack() self._macroRunning = False def __setitem__(self, key: Union[int, slice], value: Any) -> NoReturn: self.__stack__.push(self.__SingleStackCommand__(self, key, value)) def __getitem__(self, key): if isinstance(key, slice): myList = [] if key.step is None: myRange = range(key.start, key.stop + 1) else: myRange = range(key.start, key.stop + 1, key.step) for cKey in myRange: myList.append(super().__getitem__(cKey)) return myList return super().__getitem__(key) def __realsetitem__(self, key: Union[int, slice], value: Any) -> NoReturn: def keyUpdate(base, key, value): if key > (len(base.data) - 1): super().append(value) super().__setitem__(key, value) if isinstance(key, slice): if key.step is None: myRange = range(key.start, key.stop + 1) else: myRange = range(key.start, key.stop + 1, key.step) for cKey in myRange: keyUpdate(self, cKey, value[cKey]) super().__setitem__(cKey, value[cKey]) return keyUpdate(self, key, value) def undo(self) -> NoReturn: self.__stack__.undo() def redo(self) -> NoReturn: self.__stack__.redo() def startBulkUpdate(self) -> NoReturn: self.__stack__.beginMacro('Bulk update') self._macroRunning = True def endBulkUpdate(self) -> NoReturn: self.__stack__.endMacro() self._macroRunning = False def append(self, item) -> None: self.__setitem__(len(self.data), item)
class MainWindow(QMainWindow): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.undoStack = QUndoStack(self) self.undoStack.cleanChanged.connect(self.cleanChanged) self.undoAction = self.undoStack.createUndoAction(self, "&Undo") self.undoAction.setShortcut(QKeySequence.Undo) self.redoAction = self.undoStack.createRedoAction(self, "&Redo") self.redoAction.setShortcut(QKeySequence.Redo) self.messageLabel = QLabel() self.coordLabel = QLabel() self.stopwatchLabel = QLabel() self.time = QTime(0, 0) self.stopwatch = QTimer() self.undoView = QUndoView(self.undoStack) self.graphicsScene = GraphicsScene(self) self.copyList = [] def setupUi(self): if QIcon.themeName() == "": QIcon.setThemeName('breeze') self.openIcon = QIcon().fromTheme("document-open") self.actionOpen_Datasets.setIcon(self.openIcon) self.saveIcon = QIcon().fromTheme("document-save") self.actionSave.setIcon(self.saveIcon) self.closeIcon = QIcon().fromTheme("document-close") self.actionClose_Dataset.setIcon(self.closeIcon) self.statusbar.addWidget(self.messageLabel) self.statusbar.addWidget(self.coordLabel) self.statusbar.addWidget(self.stopwatchLabel) self.stopwatch.setInterval(1000) self.stopwatch.timeout.connect(self.updateStopWatchLabel) self.stopwatchStartIcon = QIcon().fromTheme("chronometer-start") self.actionTimer_Start.setIcon(self.stopwatchStartIcon) self.actionTimer_Start.triggered.connect(self.startStopWatch) self.stopwatchStopIcon = QIcon().fromTheme("chronometer-pause") self.actionTimer_Stop.setIcon(self.stopwatchStopIcon) self.actionTimer_Stop.triggered.connect(self.stopStopWatch) self.stopwatchResetIcon = QIcon().fromTheme("chronometer-reset") self.actionTimer_Reset.setIcon(self.stopwatchResetIcon) self.actionTimer_Reset.triggered.connect(self.resetStopWatch) self.leftIcon = QIcon().fromTheme("go-previous") self.actionSend_To_Left.setIcon(self.leftIcon) self.rightIcon = QIcon().fromTheme("go-next") self.actionSend_To_Right.setIcon(self.rightIcon) self.upIcon = QIcon().fromTheme("go-up") self.actionPrevious_Item.setIcon(self.upIcon) self.downIcon = QIcon().fromTheme("go-down") self.actionNext_Item.setIcon(self.downIcon) self.undoView.setWindowTitle("Command List") self.undoView.show() self.undoView.setAttribute(Qt.WA_QuitOnClose, False) self.menuEdit.addAction(self.undoAction) self.menuEdit.addAction(self.redoAction) self.graphicsView.setScene(self.graphicsScene) self.graphicsView.mouseMoved.connect(self.coordLabel.setText) self.graphicsScene.tabWidget = self.tabWidget self.graphicsScene.comboBox = self.comboBox self.graphicsScene.signalHandler.boxPressed.connect(self.selectBox) self.graphicsScene.signalHandler.boxChanged.connect(self.changeBox) self.graphicsScene.signalHandler.boxCreated.connect(self.createItem) @Slot() def sendToLeft(self): originIndex = self.tabWidget.currentIndex() numTabs = self.tabWidget.count() targetIndex = (numTabs + originIndex - 1) % numTabs modelIndex = self.tabWidget.getCurrentTableView().currentIndex() if modelIndex.isValid(): self.undoStack.beginMacro(f"Send item to {targetIndex}") sendToCommand = SendToCommand(originIndex, targetIndex, modelIndex.row(), self.tabWidget, self.graphicsScene) self.undoStack.push(sendToCommand) modelIndex = modelIndex.model().index(modelIndex.row(), modelIndex.column()) if modelIndex.isValid(): self.cellClicked(originIndex, modelIndex, originIndex, modelIndex) self.undoStack.endMacro() @Slot() def sendToRight(self): originIndex = self.tabWidget.currentIndex() numTabs = self.tabWidget.count() targetIndex = (originIndex + 1) % numTabs modelIndex = self.tabWidget.getCurrentTableView().currentIndex() if modelIndex.isValid(): self.undoStack.beginMacro(f"Send item to {targetIndex}") sendToCommand = SendToCommand(originIndex, targetIndex, modelIndex.row(), self.tabWidget, self.graphicsScene) self.undoStack.push(sendToCommand) modelIndex = modelIndex.model().index(modelIndex.row(), modelIndex.column()) if modelIndex.isValid(): self.cellClicked(originIndex, modelIndex, originIndex, modelIndex) self.undoStack.endMacro() @Slot() @Slot(int) def closeDataset(self, i=-1): # put a dialog if there is a pending modification # say that modifications are not lost and retrievable with CTRL-Z if self.tabWidget.count() > 0: if i == -1: i = self.tabWidget.currentIndex() deleteDatasetCommand = DeleteDatasetCommand([i], self.tabWidget, self.comboBox, self.graphicsView, self.graphicsScene) self.undoStack.push(deleteDatasetCommand) @Slot() def openDatasets(self): """Open dataset directory""" prevTabIndex = self.tabWidget.currentIndex() prevModelIndex = self.tabWidget.getCurrentSelectedCell() numTabs = self.tabWidget.count() (filenames, _ext) = QFileDialog.getOpenFileNames( self, QApplication.translate("MainWindow", "Open datasets", None, -1), "/home/kwon-young/Documents/PartageVirtualBox/data/omr_dataset/choi_dataset", "*.csv") if filenames: self.undoStack.beginMacro(f"open Datasets {filenames}") filenames.sort() openDatasetCommand = OpenDatasetCommand(filenames, self.tabWidget, self.comboBox, self.graphicsScene, self.messageLabel) self.undoStack.push(openDatasetCommand) tabIndex = numTabs if self.tabWidget.count() > 0: modelIndex = self.tabWidget.getTableModel(tabIndex).index(0, 0) if modelIndex.isValid(): self.cellClicked(tabIndex, modelIndex, prevTabIndex, prevModelIndex) self.undoStack.endMacro() @Slot(int) def currentTabChanged(self, index): self.tabWidget.setCurrentIndex(index) for tabIndex in range(self.tabWidget.count()): self.graphicsScene.changeTabColor( tabIndex, self.tabWidget.color_map(tabIndex)) @Slot(int, QModelIndex, int, QModelIndex) def cellClicked(self, tabIndex, cellIndex, prevTabIndex, prevCellIndex): cellClickedCommand = CellClickedCommand( tabIndex, cellIndex, prevTabIndex, prevCellIndex, self.tabWidget, self.graphicsScene, self.graphicsView, self.comboBox, self.messageLabel) self.undoStack.push(cellClickedCommand) @Slot() def SelectNextItem(self): if self.tabWidget.count() > 0: tabIndex = self.tabWidget.currentIndex() prevCellIndex = self.tabWidget.getCurrentSelectedCell() model = self.tabWidget.getCurrentTableModel() rowCount = model.rowCount(QModelIndex()) nextRow = (prevCellIndex.row() + 1) % rowCount cellIndex = model.index(nextRow, prevCellIndex.column()) cellClickedCommand = CellClickedCommand( tabIndex, cellIndex, tabIndex, prevCellIndex, self.tabWidget, self.graphicsScene, self.graphicsView, self.comboBox, self.messageLabel) self.undoStack.push(cellClickedCommand) @Slot() def SelectPreviousItem(self): if self.tabWidget.count() > 0: tabIndex = self.tabWidget.currentIndex() prevCellIndex = self.tabWidget.getCurrentSelectedCell() model = self.tabWidget.getCurrentTableModel() rowCount = model.rowCount(QModelIndex()) nextRow = (rowCount + prevCellIndex.row() - 1) % rowCount cellIndex = model.index(nextRow, prevCellIndex.column()) cellClickedCommand = CellClickedCommand( tabIndex, cellIndex, tabIndex, prevCellIndex, self.tabWidget, self.graphicsScene, self.graphicsView, self.comboBox, self.messageLabel) self.undoStack.push(cellClickedCommand) @Slot() def SelectNextPage(self): if self.tabWidget.count() > 0: tabIndex = self.tabWidget.currentIndex() prevCellIndex = self.tabWidget.getCurrentSelectedCell() model = self.tabWidget.getCurrentTableModel() prevPage = model.pageAtIndex(prevCellIndex) rowCount = model.rowCount(QModelIndex()) for i in range(0, rowCount): row = (prevCellIndex.row() + i) % rowCount cellIndex = model.index(row, prevCellIndex.column()) page = model.pageAtIndex(cellIndex) if prevPage.split("-")[0] != page.split("-")[0]: break cellClickedCommand = CellClickedCommand( tabIndex, cellIndex, tabIndex, prevCellIndex, self.tabWidget, self.graphicsScene, self.graphicsView, self.comboBox, self.messageLabel) self.undoStack.push(cellClickedCommand) @Slot() def SelectPreviousPage(self): if self.tabWidget.count() > 0: tabIndex = self.tabWidget.currentIndex() prevCellIndex = self.tabWidget.getCurrentSelectedCell() model = self.tabWidget.getCurrentTableModel() prevPage = model.pageAtIndex(prevCellIndex) rowCount = model.rowCount(QModelIndex()) for i in range(0, rowCount): row = (prevCellIndex.row() - i) % rowCount cellIndex = model.index(row, prevCellIndex.column()) page = model.pageAtIndex(cellIndex) if prevPage.split("-")[0] != page.split("-")[0]: break cellClickedCommand = CellClickedCommand( tabIndex, cellIndex, tabIndex, prevCellIndex, self.tabWidget, self.graphicsScene, self.graphicsView, self.comboBox, self.messageLabel) self.undoStack.push(cellClickedCommand) @Slot() def selectNextLabel(self): if self.comboBox.count() > 0: index = self.comboBox.currentIndex() newIndex = (index + 1) % self.comboBox.count() label = self.comboBox.itemText(newIndex) tabIndex = self.tabWidget.currentIndex() cellIndex = self.tabWidget.getCurrentSelectedCell() labelChangedCommand = LabelChangedCommand(label, tabIndex, cellIndex, self.tabWidget, self.graphicsScene, self.comboBox) self.undoStack.push(labelChangedCommand) @Slot() def selectPreviousLabel(self): if self.comboBox.count() > 0: index = self.comboBox.currentIndex() newIndex = ((self.comboBox.count() + index - 1) % self.comboBox.count()) label = self.comboBox.itemText(newIndex) tabIndex = self.tabWidget.currentIndex() cellIndex = self.tabWidget.getCurrentSelectedCell() labelChangedCommand = LabelChangedCommand(label, tabIndex, cellIndex, self.tabWidget, self.graphicsScene, self.comboBox) self.undoStack.push(labelChangedCommand) @Slot(int) def labelChanged(self, index): label = self.comboBox.itemText(index) tabIndex = self.tabWidget.currentIndex() cellIndex = self.tabWidget.getCurrentSelectedCell() labelChangedCommand = LabelChangedCommand(label, tabIndex, cellIndex, self.tabWidget, self.graphicsScene, self.comboBox) self.undoStack.push(labelChangedCommand) @Slot() def saveDataToDisk(self): self.undoStack.setClean() for name, model in zip(self.tabWidget.filenames(), self.tabWidget.models()): model.save(name) @Slot(bool) def cleanChanged(self, clean): self.setWindowModified(not clean) @Slot(int, int) def selectBox(self, tabIndex, rowIndex): if tabIndex != self.tabWidget.currentIndex() or \ rowIndex != self.tabWidget.getCurrentSelectedCell().row(): selectBoxCommand = SelectBoxCommand(tabIndex, rowIndex, self.tabWidget, self.graphicsScene, self.comboBox) self.undoStack.push(selectBoxCommand) @Slot(int, int, QRectF) def changeBox(self, tabIndex, rowIndex, box): moveBoxCommand = MoveBoxCommand(tabIndex, rowIndex, box, self.tabWidget, self.graphicsScene) self.undoStack.push(moveBoxCommand) @Slot(QRectF, QRectF) def viewportMoved(self, rect, prevRect): viewportMovedCommand = ViewportMovedCommand(rect, prevRect, self.graphicsView) self.undoStack.push(viewportMovedCommand) @Slot() def updateStopWatchLabel(self): elapsed = QTime(0, 0).addMSecs(self.time.elapsed()) self.stopwatchLabel.setText(elapsed.toString()) @Slot() def startStopWatch(self): self.time.start() self.stopwatch.start(1000) @Slot() def stopStopWatch(self): self.stopwatch.stop() @Slot() def resetStopWatch(self): self.time.start() self.stopwatchLabel.setText(QTime(0, 0).toString()) @Slot() def deleteItem(self): tabIndex = self.tabWidget.currentIndex() cellIndex = self.tabWidget.getCurrentSelectedCell() self.undoStack.beginMacro(f"Delete item {tabIndex}:{cellIndex.row()}") deleteItemCommand = DeleteItemCommand(tabIndex, cellIndex, self.tabWidget, self.graphicsView, self.graphicsScene, self.comboBox) self.undoStack.push(deleteItemCommand) cellIndex = cellIndex.model().index(cellIndex.row(), cellIndex.column()) if cellIndex.isValid(): self.cellClicked(tabIndex, cellIndex, tabIndex, cellIndex) self.undoStack.endMacro() @Slot(ResizableRect) def createItem(self, rect): self.undoStack.beginMacro( f"Create item {rect.tabIndex}:{rect.rowIndex}") createItemCommand = CreateItemCommand(rect, self.tabWidget, self.graphicsScene, self.comboBox) self.undoStack.push(createItemCommand) self.selectBox(rect.tabIndex, rect.rowIndex) self.undoStack.endMacro() @Slot() def tabItemForward(self): changeTabItemZValueCommand = ChangeTabItemZValueCommand( self.tabWidget.currentIndex(), 1, self.graphicsScene) self.undoStack.push(changeTabItemZValueCommand) @Slot() def tabItemBackward(self): changeTabItemZValueCommand = ChangeTabItemZValueCommand( self.tabWidget.currentIndex(), -1, self.graphicsScene) self.undoStack.push(changeTabItemZValueCommand) @Slot() def copy(self): tabIndex = self.tabWidget.currentIndex() cellIndex = self.tabWidget.getCurrentSelectedCell() box = self.graphicsScene.box(tabIndex, cellIndex.row()) copyCommand = CopyCommand(box, self.copyList) self.undoStack.push(copyCommand) @Slot() def paste(self): pos = self.graphicsView.mapFromGlobal(QCursor.pos()) scenePos = self.graphicsView.mapToScene(pos) prop = self.copyList[-1] self.undoStack.beginMacro(f"paste item {prop.box}") pasteCommand = PasteCommand(scenePos, prop, self.tabWidget, self.graphicsScene) self.undoStack.push(pasteCommand) self.selectBox(prop.tabIndex, prop.rowIndex) self.undoStack.endMacro()
class UndoableDict(PathDict): """ The UndoableDict class implements a PathDict-base_dict class with undo/redo functionality base_dict on QUndoStack. """ def __init__(self, *args, **kwargs): self.__stack = QUndoStack() self._macroRunning = False super().__init__(*args, **kwargs) # Public methods: dictionary-related def __setitem__(self, key: str, val: Any) -> NoReturn: """ Calls the undoable command to override PathDict assignment to self[key] implementation and pushes this command on the stack. """ if key in self: self.__stack.push(_SetItemCommand(self, key, val)) else: self.__stack.push(_AddItemCommand(self, key, val)) def setItemByPath(self, keys: list, value: Any) -> NoReturn: """ Calls the undoable command to set a value in a nested object by key sequence and pushes this command on the stack. """ self.__stack.push(_SetItemCommand(self, keys, value)) # Public methods: undo/redo-related def clearUndoStack(self) -> NoReturn: """ Clears the command stack by deleting all commands on it, and returns the stack to the clean state. """ self.__stack.clear() def canUndo(self) -> bool: """ :return true if there is a command available for undo; otherwise returns false. """ return self.__stack.canUndo() def canRedo(self) -> bool: """ :return true if there is a command available for redo; otherwise returns false. """ return self.__stack.canRedo() def undo(self) -> NoReturn: """ Undoes the current command on stack. """ self.__stack.undo() def redo(self) -> NoReturn: """ Redoes the current command on stack. """ self.__stack.redo() def undoText(self) -> str: """ :return the current command on stack. """ return self.__stack.undoText() def redoText(self) -> str: """ :return the current command on stack. """ return self.__stack.redoText() def startBulkUpdate(self, text='Bulk update') -> NoReturn: """ Begins composition of a macro command with the given text description. """ if self._macroRunning: print('Macro already running') return self.__stack.beginMacro(text) self._macroRunning = True def endBulkUpdate(self) -> NoReturn: """ Ends composition of a macro command. """ if not self._macroRunning: print('Macro not running') return self.__stack.endMacro() self._macroRunning = False def bulkUpdate(self, key_list: list, item_list: list, text='Bulk update') -> NoReturn: """ Performs a bulk update base_dict on a list of keys and a list of values :param key_list: list of keys or path keys to be updated :param item_list: the value to be updated :return: None """ self.startBulkUpdate(text) for key, value in zip(key_list, item_list): self.setItemByPath(key, value) self.endBulkUpdate()
class URDict(UserDict): """ The URDict class implements a dictionary-based class with undo/redo functionality based on QUndoStack. """ def __init__(self, *args, **kwargs): self._stack = QUndoStack() super().__init__(*args, **kwargs) self._macroRunning = False # Private URDict dictionary-based methods to be called via the QUndoCommand-based classes. def _realSetItem(self, key: Union[str, List], value: Any) -> NoReturn: """Actually changes the value for the existing key in dictionary.""" if isinstance(key, list): self.getItemByPath(key[:-1])[key[-1]] = value else: super().__setitem__(key, value) def _realAddItem(self, key: str, value: Any) -> NoReturn: """Actually adds a key-value pair to dictionary.""" super().__setitem__(key, value) def _realDelItem(self, key: str) -> NoReturn: """Actually deletes a key-value pair from dictionary.""" del self[key] def _realSetItemByPath(self, keys: list, value: Any) -> NoReturn: """Actually sets the value in a nested object by the key sequence.""" self.getItemByPath(keys[:-1])[keys[-1]] = value # Public URDict dictionary-based methods def __setitem__(self, key: str, val: Any) -> NoReturn: """Overrides default dictionary assignment to self[key] implementation. Calls the undoable command and pushes this command on the stack.""" if key in self: self._stack.push(_SetItemCommand(self, key, val)) else: self._stack.push(_AddItemCommand(self, key, val)) def setItemByPath(self, keys: list, value: Any) -> NoReturn: """Calls the undoable command to set a value in a nested object by key sequence and pushes this command on the stack.""" self._stack.push(_SetItemCommand(self, keys, value)) def getItemByPath(self, keys: list, default=None) -> Any: """Returns a value in a nested object by key sequence.""" item = self for key in keys: if key in item.keys(): item = item[key] else: return default return item def getItem(self, key: Union[str, list], default=None): """Returns a value in a nested object. Key can be either a sequence or a simple string.""" if isinstance(key, list): return self.getItemByPath(key, default) else: return self.get(key, default) # Public URDict undostack-based methods def undoText(self) -> NoReturn: """Returns the text of the command which will be undone in the next call to undo().""" return self._stack.undoText() def redoText(self) -> NoReturn: """Returns the text of the command which will be redone in the next call to redo().""" return self._stack.redoText() def undo(self) -> NoReturn: """Undoes the current command on stack.""" self._stack.undo() def redo(self) -> NoReturn: """Redoes the current command on stack.""" self._stack.redo() def startBulkUpdate(self, text='Bulk update') -> NoReturn: """Begins composition of a macro command with the given text description.""" if self._macroRunning: print('Macro already running') return self._stack.beginMacro(text) self._macroRunning = True def endBulkUpdate(self) -> NoReturn: """Ends composition of a macro command.""" if not self._macroRunning: print('Macro not running') return self._stack.endMacro() self._macroRunning = False
class URDict(dict): class _StackCommand(QUndoCommand): def __init__(self, dictionary, key, value): QUndoCommand.__init__(self) self._dictionary = dictionary self._key = key self._old_value = None thisKey = key if isinstance(thisKey, list): thisKey = thisKey[0] if thisKey in dictionary: self._old_value = dictionary[key] self._new_value = value def undo(self): # self.setText(" undo command {} - {}:{} = ".format(self._dictionary, self._key, self._value)) if self._old_value is None: self.setText(" undo command {} - {}:{} = ".format( self._dictionary, self._key, self._new_value)) del self._dictionary[self._key] else: self._dictionary.__realsetitem__(self._key, self._old_value) def redo(self): # self.setText(" do/redo command {} + {}:{} = ".format(self._dictionary, self._key, self._value)) self._dictionary.__realsetitem__(self._key, self._new_value) def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.__stack__ = QUndoStack() def __setitem__(self, key, val): self.__stack__.push(self._StackCommand(self, key, val)) def __getitem__(self, key): if isinstance(key, list): return self.getByPath(key) return super().__getitem__(key) def __realsetitem__(self, key, val): if isinstance(key, list): self.setByPath(key, val) else: super().__setitem__(key, val) def undoText(self): return self.__stack__.undoText() def redoText(self): return self.__stack__.redoText() def undo(self): self.__stack__.undo() def redo(self): self.__stack__.redo() def getByPath(self, keys): """Access a nested object in root by key sequence. We can't use reduce and operator""" item = self for key in keys: if key in item.keys(): item = item[key] else: raise KeyError return item def setByPath(self, keys, value): """Get a value in a nested object in root by key sequence.""" self.getByPath(keys[:-1])[keys[-1]] = value
class Scene(QGraphicsScene): def __init__(self, parent=None, view=None): QGraphicsScene.__init__(self, parent) self.undoStack = QUndoStack(self) # super(Scene, self).__init__(parent) self.view = view self.imgPosibleConnectH = QGraphicsPixmapItem( os.path.join(PATHBLOCKSIMG, "ConnectH.png")) super(Scene, self).addItem(self.imgPosibleConnectH) self.imgPosibleConnectH.setVisible(False) self.imgPosibleConnectV = QGraphicsPixmapItem( os.path.join(PATHBLOCKSIMG, "ConnectV.png")) super(Scene, self).addItem(self.imgPosibleConnectV) self.imgPosibleConnectV.setVisible(False) self.oldPos = None self.createActions() def createActions(self): self.popMenu = QMenu() self.undoAction = self.undoStack.createUndoAction( self, self.tr("&Undo")) self.undoAction.setShortcuts(QKeySequence.Undo) self.popMenu.addAction(self.undoAction) self.redoAction = self.undoStack.createRedoAction( self, self.tr("&Redo")) self.redoAction.setShortcuts(QKeySequence.Redo) self.popMenu.addAction(self.redoAction) self.disableAction = QAction(self.tr("&Disable"), self) self.disableAction.triggered.connect(self.setEnabledMain) self.popMenu.addAction(self.disableAction) def setEnabledMain(self): for item in self.items(): if isinstance(item, QGraphicsBlockItem) and item.isBlockDef(): if item.functionname == "main": item.setEnabled(not item.isEnabled()) elif item.functionname == "when": item.setEnabled(not item.isEnabled()) def addItem(self, item: QGraphicsItem, fromStack=False): if fromStack: super(Scene, self).addItem(item) else: self.undoStack.push(AddCommand(item, self)) def mousePressEvent(self, event: QGraphicsSceneMouseEvent): movingItem = self.itemAt(event.scenePos(), self.view.transform()) if movingItem is None and event.button() is Qt.MouseButton.RightButton: self.popMenu.exec_(event.screenPos()) if movingItem is not None and event.button( ) is Qt.MouseButton.LeftButton: self.oldPos = movingItem.pos() self.clearSelection() super(Scene, self).mousePressEvent(event) def mouseReleaseEvent(self, event: QGraphicsSceneMouseEvent): if len(self.selectedItems()) is not 0: movingItem = self.selectedItems()[0] else: movingItem = None if movingItem is not None and event.button( ) is Qt.MouseButton.LeftButton: if self.oldPos is not movingItem.pos(): self.undoStack.push(MoveCommand(movingItem, self.oldPos, self)) super(Scene, self).mouseReleaseEvent(event) def getListInstructions(self): list = [] for item in self.items(): if isinstance(item, QGraphicsBlockItem) and item.isBlockDef( ) and item.isEnabled(): inst = item.getInstructions() list.append(inst) return list
class URDict(UserDict): """ The URDict class implements a dictionary-based class with undo/redo functionality based on QUndoStack. """ def __init__(self, *args, **kwargs): self.stack = QUndoStack() super().__init__(*args, **kwargs) # Private dictionary-based methods to be called via the QUndoCommand-based classes. def _realSetItem(self, key: Union[str, List], value: Any) -> NoReturn: """Actually changes the value for the existing key in dictionary.""" if isinstance(key, list): self.getItemByPath(key[:-1])[key[-1]] = value else: super().__setitem__(key, value) def _realAddItem(self, key: str, value: Any) -> NoReturn: """Actually adds a key-value pair to dictionary.""" super().__setitem__(key, value) def _realDelItem(self, key: str) -> NoReturn: """Actually deletes a key-value pair from dictionary.""" del self[key] def _realSetItemByPath(self, keys: list, value: Any) -> NoReturn: """Actually sets the value in a nested object by the key sequence.""" self.getItemByPath(keys[:-1])[keys[-1]] = value # Public dictionary-based methods def __setitem__(self, key: str, val: Any) -> NoReturn: """Overrides default dictionary assignment to self[key] implementation. Calls the undoable command and pushes this command on the stack.""" if key in self: self.stack.push(_SetItemCommand(self, key, val)) else: self.stack.push(_AddItemCommand(self, key, val)) def setItemByPath(self, keys: list, value: Any) -> NoReturn: """Calls the undoable command to set a value in a nested object by key sequence and pushes this command on the stack.""" self.stack.push(_SetItemCommand(self, keys, value)) def getItemByPath(self, keys: list, default=None) -> Any: """Returns a value in a nested object by key sequence.""" item = self for key in keys: if key in item.keys(): item = item[key] else: return default return item def getItem(self, key: Union[str, list], default=None): """Returns a value in a nested object. Key can be either a sequence or a simple string.""" if isinstance(key, list): return self.getItemByPath(key, default) else: return self.get(key, default)
class NodeGraph(QtCore.QObject): node_selected = QtCore.Signal(list) def __init__(self, parent=None): super(NodeGraph, self).__init__(parent) self._model = NodeGraphModel() self._viewer = NodeViewer() self._undo_stack = QUndoStack(self) self._init_actions() self._wire_signals() self.patch_context_menu() def _wire_signals(self): self._viewer.moved_nodes.connect(self._on_nodes_moved) self._viewer.search_triggered.connect(self._on_search_triggered) self._viewer.connection_changed.connect(self._on_connection_changed) self._viewer.node_selected.connect(self._on_node_selected) def _init_actions(self): # setup tab search shortcut. tab = QAction('Search Nodes', self) tab.setShortcut('tab') tab.triggered.connect(self._toggle_tab_search) self._viewer.addAction(tab) setup_actions(self) def _toggle_tab_search(self): """ toggle the tab search widget. """ self._viewer.tab_search_set_nodes(NodeVendor.names) self._viewer.tab_search_toggle() def _on_nodes_moved(self, node_data): """ called when selected nodes in the viewer has changed position. Args: node_data (dict): {<node_view>: <previous_pos>} """ self._undo_stack.beginMacro('moved nodes') for node_view, prev_pos in node_data.items(): node = self._model.nodes[node_view.id] self._undo_stack.push(NodeMovedCmd(node, node.pos(), prev_pos)) self._undo_stack.endMacro() def _on_nodes_moved(self, node_data): """ called when a node in the viewer is selected on left click. """ nodes = self.selected_nodes() self.node_selected.emit(nodes) def _on_search_triggered(self, node_type, pos): """ called when the tab search widget is triggered in the viewer. Args: node_type (str): node identifier. pos (tuple): x,y position for the node. """ self.create_node(node_type, pos=pos) def _on_connection_changed(self, disconnected, connected): """ called when a pipe connection has been changed in the viewer. Args: disconnected (list[list[widgets.port.PortItem]): pair list of port view items. connected (list[list[widgets.port.PortItem]]): pair list of port view items. """ if not (disconnected or connected): return label = 'connected node(s)' if connected else 'disconnected node(s)' ptypes = {'in': 'inputs', 'out': 'outputs'} self._undo_stack.beginMacro(label) for p1_view, p2_view in disconnected: node1 = self._model.nodes[p1_view.node.id] node2 = self._model.nodes[p2_view.node.id] port1 = getattr(node1, ptypes[p1_view.port_type])()[p1_view.name] port2 = getattr(node2, ptypes[p2_view.port_type])()[p2_view.name] port1.disconnect_from(port2) for p1_view, p2_view in connected: node1 = self._model.nodes[p1_view.node.id] node2 = self._model.nodes[p2_view.node.id] port1 = getattr(node1, ptypes[p1_view.port_type])()[p1_view.name] port2 = getattr(node2, ptypes[p2_view.port_type])()[p2_view.name] port1.connect_to(port2) self._undo_stack.endMacro() @property def model(self): """ Return the node graph model. Returns: NodeGraphModel: model object. """ return self._model def show(self): """ Show node graph viewer widget. """ self._viewer.show() def hide(self): """ Hide node graph viewer widget. """ self._viewer.hide() def close(self): """ Close node graph viewer widget. """ self._viewer.close() def viewer(self): """ Return the node graph viewer widget object. Returns: NodeGraphQt.widgets.viewer.NodeViewer: viewer widget. """ return self._viewer def scene(self): """ Return the scene object. Returns: NodeGraphQt.widgets.scene.NodeScene: node scene. """ return self._viewer.scene() def undo_stack(self): """ Returns the undo stack used in the node graph Returns: QUndoStack: undo stack. """ return self._undo_stack def begin_undo(self, name='undo'): """ Start of an undo block followed by a end_undo(). Args: name (str): name for the undo block. """ self._undo_stack.beginMacro(name) def end_undo(self): """ End of an undo block started by begin_undo(). """ self._undo_stack.endMacro() def context_menu(self): """ Returns a node graph context menu object. Returns: ContextMenu: node graph context menu object instance. """ return self._viewer.context_menu() @staticmethod def modify_context_menu(viewer):