modelverse/sketchUI/im_mainwindow.py

from PyQt5.QtWidgets import QMainWindow, QGraphicsItem, QAction, QActionGroup, QGraphicsView, QTableWidgetItem
from PyQt5.QtGui import QIcon
from PyQt5.QtCore import QStateMachine, QState
from PyQt5.Qt import QApplication, Qt
from sketchUI.ui import Ui_MainWindow
from sketchUI.im_scene import CustomScene, Mode
from sketchUI import mvops
from sketchUI.graphics_node_item import GraphicsNodeItem
from sketchUI.graphics_edge_item import GraphicsEdgeItem
from wrappers.modelverse import element_list_nice
from verifier import Verifier
import commons


class IMMainWindow(QMainWindow, Ui_MainWindow):
    def __init__(self, model):
        QMainWindow.__init__(self)
        self.setupUi(self)
        self.setWindowTitle(model)
        self._cur_model = model

        self._scene = CustomScene(model, self)
        self._scene.set_mode(Mode.SELECT)
        self._scene.setSceneRect(0, 0, 200, 200)
        self.graphicsView.setScene(self._scene)

        self.listWidget.addItems(commons.get_available_types())
        self.listWidget.itemDoubleClicked.connect(self._on_list_item_clicked)

        self.setup_toolbar()
        self.setup_state_machine()
        self.menuActionVerify.triggered.connect(self._on_verify_clicked)
        self.menuActionDeleteModel.triggered.connect(self._on_delete_model_clicked)

        # load the model
        self._load_model()

        # setup log viewer
        self.plainTextEdit.setReadOnly(True)

        # setup table view for attributes
        self.tableWidget.setColumnCount(2)
        self.tableWidget.setHorizontalHeaderLabels(["Key", "Value"])
        self.tableWidget.horizontalHeader().setStretchLastSection(True)
        self.tableWidget.itemChanged.connect(self._on_attribute_edited)

        #lastly, start the state machine
        self._statemachine.start()

    def setup_toolbar(self):
        self.select_action = QAction("Select", self)
        self.select_action.setIcon(QIcon("sketchUI/icons/select.png"))
        self.select_action.setCheckable(True)
        self.select_action.setChecked(True)

        self.connect_action = QAction("Connect", self)
        self.connect_action.setIcon(QIcon("sketchUI/icons/connect.png"))
        self.connect_action.setCheckable(True)

        action_group = QActionGroup(self)
        action_group.setExclusive(True)
        action_group.addAction(self.select_action)
        action_group.addAction(self.connect_action)

        for item in action_group.actions():
            self.toolBar.addAction(item)

    def setup_state_machine(self):
        self._statemachine = QStateMachine()
        state_select = QState()
        state_connect = QState()
        state_select.addTransition(self.connect_action.triggered, state_connect)
        state_connect.addTransition(self.select_action.triggered, state_select)
        state_connect.entered.connect(self._state_connect_entered)
        state_select.entered.connect(self._state_select_entered)

        self._statemachine.addState(state_select)
        self._statemachine.addState(state_connect)
        self._statemachine.setInitialState(state_select)

    def _load_model(self):
        """
        Load the model from the mv and render to screen using the concrete syntaxes stored in the mv
        """
        model = element_list_nice(self._cur_model)
        if not model:
            # empty model
            return

        x_pos = -150
        y_pos = 70
        for item in model:
            typ = item["type"]
            if typ == "Node":
                # first, draw all nodes
                node_type = item["typeID"]
                self._add_node_to_scene(item["id"], node_type, x=x_pos, y=y_pos)
                x_pos += 80
                y_pos *= -1

        for item in model:
            # now the edges
            typ = item["type"]
            if typ == "Edge":
                target = item["__target"]
                src = item["__source"]
                self._add_edge_to_scene(src, target, item["id"])

    def _state_connect_entered(self):
        self._scene.set_mode(Mode.CONNECT)
        self._make_items_movable(False)
        self._enable_box_select(False)
        self._enable_list_widget(False)

    def _state_select_entered(self):
        self._scene.set_mode(Mode.SELECT)
        self._make_items_movable(True)
        self._enable_box_select(True)
        self._enable_list_widget(True)

    def _enable_list_widget(self, enabled):
        self.listWidget.setEnabled(enabled)

    def _make_items_movable(self, movable):
        for item in self._scene.items():
            if isinstance(item, GraphicsEdgeItem):
                # edges are selectable (for delete) but never movable
                item.setFlag(QGraphicsItem.ItemIsMovable, False)
                item.setFlag(QGraphicsItem.ItemIsSelectable, True)
            else:
                item.setFlag(QGraphicsItem.ItemIsMovable, movable)
                item.setFlag(QGraphicsItem.ItemIsSelectable, movable)

    def _enable_box_select(self, enable):
        if enable:
            self.graphicsView.setDragMode(QGraphicsView.RubberBandDrag)
        else:
            self.graphicsView.setDragMode(QGraphicsView.NoDrag)

    def _add_node_to_scene(self, node_id, node_type, x=0, y=0):
        """
        Render a node with id and type to the canvas by getting its concrete syntax
        from the modelverse.
        """
        consyn = mvops.get_consyn_of(node_type)
        item = GraphicsNodeItem(node_id, node_type, consyn)
        item.setPos(x, y)
        item.setFlag(QGraphicsItem.ItemIsMovable, True)
        item.setFlag(QGraphicsItem.ItemIsSelectable, True)
        self._scene.addItem(item)

    def _add_edge_to_scene(self, from_id, to_id, edge_id):
        from_item = None
        to_item = None
        for item in self._scene.items():
            try:
                node_id = item.node_id
            except AttributeError:
                # no node item, continue
                continue
            if node_id == from_id:
                from_item = item
                continue
            if node_id == to_id:
                to_item = item

        self._scene.draw_edge(from_item, to_item, is_new=False, edge_id=edge_id)

    def _on_list_item_clicked(self, event):
        # add new node to model in mv
        node_id = mvops.add_node(self._cur_model, event.text())
        # render to scene
        self._add_node_to_scene(node_id, event.text())
        self.plainTextEdit.appendPlainText("Added node of type {} to model".format(event.text()))

    def _on_verify_clicked(self, event):
        self.plainTextEdit.appendPlainText("Verifying instance model against example models ...")
        self.plainTextEdit.repaint()
        QApplication.setOverrideCursor(Qt.WaitCursor)

        verify = Verifier(self._cur_model)
        verify.init()

        self.plainTextEdit.appendPlainText("Verify: Checking node typing ...")
        self.plainTextEdit.repaint()
        ret = verify.verify_node_typing()
        if not ret["OK"]:
            self.plainTextEdit.appendPlainText("Error: {}".format(str(ret["error"])))
            QApplication.restoreOverrideCursor()
            return
        else:
            self.plainTextEdit.appendPlainText("OK")
            self.plainTextEdit.repaint()

        self.plainTextEdit.appendPlainText("Verify: Checking node multiplicity ...")
        self.plainTextEdit.repaint()
        ret = verify.verify_node_multiplicity()
        if not ret["OK"]:
            self.plainTextEdit.appendPlainText("Error: {}".format(str(ret["error"])))
            QApplication.restoreOverrideCursor()
            return
        else:
            self.plainTextEdit.appendPlainText("OK")
            self.plainTextEdit.repaint()

        self.plainTextEdit.appendPlainText("Verify: Checking attributes ...")
        self.plainTextEdit.repaint()
        ret = verify.verify_attributes()
        if not ret["OK"]:
            self.plainTextEdit.appendPlainText("Error: {}".format(str(ret["error"])))
            self._scene.highlight_node(ret["affected"][0], Qt.red)
            QApplication.restoreOverrideCursor()
            return
        else:
            self.plainTextEdit.appendPlainText("OK")
            self.plainTextEdit.repaint()

        self.plainTextEdit.appendPlainText("Verify: Checking edges ...")
        self.plainTextEdit.repaint()
        ret = verify.verify_associations()
        if not ret["OK"]:
            self.plainTextEdit.appendPlainText("Error: {}".format(str(ret["error"])))
            QApplication.restoreOverrideCursor()
            return
        else:
            self.plainTextEdit.appendPlainText("OK")
            self.plainTextEdit.repaint()

        self.plainTextEdit.appendPlainText("Verify OK")
        QApplication.restoreOverrideCursor()

    def _on_attribute_edited(self, item):
        # type: (QTableWidgetItem) -> None
        """ An attribute was edited, change it in the model if supported.
        If the new entered value is empty, delete the attribute.
        """
        row = self.tableWidget.row(item)
        attr_key = self.tableWidget.item(row, 0).text()
        attr_val = self.tableWidget.item(row, 1).text()
        node = self._scene.selectedItems()[0]

        if not attr_val:
            if commons.is_attribute_mandatory(node.get_type(), attr_key):
                self.plainTextEdit.appendPlainText("Error: attribute {} mandatory".format(attr_key))
                return

            self.plainTextEdit.appendPlainText("Deleting attribute {}".format(attr_key))
            mvops.delete_attribute_from_node(self._cur_model, node.node_id, attr_key)
            self.tableWidget.removeRow(row)
        else:
            self.plainTextEdit.appendPlainText("Updating value of attribute {} to {}".format(attr_key, attr_val))
            mvops.update_attribute_val(self._cur_model, node.node_id, attr_key, attr_val)

    def add_new_attribute(self, key, val="unknown"):
        """
        Adds a new attribute to the view with key "key" and optional val. Also adds this attribute to the modelverse
        model.
        """
        selected_node = self._scene.selectedItems()[0]
        self.plainTextEdit.appendPlainText("Adding new attribute with key {} to node {}".format(key, selected_node.get_type()))
        self.tableWidget.blockSignals(True)
        table_item_key = QTableWidgetItem(key)
        table_item_key.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
        table_item_val = QTableWidgetItem(val)
        cur_row_cnt = self.tableWidget.rowCount()
        self.tableWidget.insertRow(cur_row_cnt)
        self.tableWidget.setItem(cur_row_cnt, 0, table_item_key)
        self.tableWidget.setItem(cur_row_cnt, 1, table_item_val)
        self.tableWidget.blockSignals(False)

        # add to modelverse
        mvops.add_attribute(self._cur_model, selected_node.node_id, key, val)

    def _on_delete_model_clicked(self, event):
        self.plainTextEdit.appendPlainText("Deleting model ...")
        self.plainTextEdit.repaint()

        if mvops.delete_instance_model(self._cur_model):
            self.close()
        else:
            self.plainTextEdit.appendPlainText("Error: Delete failed")