updated remove antenna logic to simplify, updated wireless edges to be objects

coretk/coretk/coreclient.py

@@ -121,13 +121,12 @@ class CoreClient:
     def handle_events(self, event):
         if event.HasField("link_event"):
             logging.info("link event: %s", event)
-            self.app.canvas.wireless_draw.handle_link_event(event.link_event)
+            self.handle_link_event(event.link_event)
         elif event.HasField("session_event"):
             logging.info("session event: %s", event)
             session_event = event.session_event
             if session_event.event <= core_pb2.SessionState.SHUTDOWN:
                 self.state = event.session_event.event
-            # mobility start
             elif session_event.event in {7, 8, 9}:
                 node_id = session_event.node_id
                 dialog = self.mobility_players.get(node_id)
@@ -145,6 +144,19 @@ class CoreClient:
         else:
             logging.info("unhandled event: %s", event)
 
+    def handle_link_event(self, event):
+        node_one_id = event.link.node_one_id
+        node_two_id = event.link.node_two_id
+        canvas_node_one = self.canvas_nodes[node_one_id]
+        canvas_node_two = self.canvas_nodes[node_two_id]
+
+        if event.message_type == core_pb2.MessageType.ADD:
+            self.app.canvas.add_wireless_edge(canvas_node_one, canvas_node_two)
+        elif event.message_type == core_pb2.MessageType.DELETE:
+            self.app.canvas.delete_wireless_edge(canvas_node_one, canvas_node_two)
+        else:
+            logging.warning("unknown link event: %s", event.message_type)
+
     def handle_node_event(self, event):
         if event.source == "gui":
             return

coretk/coretk/graph.py

@@ -17,7 +17,6 @@ from coretk.images import Images
 from coretk.linkinfo import LinkInfo, Throughput
 from coretk.nodedelete import CanvasComponentManagement
 from coretk.nodeutils import NodeUtils
-from coretk.wirelessconnection import WirelessConnection
 
 NODE_TEXT_OFFSET = 5
 
@@ -50,6 +49,7 @@ class CanvasGraph(tk.Canvas):
         self.context = None
         self.nodes = {}
         self.edges = {}
+        self.wireless_edges = {}
         self.drawing_edge = None
         self.grid = None
         self.canvas_management = CanvasComponentManagement(self, core)
@@ -58,7 +58,6 @@ class CanvasGraph(tk.Canvas):
         self.core = core
         self.helper = GraphHelper(self, core)
         self.throughput_draw = Throughput(self, core)
-        self.wireless_draw = WirelessConnection(self, core)
 
         # background related
         self.wallpaper_id = None
@@ -120,8 +119,8 @@ class CanvasGraph(tk.Canvas):
         self.selected = None
         self.nodes.clear()
         self.edges.clear()
+        self.wireless_edges.clear()
         self.drawing_edge = None
-        self.wireless_draw.map.clear()
         self.draw_session(session)
 
     def setup_bindings(self):
@@ -162,6 +161,25 @@ class CanvasGraph(tk.Canvas):
         self.tag_lower("gridline")
         self.tag_lower(self.grid)
 
+    def add_wireless_edge(self, src, dst):
+        token = tuple(sorted((src.id, dst.id)))
+        x1, y1 = self.coords(src.id)
+        x2, y2 = self.coords(dst.id)
+        position = (x1, y1, x2, y2)
+        edge = CanvasWirelessEdge(token, position, src.id, dst.id, self)
+        self.wireless_edges[token] = edge
+        src.wireless_edges.add(edge)
+        dst.wireless_edges.add(edge)
+        self.tag_raise(src.id)
+        self.tag_raise(dst.id)
+
+    def delete_wireless_edge(self, src, dst):
+        token = tuple(sorted((src.id, dst.id)))
+        edge = self.wireless_edges.pop(token)
+        edge.delete()
+        src.wireless_edges.remove(edge)
+        dst.wireless_edges.remove(edge)
+
     def draw_session(self, session):
         """
         Draw existing session.
@@ -187,7 +205,7 @@ class CanvasGraph(tk.Canvas):
             canvas_node_two = self.core.canvas_nodes[link.node_two_id]
             node_two = canvas_node_two.core_node
             if link.type == core_pb2.LinkType.WIRELESS:
-                self.wireless_draw.add_connection(link.node_one_id, link.node_two_id)
+                self.add_wireless_edge(canvas_node_one, canvas_node_two)
             else:
                 is_node_one_wireless = NodeUtils.is_wireless_node(node_one.type)
                 is_node_two_wireless = NodeUtils.is_wireless_node(node_two.type)
@@ -492,6 +510,20 @@ class CanvasGraph(tk.Canvas):
             self.itemconfig("gridline", state=tk.HIDDEN)
 
 
+class CanvasWirelessEdge:
+    def __init__(self, token, position, src, dst, canvas):
+        self.token = token
+        self.src = src
+        self.dst = dst
+        self.canvas = canvas
+        self.id = self.canvas.create_line(
+            *position, tags="wireless", width=1.5, fill="#009933"
+        )
+
+    def delete(self):
+        self.canvas.delete(self.id)
+
+
 class CanvasEdge:
     """
     Canvas edge class
@@ -580,7 +612,7 @@ class CanvasNode:
         self.canvas.tag_bind(self.id, "<Leave>", self.on_leave)
         self.edges = set()
         self.interfaces = []
-        self.wlans = []
+        self.wireless_edges = set()
         self.moving = None
 
     def redraw(self):
@@ -605,7 +637,14 @@ class CanvasNode:
             else:
                 self.canvas.coords(edge.id, x1, y1, x, y)
             edge.link_info.recalculate_info()
-        self.canvas.helper.update_wlan_connection(old_x, old_y, x, y, self.wlans)
+        for edge in self.wireless_edges:
+            x1, y1, x2, y2 = self.canvas.coords(edge.id)
+            if edge.src == self.id:
+                self.canvas.coords(edge.id, x, y, x2, y2)
+            else:
+                self.canvas.coords(edge.id, x1, y1, x, y)
+        if self.app.core.is_runtime():
+            self.app.core.edit_node(self.core_node.id, int(x), int(y))
 
     def on_enter(self, event):
         if self.app.core.is_runtime() and self.app.core.observer:

coretk/coretk/nodedelete.py

@@ -1,7 +1,7 @@
 """
 manage deletion
 """
-from core.api.grpc import core_pb2
+from coretk.nodeutils import NodeUtils
 
 
 class CanvasComponentManagement:
@@ -48,48 +48,6 @@ class CanvasComponentManagement:
         edges = set()
         nodes = []
 
-        node_to_wlink = {}
-        for link_tuple in self.canvas.wireless_draw.map:
-            nid_one, nid_two = link_tuple
-            if nid_one not in node_to_wlink:
-                node_to_wlink[nid_one] = []
-            if nid_two not in node_to_wlink:
-                node_to_wlink[nid_two] = []
-            node_to_wlink[nid_one].append(link_tuple)
-            node_to_wlink[nid_two].append(link_tuple)
-
-        # delete antennas and wireless links
-        for cnid in self.selected:
-            canvas_node = self.canvas.nodes[cnid]
-            if canvas_node.core_node.type != core_pb2.NodeType.WIRELESS_LAN:
-                canvas_node.antenna_draw.delete_antennas()
-            else:
-                for e in canvas_node.edges:
-                    link_proto = self.app.links[e.token]
-                    node_one_id, node_two_id = (
-                        link_proto.node_one_id,
-                        link_proto.node_two_id,
-                    )
-                    if node_one_id == canvas_node.core_node.id:
-                        neighbor_id = node_two_id
-                    else:
-                        neighbor_id = node_one_id
-                    neighbor = self.app.canvas_nodes[neighbor_id]
-                    if neighbor.core_node.type != core_pb2.NodeType.WIRELESS_LAN:
-                        neighbor.antenna_draw.delete_antenna()
-
-            for link_tuple in node_to_wlink.get(canvas_node.core_node.id, []):
-                nid_one, nid_two = link_tuple
-                if link_tuple in self.canvas.wireless_draw.map:
-                    self.canvas.delete(self.canvas.wireless_draw.map[link_tuple])
-                    link_cid = self.canvas.wireless_draw.map.pop(link_tuple, None)
-                    canvas_node_one = self.app.canvas_nodes[nid_one]
-                    canvas_node_two = self.app.canvas_nodes[nid_two]
-                    if link_cid in canvas_node_one.wlans:
-                        canvas_node_one.wlans.remove(link_cid)
-                    if link_cid in canvas_node_two.wlans:
-                        canvas_node_two.wlans.remove(link_cid)
-
         for node_id in list(self.selected):
             bbox_id = self.selected[node_id]
             canvas_node = self.canvas.nodes.pop(node_id)
@@ -97,6 +55,13 @@ class CanvasComponentManagement:
             self.canvas.delete(node_id)
             self.canvas.delete(bbox_id)
             self.canvas.delete(canvas_node.text_id)
+
+            # delete antennas
+            is_wireless = NodeUtils.is_wireless_node(canvas_node.core_node.type)
+            if is_wireless:
+                canvas_node.antenna_draw.delete_antennas()
+
+            # delete related edges
             for edge in canvas_node.edges:
                 if edge in edges:
                     continue
@@ -116,5 +81,7 @@ class CanvasComponentManagement:
                     other_node.interfaces.remove(other_interface)
                 except ValueError:
                     pass
+                if is_wireless:
+                    other_node.antenna_draw.delete_antenna()
         self.selected.clear()
         return nodes

coretk/coretk/wirelessconnection.py

@@ -1,51 +0,0 @@
-"""
-Wireless connection handler
-"""
-from core.api.grpc import core_pb2
-
-
-class WirelessConnection:
-    def __init__(self, canvas, core):
-        self.canvas = canvas
-        self.core = core
-        # map a (node_one_id, node_two_id) to a wlan canvas id
-        self.map = {}
-
-    def add_connection(self, node_one_id, node_two_id):
-        canvas_node_one = self.core.canvas_nodes[node_one_id]
-        canvas_node_two = self.core.canvas_nodes[node_two_id]
-        key = tuple(sorted((node_one_id, node_two_id)))
-        if key not in self.map:
-            x1, y1 = self.canvas.coords(canvas_node_one.id)
-            x2, y2 = self.canvas.coords(canvas_node_two.id)
-            wlan_canvas_id = self.canvas.create_line(
-                x1, y1, x2, y2, fill="#009933", tags="wireless", width=1.5
-            )
-            self.map[key] = wlan_canvas_id
-            canvas_node_one.wlans.append(wlan_canvas_id)
-            canvas_node_two.wlans.append(wlan_canvas_id)
-        else:
-            print("in map")
-            self.canvas.itemconfig(self.map[key], state="normal")
-
-    def delete_connection(self, node_one_id, node_two_id):
-        canvas_node_one = self.core.canvas_nodes[node_one_id]
-        canvas_node_two = self.core.canvas_nodes[node_two_id]
-        key = tuple(sorted((node_one_id, node_two_id)))
-        wlan_canvas_id = self.map[key]
-        canvas_node_one.wlans.remove(wlan_canvas_id)
-        canvas_node_two.wlans.remove(wlan_canvas_id)
-        self.canvas.delete(wlan_canvas_id)
-        self.map.pop(key, None)
-
-    def handle_link_event(self, link_event):
-        if link_event.message_type == core_pb2.MessageType.ADD:
-            self.add_connection(
-                link_event.link.node_one_id, link_event.link.node_two_id
-            )
-            self.canvas.tag_raise("node")
-
-        if link_event.message_type == core_pb2.MessageType.DELETE:
-            self.delete_connection(
-                link_event.link.node_one_id, link_event.link.node_two_id
-            )