use evolution handlers for edge add/delete as well

evolution/edge_ops.py

@@ -26,15 +26,16 @@ class EdgeAdd(object):
                     for nt in nodes_to:
                         self.execute(m, nf, nt, local=True)
 
+
     def _callback(self, model):
-        mv.instantiate(model, "gm/Edge", ("gm/"+self._from_node, "gm/"+self._to_node), ID="e")
+        mv.instantiate(model, "gm/Edge", ("gm/"+self._from_node, "gm/"+self._to_node))
 
 
 class EdgeDel(object):
     def __init__(self):
         self._edge = ""
 
-    def execute(self, model, edge, local, check_last=False):
+    def execute(self, model, edge, local, check_if_last=False):
         self._edge = edge
         from_node = mv.read_association_source(model, edge)[0]
         to_node = mv.read_association_destination(model, edge)[0]
@@ -44,7 +45,7 @@ class EdgeDel(object):
         if local:
             mv.transformation_execute_MANUAL("graph_ops/del_edge", {"gm":model}, {"gm":model},
                                              callback=self._callback)
-        if check_last:
+        if check_if_last:
             # check if this association was the last one in all example models
             # if yes, delete it from all instance models as well to preserve their validity
             remaining_instances = 0

sketchUI/exm_mainwindow.py

@@ -213,6 +213,8 @@ class EXMMainWindow(QMainWindow, Ui_MainWindow):
             # empty
             return
 
+        self._scene.clear()
+
         x_pos = -150
         y_pos = 70
         for item in model:
@@ -254,7 +256,7 @@ class EXMMainWindow(QMainWindow, Ui_MainWindow):
             if node_id == to_id:
                 to_item = item
 
-        self._scene.draw_edge(from_item, to_item, is_new=False, edge_id=edge_id)
+        self._scene.draw_edge(from_item, to_item, edge_id=edge_id)
 
     def _on_list_item_clicked(self, event):
         # add node to model

sketchUI/exm_scene.py

@@ -8,6 +8,7 @@ from sketchUI.graphics_sketch_group import SketchGroup
 from sketchUI.graphics_sketch_line import SketchedLineItem
 from sketchUI import mvops
 from evolution.node_ops import NodeAdd, NodeDelete, NodeRetype
+from evolution.edge_ops import EdgeDel, EdgeAdd
 from evolution.attribute_ops import AttributeAdd
 import commons
 
@@ -43,18 +44,15 @@ class SketchScene(QGraphicsScene):
             return False
         return True
 
-    def draw_edge(self, from_item, to_item, is_new, edge_id=None):
-        # type: (GraphicsNodeItem, GraphicsNodeItem, bool, str) -> None
-        # draw an edge between two items. If is_new, also add it to the model
+    def draw_edge(self, from_item, to_item, edge_id=None):
+        # type: (GraphicsNodeItem, GraphicsNodeItem, str) -> GraphicsEdgeItem
+        # draw an edge between two items.
         line = GraphicsEdgeItem(from_item, to_item, edge_id)
         line.setFlag(QGraphicsItem.ItemIsMovable, False)
         line.setFlag(QGraphicsItem.ItemIsSelectable, False)
         self.addItem(line)
         line.redraw()
-
-        if is_new:
-            edge_id = mvops.add_edge(self._cur_model, from_item.node_id, to_item.node_id)
-            line.edge_id = edge_id
+        return line
 
     def mousePressEvent(self, event):
         if event.button() == Qt.LeftButton and self._in_draw_mode():
@@ -94,7 +92,8 @@ class SketchScene(QGraphicsScene):
                 self._parent.tableWidget.blockSignals(False)
 
             elif isinstance(item, GraphicsEdgeItem):
-                self._parent.plainTextEdit.appendPlainText("Selected edge")
+                self._parent.plainTextEdit.appendPlainText("Selected edge ({},{}),id={}".format(item.from_item.get_type(),
+                                                                                                item.to_item.get_type(), item.edge_id))
 
         else:
             pass
@@ -171,7 +170,26 @@ class SketchScene(QGraphicsScene):
                 item = self.itemAt(event.scenePos(), QTransform())
                 if not item or not isinstance(item, GraphicsNodeItem):
                     return
-                self.draw_edge(self._connect_from_item, item, is_new=True)
+
+                from_item = self._connect_from_item
+                to_item = item
+                # global or local edge add?
+                scope, ok = QInputDialog.getItem(self._parent, "Select scope", "Scope", ["Local", "Global"])
+                if not ok:
+                    return
+
+                QApplication.setOverrideCursor(Qt.WaitCursor)
+                add_handler = EdgeAdd()
+
+                if scope == "Global":
+                    add_handler.execute(self._cur_model, from_item.node_id, to_item.node_id, local=False)
+                else:
+                    add_handler.execute(self._cur_model, from_item.node_id, to_item.node_id, local=True)
+                    self.draw_edge(self._connect_from_item, item)
+
+                # reload model because only then the ids of the edges get set anew
+                self._parent._load_model()
+                QApplication.restoreOverrideCursor()
 
             else:
                 pass
@@ -361,12 +379,32 @@ class SketchScene(QGraphicsScene):
     def _handle_keypress_delete(self, selected):
         if len(selected) == 1 and isinstance(selected[0], GraphicsEdgeItem):
             # an edge is to be deleted
-            # TODO: use evolution code
-            self._parent.plainTextEdit.appendPlainText("Deleting edge")
             edge = selected[0]
-            mvops.delete_node(self._cur_model, edge.edge_id)
-            self.removeItem(edge)
-            return
+            edge_from_type = edge.from_item.get_type()
+            edge_to_type = edge.to_item.get_type()
+            self._parent.plainTextEdit.appendPlainText("Deleting edge ({},{}),id={}".format(edge_from_type, edge_to_type, edge.edge_id))
+
+            # local or global?
+            scope, ok = QInputDialog.getItem(self._parent, "Select scope", "Scope", ["Local", "Global"])
+            if not ok:
+                return
+
+            del_handler = EdgeDel()
+            QApplication.setOverrideCursor(Qt.WaitCursor)
+            if scope == "Global":
+                del_handler.execute(self._cur_model, edge.edge_id, local=False, check_if_last=False)
+                # delete all edges with same typing in view
+                for item in self.items():
+                    if not isinstance(item, GraphicsEdgeItem):
+                        continue
+                    if item.from_item.get_type() in [edge_from_type, edge_to_type] and item.to_item.get_type() in [edge_from_type, edge_to_type]:
+                        self.removeItem(item)
+            else:
+                del_handler.execute(self._cur_model, edge.edge_id, local=True, check_if_last=True)
+                # delete from view
+                self.removeItem(edge)
+
+            QApplication.restoreOverrideCursor()
 
         elif len(selected) == 1 and isinstance(selected[0], GraphicsNodeItem):
             del_hander = NodeDelete()