fix boxing

python/box.py

@@ -21,11 +21,11 @@ BOX_PADDING = 20
 # when we don't want it to be visible.  We can't just setVisible(False)
 # because QGraphicsView still reserves space for it.  We can't unparent
 # the top-level box in the QGraphicsView because top-level items are
-# managed differently.  We prevent this problem by removing hide capability
-# from the background box in component_visibility_menus.
+# managed differently.  We prevent the top-level box from being able
+# to be hidden.
 class _UnparentedItem(QGraphicsItem):
     def __init__(self):
-        super().__init__(parent=None)
+        super().__init__()
     def boundingRect(self):
         raise RuntimeError("bad")
     def paint(self, _painter, _option, _widget):
@@ -34,31 +34,29 @@ class _UnparentedItem(QGraphicsItem):
 class Box(QGraphicsItem):
 
     def __init__(self, parent, box_type, gry_data):
-        super().__init__(parent=parent)
+        super().__init__()
         self.box_type = box_type
         self.parent = parent
-        self.is_visible = gry_data["is_visible"]
-        self._set_parent(self.is_visible)
+        self.is_visible = gry_data["is_visible"] or box_type == BACKGROUND_BOX
         self.is_boxed = gry_data["is_boxed"]
         self.setPos(QPoint(gry_data["x"], gry_data["y"]))
 
+        self.reset_appearance()
+
         # graphicsItem mode
+        self._set_parent(self.is_visible)
         if self.parentItem():
             self.setFlag(QGraphicsItem.ItemIsMovable)
             self.setFlag(QGraphicsItem.ItemIsSelectable)
         self.setFlag(QGraphicsItem.ItemSendsGeometryChanges)
         self.setAcceptHoverEvents(True)
-        self.reset_appearance()
 
     def _set_parent(self, is_visible):
-        print("_set_parent on %d"%self.box_type, is_visible)
         # parent or unparent this box for visibility in QGraphicsView tree
         if is_visible:
             self.setParentItem(self.parent)
         else:
-#            self._unparented_item = _UnparentedItem()
-#zz
-            self._unparented_item = None
+            self._unparented_item = _UnparentedItem()
             self.setParentItem(self._unparented_item)
 
     def set_visible(self, is_visible):
@@ -75,7 +73,7 @@ class Box(QGraphicsItem):
 
     def set_boxed(self, is_boxed):
         self.is_boxed = is_boxed
-        if is_boxed and not is_visible:
+        if is_boxed and not self.is_visible:
             # when making box visible make contents visible too
             self.set_visible(True)
         self.reset_appearance()
@@ -83,8 +81,8 @@ class Box(QGraphicsItem):
     def itemChange(self, change, value):
         self.reset_appearance()
 
-        # change parent unless at top background box
-        if not self.box_type == BACKGROUND_BOX:
+        # change parent unless at top background box or not initialized
+        if self.parentItem():
             self.parentItem().itemChange(change, value)
 
         return super(Box, self).itemChange(change, value)
@@ -97,45 +95,28 @@ class Box(QGraphicsItem):
                     "x":self.x(), "y":self.y(), "is_visible":self.is_visible}
         return gry_data
 
-##zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
-#    def childrenBoundingRect(self):
-#        return QRectF(0,0,500,500)
-##zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
-
    # adjust for appearance change
     def reset_appearance(self):
-#        print("box.reset_appearance.a", 5/0)
 
         # make the box
         self.painter_path = QPainterPath()
-        print("box.reset_appearance.b", self.box_type)
         if self.is_boxed:
-            print("box.reset_appearance.c")
             p = BOX_PADDING
             rectangle = self.childrenBoundingRect().adjusted(-p, -p, p, p)
             self.painter_path.addRect(rectangle)
             self.bounding_rect = rectangle.adjusted(-1, -1, 1, 1)
         else:
-            print("box.reset_appearance.d")
-            print(self)
-            print(self.childrenBoundingRect())
-            print("box.reset_appearance.d2")
             self.bounding_rect = self.childrenBoundingRect().adjusted(
                                                     -1, -1, 1, 1)
 
-        print("box.reset_appearance.e")
         # shape without auto-fill
         stroker = QPainterPathStroker()
-        print("box.reset_appearance.f")
         self.shape_path = stroker.createStroke(self.painter_path).simplified()
-        print("box.reset_appearance.g")
 
         # pen color
         self.pen_color = preferred_pen_color()
 
-        print("box.reset_appearance.h")
         self.prepareGeometryChange()
-        print("box.reset_appearance.i")
 
     # draw inside this rectangle
     def boundingRect(self):

python/component_visibility_menus.py

@@ -6,7 +6,7 @@ from PyQt5.QtGui import QCursor
 from settings_manager import emit_signal_settings_changed
 
 """
-Provides menu for changing visibility of a component and its box.
+Provides menu for changing visibility of a component and its box border.
 
 Data structure:
   * menu
@@ -20,9 +20,9 @@ class ComponentVisibilityMenu(QObject):
 
     def _make_change(self, component, is_box, is_show):
         if is_box:
-            component.show_box(is_show)
+            component.set_boxed(is_show)
         else:
-            component.show_contents(is_show)
+            component.set_visible(is_show)
         emit_signal_settings_changed()
 
     # action = show|hide, boxes|components, all_groups|<group name>
@@ -37,9 +37,9 @@ class ComponentVisibilityMenu(QObject):
                 self._make_change(graph.background_box, is_box, True)
 
         # trace
-        if graph.trace_box:
+        if graph.has_trace():
             if "all_groups" in group or "traces" in group:
-                self._make_change(graph.trace_box, is_box, is_show)
+                self._make_change(graph.trace.trace_box, is_box, is_show)
 
         # reports
         if "all_groups" in group or "reports" in group:
@@ -110,11 +110,11 @@ class ComponentVisibilityMenu(QObject):
 
     def _add_group_menus(self, parent_menu, is_selected_graph):
           
-        menu = QMenu("Show boxes in group")
+        menu = QMenu("Show borders in group")
         parent_menu.addMenu(menu)
         self._menus.append(menu)
         self._add_menu_group(menu, is_selected_graph, True, True)
-        menu = QMenu("Hide boxes in group")
+        menu = QMenu("Hide borders in group")
         parent_menu.addMenu(menu)
         self._menus.append(menu)
         self._add_menu_group(menu, is_selected_graph, True, False)
@@ -141,31 +141,31 @@ class ComponentVisibilityMenu(QObject):
 
 def embedded_box_menu(component):
 
-    action_show_box = QAction("Show box")
-    action_show_box.setCheckable(True)
+    action_set_boxed = QAction("Show box")
+    action_set_boxed.setCheckable(True)
     @pyqtSlot(bool)
-    def _show_box(is_show_box):
-        component.show_box(is_show_box)
+    def _set_boxed(is_set_boxed):
+        component.set_boxed(is_set_boxed)
         emit_signal_settings_changed()
-    action_show_box.triggered.connect(_show_box)
+    action_set_boxed.triggered.connect(_set_boxed)
 
-    action_show_component = QAction("Show component")
-    action_show_component.setCheckable(True)
+    action_set_visible = QAction("Show component")
+    action_set_visible.setCheckable(True)
     @pyqtSlot(bool)
-    def _show_component(is_show_component):
-        component.show_contents(is_show_component)
+    def _set_visible(is_visible):
+        component.set_visible(is_visible)
         emit_signal_settings_changed()
-    action_show_component.triggered.connect(_show_component)
+    action_set_visible.triggered.connect(_set_visible)
 
     def _about_to_show():
         # show visibility status but disallow hiding the background component
-        action_show_box.setChecked(component._show_box)
-        action_show_component.setChecked(component._visible)
-        action_show_component.setEnabled(bool(component.parentItem()))
+        action_set_boxed.setChecked(component.is_boxed)
+        action_set_visible.setChecked(component.is_visible)
+        action_set_visible.setEnabled(bool(component.parentItem()))
 
     menu = QMenu()
     menu.aboutToShow.connect(_about_to_show)
-    menu.addAction(action_show_box)
-    menu.addAction(action_show_component)
+    menu.addAction(action_set_boxed)
+    menu.addAction(action_set_visible)
     _action = menu.exec(QCursor.pos())
 

python/edge.py

@@ -22,8 +22,7 @@ from graph_constants import EDGE_TYPE
 class Edge(QGraphicsItem):
 
     def __init__(self, parent, gry_edge, node_lookup):
-#zz        super().__init__(parent=parent)
-        super().__init__(parent=None)
+        super().__init__()
 
         # MP attributes
         self.source_id = gry_edge["source"]
@@ -55,6 +54,8 @@ class Edge(QGraphicsItem):
         # appearance
         self.reset_appearance()
 
+        self.setParentItem(parent)
+
     def type(self):
         return EDGE_TYPE
 

python/graph_item.py

@@ -32,33 +32,33 @@ class GraphItem(QObject):
             # already done
             return
 
+        print("GraphItem.initialize_items")
+
         gry_graph = self.gry_graph
 
         # top box
         self.background_box = Box(None, BACKGROUND_BOX, gry_graph["box"])
 
-        print("checkpoint.a")
+        # trace
         self.trace = None
         if "trace" in gry_graph:
-            print("GraphItem.a", gry_graph["trace"])
             self.trace = ViewTrace(self.background_box, gry_graph["trace"])
 
-        print("checkpoint.b")
         # view | report
-        self.reports = list()
+        self.view_reports = list()
         for gry_report in gry_graph["reports"]:
-            self.reports.append(ViewReport(self.background_box,
+            self.view_reports.append(ViewReport(self.background_box,
                                                                   gry_report))
 
         # view | table
-        self.tables = list()
+        self.view_tables = list()
         for gry_table in gry_graph["tables"]:
-            self.tables.append(ViewTable(self.background_box, gry_table))
+            self.view_tables.append(ViewTable(self.background_box, gry_table))
 
         # view | graph
-        self.graphs = list()
+        self.view_graphs = list()
         for gry_graph in gry_graph["graphs"]:
-            self.graphs.append(ViewGraph(self.background_box, gry_graph))
+            self.view_graphs.append(ViewGraph(self.background_box, gry_graph))
 
         # other views
         self.view_says = list()
@@ -81,15 +81,15 @@ class GraphItem(QObject):
                 gry_graph["trace"] = self.trace.get_gry()
 
             # view | report
-            for report in self.reports:
+            for report in self.view_reports:
                 gry_graph["reports"].append(report.get_gry())
 
             # view | table
-            for table in self.tables:
+            for table in self.view_tables:
                 gry_graph["tables"].append(table.get_gry())
 
             # view | graph
-            for graph in self.graphs:
+            for graph in self.view_graphs:
                 gry_graph["graphs"].append(graph.get_gry())
 
             return gry_graph
@@ -97,24 +97,27 @@ class GraphItem(QObject):
             return self.gry_graph
 
     def paint_items(self, painter, _option, _widget):
+
+        # background box
+        self.background_box.paint(painter, _option, _widget)
         # trace
         if self.has_trace():
             self.trace.paint_items(painter, _option, _widget)
 
         # any views:
-        for report in self.reports:
+        for report in self.view_reports:
             painter.save()
             painter.translate(report.pos())
             report.paint(painter, option, None)
             painter.restore()
 
-        for table in self.tables:
+        for table in self.view_tables:
             painter.save()
             painter.translate(table.pos())
             table.paint(painter, option, None)
             painter.restore()
 
-        for graph in self.graphs:
+        for graph in self.view_graphs:
             painter.save()
             painter.translate(graph.pos())
             graph.paint(painter, option, None)
@@ -124,7 +127,7 @@ class GraphItem(QObject):
         return bool(self.trace)
 
     def has_non_trace(self):
-        return bool(self.reports or self.tables or self.graphs)
+        return bool(self.view_reports or self.view_tables or self.view_graphs)
 
     # maybe box coordinates are not set
     def _maybe_set_x(self, graphics_item):
@@ -139,11 +142,11 @@ class GraphItem(QObject):
             self.background_box.reset_appearance()
             if self.has_trace():
                 self.trace.reset_appearance()
-            for report in self.reports:
+            for report in self.view_reports:
                 report.reset_appearance()
-            for table in self.tables:
+            for table in self.view_tables:
                 table.reset_appearance()
-            for graph in self.graphs:
+            for graph in self.view_graphs:
                 graph.reset_appearance()
 
     def change_item_spacing(self, ratios):

python/graphs_manager.py

@@ -56,6 +56,7 @@ class GraphsManager(QObject):
     def set_graphs(self, gry_data):
         self.gry_data = gry_data
         self.graphs = list()
+
         for gry_graph in gry_data["graphs"]:
              self.graphs.append(GraphItem(gry_graph))
         self.selected_graph_index = gry_data["selected_graph_index"]

python/node.py

@@ -19,9 +19,7 @@ from graph_constants import NODE_TYPE
 class Node(QGraphicsItem):
 
     def __init__(self, parent, gry_node, trace):
-        print("Node.a0.parent", parent.box_type)
-        super().__init__(parent=parent)
-        print("Node.a.parent", parent.box_type)
+        super().__init__()
         self.node_id = gry_node["id"]
         self.node_type = gry_node["type"]
         self.label = gry_node["label"]
@@ -47,6 +45,9 @@ class Node(QGraphicsItem):
 
         # appearance
         self.reset_appearance()
+
+        self.setParentItem(parent)
+
     # export
     def get_gry(self):
         gry_node = dict()

python/view_trace.py

@@ -10,34 +10,25 @@ class ViewTrace(QObject):
 
     def __init__(self, background_box, gry_trace):
         super().__init__()
-        print("ViewTrace", gry_trace)
 
-        print("ViewTrace.a")
         self.background_box = background_box
         self.gry_trace = gry_trace
 
-        print("ViewTrace.b")
         self.trace_box = Box(background_box, TRACE_BOX, gry_trace["box"])
 
-        print("ViewTrace.c")
         # trace parts
         self.mark = gry_trace["graph_mark"]
         self.layout = gry_trace["layout"]
         self.probability = gry_trace["probability"]
         self.nodes = list()
         node_lookup = dict()
-        print("ViewTrace.d")
         for gry_node in gry_trace["nodes"]:
-            print("ViewTrace.e")
             node = Node(self.trace_box, gry_node, self)
-            print("ViewTrace.f")
             self.nodes.append(node)
-            print("ViewTrace.g")
             node_lookup[node.node_id] = node
-            print("ViewTrace.h")
+
         self.edges = [Edge(self.trace_box, gry_edge, node_lookup)
                       for gry_edge in gry_trace["edges"]]
-        print("ViewTrace.i")
 
     def get_gry(self):
         gry_trace = {