network: Commment some code and delete some dead code.

src/view/network/GraphWidget.py

@@ -30,7 +30,6 @@ class NodeItem(QGraphicsItem):
         self.setPos(QPointF(self.node.pos.x, self.node.pos.y))
 
         self.graph = graph_widget
-        self.newPos = QPointF()
 
         self.setFlag(QGraphicsItem.ItemIsMovable)
         self.setFlag(QGraphicsItem.ItemSendsGeometryChanges)
@@ -40,13 +39,6 @@ class NodeItem(QGraphicsItem):
     def type(self):
         return NodeItem.Type
 
-    def advance(self):
-        if self.newPos == self.pos():
-            return False
-
-        self.setPos(self.newPos)
-        return True
-
     def boundingRect(self):
         adjust = 2.0
         return QRectF(-10 - adjust, -10 - adjust, 20 + adjust, 20 + adjust)
@@ -59,10 +51,11 @@ class NodeItem(QGraphicsItem):
     def paint(self, painter, option, widget):
         painter.setPen(Qt.NoPen)
 
+        # Select in function of node position in graph or status
         color = Qt.yellow
-        if self.graph.selectedNewEdgeSrcNode() == self:
+        if self.graph.selected_new_edge_src_node() == self:
             color = Qt.darkRed
-        elif self.graph.selectedItem() == self:
+        elif self.graph.selected_item() == self:
             color = Qt.red
         elif not self.graph.graph.is_enable_node(self.node):
             color = Qt.darkGray
@@ -76,8 +69,7 @@ class NodeItem(QGraphicsItem):
 
     def itemChange(self, change, value):
         if change == QGraphicsItem.ItemPositionHasChanged:
-            self.graph.itemMoved()
-            self.graph.nodeChangePosition(value, self)
+            self.graph.node_change_position(value, self)
 
         self.graph.update_edges(self)
         return super(NodeItem, self).itemChange(change, value)
@@ -108,20 +100,6 @@ class EdgeItem(QGraphicsItem):
     def type(self):
         return Edge.Type
 
-    def sourceNode(self):
-        return self.src_node.node
-
-    def setSourceNode(self, node_item):
-        self.src_node = node_item
-        self.adjust()
-
-    def destNode(self):
-        return self.dest
-
-    def setDestNode(self, node_item):
-        self.dest_node = node_item
-        self.adjust()
-
     def adjust(self):
         line = QLineF(
             self.mapFromItem(self.src_node, 0, 0),
@@ -156,7 +134,7 @@ class EdgeItem(QGraphicsItem):
             return
 
         color = Qt.blue
-        if self.graph.selectedItem() == self:
+        if self.graph.selected_item() == self:
             color = Qt.red
         elif self.graph.currentEdge() == self:
             color = Qt.darkBlue
@@ -259,8 +237,8 @@ class GraphWidget(QGraphicsView):
         self.parent = parent
         self._state = "move"
 
-        self._selectedItem = None
-        self._selectedNewEdgeSrcNode = None
+        self._selected_item = None
+        self._selected_new_edge_src_node = None
         self._currentEdge = None
         self.tmp_line = None
 
@@ -287,6 +265,11 @@ class GraphWidget(QGraphicsView):
         self.create_items()
 
     def create_items(self):
+        """Create all items and draw its
+
+        Returns:
+            Nothing
+        """
         self.node_items = []
         self.edge_items = []
         self.texts = {}
@@ -318,9 +301,28 @@ class GraphWidget(QGraphicsView):
             self.edge_items.append(iedge)
 
     def state(self, status):
+        """Set the current status of draw widget
+
+        Set the current status of draw widget, like "move", "add" or
+        "del"
+
+        Args:
+            status: String of current status
+
+        Returns:
+            Nothing
+        """
         self._state = status
 
     def add_node(self, pos):
+        """Create a new node in graph and draw it
+
+        Args:
+            pos: The position of new node
+
+        Returns:
+            Nothing
+        """
         node = self.graph.add_node(pos.x(), pos.y())
         inode = NodeItem(node, self)
         self.scene().addItem(inode)
@@ -331,6 +333,14 @@ class GraphWidget(QGraphicsView):
         self.changeNode.emit(self.sender())
 
     def del_node(self, item):
+        """Delete a node and update display
+
+        Args:
+            item: The node item to delete
+
+        Returns:
+            Nothing
+        """
         node = item.node
         edges = list(
             filter(
@@ -352,42 +362,78 @@ class GraphWidget(QGraphicsView):
         self.changeEdge.emit(self.sender())
 
     def rename_nodes(self):
+        """Update all nodes item name in scene
+
+        Returns:
+            Nothing
+        """
         for i in self.texts:
             if type(i) == NodeItem:
                 self.texts[i].rename()
 
     def display_update(self):
+        """Clear the scene and redraw it
+
+        Returns:
+            Nothing
+        """
         self.scene().clear()
         self.create_items()
 
     def add_edge(self, node1, node2):
+        """Create a new edge in graph and draw it
+
+        Args:
+            node1: The source node
+            node2: The destination node
+
+        Returns:
+            Nothing
+        """
         if node1 == node2:
             return
 
         edge = self.graph.add_edge(node1.node, node2.node)
-        # iedge = EdgeItem(node1, node2, edge, self)
-        # self.scene().addItem(iedge)
-        # self.edge_items.append(iedge)
         self.setSelectedItem(None)
         self.setSelectedNewEdgeSrcNode(None)
-
+        # Reset the temporary line
         self.tmp_line = None
+
+        # Clear all scene and redraw it
         self.scene().clear()
         self.create_items()
 
         self.changeEdge.emit(self.sender())
 
     def del_edge(self, item):
+        """Delete an edge and update display
+
+        Args:
+            item: The edge item to delete
+
+        Returns:
+            Nothing
+        """
         edge = item.edge
         self.graph.remove_edge(edge.name)
 
+        # Clear all scene and redraw it
         self.scene().clear()
         self.create_items()
+
         self.changeNode.emit(self.sender())
         self.changeEdge.emit(self.sender())
 
 
     def update_edges(self, node):
+        """Update display of all edges linked with the node
+
+        Args:
+            node: The node item linked with edges to update
+
+        Returns:
+            Nothing
+        """
         edges = list(
             filter(
                 lambda ie: ie.edge.node1 == node.node or ie.edge.node2 == node.node,
@@ -396,25 +442,41 @@ class GraphWidget(QGraphicsView):
         )
 
         for edge in edges:
-            # edge.node1.update()
-            # edge.node2.update()
             edge.update()
 
-    def itemMoved(self):
-        if not self.timerId:
-            self.timerId = self.startTimer(1000 / 25)
+    def node_change_position(self, pos, node):
+        """Update node position and node text position
+
+        Args:
+            pos: The new position
+            node: The node item
 
-    def nodeChangePosition(self, pos, node):
+        Returns:
+            Nothing
+        """
         node.node.setPos(pos.x(), pos.y())
         self.texts[node].set_custom_pos(pos)
         self.texts[node].update()
 
-    def selectedItem(self):
-        return self._selectedItem
+    def selected_item(self):
+        """Current selected item
+
+        Returns:
+            Item if item ar selected, otherelse None
+        """
+        return self._selected_item
 
     def setSelectedItem(self, item):
-        previous_item = self._selectedItem
-        self._selectedItem = item
+        """Set current selected item
+
+        Args:
+            item: The new item to select
+
+        Returns:
+            Nothing
+        """
+        previous_item = self._selected_item
+        self._selected_item = item
 
         if previous_item:
             previous_item.update()
@@ -422,27 +484,58 @@ class GraphWidget(QGraphicsView):
         if item:
             item.update()
 
-    def selectedNewEdgeSrcNode(self):
-        return self._selectedNewEdgeSrcNode
+    def selected_new_edge_src_node(self):
+        """The current node item selected to add new edge
+
+        Returns:
+            Item if item ar selected, otherelse None
+        """
+        return self._selected_new_edge_src_node
 
     def setSelectedNewEdgeSrcNode(self, node):
-        previous_node = self._selectedNewEdgeSrcNode
-        self._selectedNewEdgeSrcNode = node
+        """Set the current node item selected to add new edge
+
+        Args:
+            node: The new node to select
+
+        Returns:
+            Nothing
+        """
+        previous_node = self._selected_new_edge_src_node
+        self._selected_new_edge_src_node = node
 
         if previous_node:
             previous_node.update()
 
     def currentEdge(self):
+        """The current selected edge
+
+        Returns:
+            Item if edge are selected, otherelse None
+        """
         return self._currentEdge
 
     def setCurrentEdge(self, edge):
-        previous_edge = self._selectedNewEdgeSrcNode
+        """Set the current edge item selected
+
+        Args:
+            edge: The new edge to select
+
+        Returns:
+            Nothing
+        """
+        previous_edge = self._selected_new_edge_src_node
         self._currentEdge = edge
 
         if previous_edge:
             previous_edge.update()
 
     def reset_selection(self):
+        """Reset all the selected items
+
+        Returns:
+            Nothing
+        """
         self.setSelectedNewEdgeSrcNode(None)
         if self.tmp_line is not None:
             self.tmp_line = None
@@ -492,8 +585,10 @@ class GraphWidget(QGraphicsView):
 
     def mousePressEvent(self, event):
         pos = self.mapToScene(event.pos())
+
+        # Move item and select edge item
         if self._state == "move":
-            self._selectedNewEdgeSrcNode = None
+            self._selected_new_edge_src_node = None
 
             self.mouse_origin_x = pos.x()
             self.mouse_origin_y = pos.y()
@@ -504,19 +599,21 @@ class GraphWidget(QGraphicsView):
                 if edge:
                     self.setCurrentEdge(edge)
 
+        # Add nodes and edges
         elif self._state == "add":
             items = self.items(event.pos())
             nodes = list(filter(lambda i: type(i) == NodeItem, items))
             if not nodes:
                 self.add_node(pos)
             else:
-                if self.selectedNewEdgeSrcNode() is None:
+                if self.selected_new_edge_src_node() is None:
                     self.setSelectedNewEdgeSrcNode(nodes[0])
                 else:
-                    self.add_edge(self.selectedNewEdgeSrcNode(), nodes[0])
+                    self.add_edge(self.selected_new_edge_src_node(), nodes[0])
 
+        # Delete nodes and edges
         elif self._state == "del":
-            self._selectedNewEdgeSrcNode = None
+            self._selected_new_edge_src_node = None
             items = list(
                 filter(
                     lambda i: type(i) == NodeItem or type(i) == EdgeItem,
@@ -547,15 +644,17 @@ class GraphWidget(QGraphicsView):
             )
         )
 
+        # Selecte item on the fly
         if selectable_items:
             self.setSelectedItem(selectable_items[0])
         else:
             self.setSelectedItem(None)
 
-        if self.selectedNewEdgeSrcNode() is not None:
+        # Update temporary line
+        if self.selected_new_edge_src_node() is not None:
             if self.tmp_line is None:
                 self.tmp_line = NewEdgeLine(
-                    self.selectedNewEdgeSrcNode().pos(),
+                    self.selected_new_edge_src_node().pos(),
                     pos
                 )
                 self.scene().addItem(self.tmp_line)
@@ -563,6 +662,7 @@ class GraphWidget(QGraphicsView):
                 self.tmp_line.dest = pos
             self.tmp_line.update()
 
+        # If state is "move" propagate event
         if self._state == "move":
             self.update()
             super(GraphWidget, self).mouseMoveEvent(event)