Move element editor layouts to Glade

gaphor/diagram/actions/actionspropertypages.py

@@ -3,149 +3,159 @@
 from gi.repository import Gtk
 
 from gaphor import UML
-from gaphor.core import gettext, transactional
+from gaphor.core import transactional
 from gaphor.diagram.actions.activitynodes import ForkNodeItem
 from gaphor.diagram.actions.objectnode import ObjectNodeItem
-from gaphor.diagram.propertypages import (
-    NamedElementPropertyPage,
-    NamedItemPropertyPage,
-    PropertyPages,
-    create_hbox_label,
-)
+from gaphor.diagram.propertypages import PropertyPageBase, PropertyPages, new_builder
 
 
 @PropertyPages.register(ObjectNodeItem)
-class ObjectNodePropertyPage(NamedItemPropertyPage):
-    """
-    """
+class ObjectNodePropertyPage(PropertyPageBase):
+
+    order = 15
 
     ORDERING_VALUES = ["unordered", "ordered", "LIFO", "FIFO"]
 
     subject: UML.ObjectNode
 
-    def construct(self):
-        page = super().construct()
+    def __init__(self, item):
+        self.item = item
 
-        subject = self.subject
+    def construct(self):
+        subject = self.item.subject
 
         if not subject:
-            return page
-
-        hbox = create_hbox_label(self, page, gettext("Upper bound"))
-        entry = Gtk.Entry()
-        entry.set_text(subject.upperBound or "")
-        entry.connect("changed", self._on_upper_bound_change)
-        hbox.pack_start(entry, True, True, 0)
-
-        hbox = create_hbox_label(self, page, "")
-        combo = Gtk.ComboBoxText()
-        for v in self.ORDERING_VALUES:
-            combo.append_text(v)
-        combo.set_active(self.ORDERING_VALUES.index(subject.ordering))
-        combo.connect("changed", self._on_ordering_change)
-        hbox.pack_start(combo, False, True, 0)
-
-        hbox = create_hbox_label(self, page, "")
-        button = Gtk.CheckButton(gettext("Ordering"))
-        button.set_active(self.item.show_ordering)
-        button.connect("toggled", self._on_ordering_show_change)
-        hbox.pack_start(button, False, True, 0)
-
-        return page
+            return
+
+        builder = new_builder("object-node-editor")
+
+        upper_bound = builder.get_object("upper-bound")
+        upper_bound.set_text(subject.upperBound or "")
+
+        ordering = builder.get_object("ordering")
+        ordering.set_active(self.ORDERING_VALUES.index(subject.ordering))
+
+        show_ordering = builder.get_object("show-ordering")
+        show_ordering.set_active(self.item.show_ordering)
+
+        builder.connect_signals(
+            {
+                "upper-bound-changed": (self._on_upper_bound_change,),
+                "ordering-changed": (self._on_ordering_change,),
+                "show-ordering-changed": (self._on_ordering_show_change,),
+            }
+        )
+
+        return builder.get_object("object-node-editor")
 
     @transactional
     def _on_upper_bound_change(self, entry):
         value = entry.get_text().strip()
-        self.subject.upperBound = value
+        self.item.subject.upperBound = value
 
     @transactional
     def _on_ordering_change(self, combo):
         value = self.ORDERING_VALUES[combo.get_active()]
-        self.subject.ordering = value
+        self.item.subject.ordering = value
 
     @transactional
     def _on_ordering_show_change(self, button):
         self.item.show_ordering = button.get_active()
 
 
 @PropertyPages.register(ForkNodeItem)
-class JoinNodePropertyPage(NamedItemPropertyPage):
-    """
-    """
+class ForkNodePropertyPage(PropertyPageBase):
 
-    subject: UML.JoinNode
+    order = 20
+
+    def __init__(self, item):
+        self.item = item
 
     def construct(self):
-        page = super().construct()
+        builder = new_builder("fork-node-editor")
+
+        horizontal = builder.get_object("horizontal")
+        horizontal.set_active(self.item.matrix[2] != 0)
+
+        builder.connect_signals({"horizontal-changed": (self._on_horizontal_change,)})
+        return builder.get_object("fork-node-editor")
+
+    @transactional
+    def _on_horizontal_change(self, button):
+        if button.get_active():
+            self.item.matrix.rotate(math.pi / 2)
+        else:
+            self.item.matrix.rotate(-math.pi / 2)
+        self.item.request_update()
+
+
+@PropertyPages.register(UML.JoinNode)
+class JoinNodePropertyPage(PropertyPageBase):
+
+    order = 15
+
+    subject: UML.JoinNode
 
+    def __init__(self, subject):
+        self.subject = subject
+
+    def construct(self):
         subject = self.subject
 
         if not subject:
-            return page
-
-        hbox = Gtk.HBox()
-        page.pack_start(hbox, False, True, 0)
+            return
 
-        if isinstance(subject, UML.JoinNode):
-            hbox = create_hbox_label(self, page, gettext("Join specification"))
-            entry = Gtk.Entry()
-            entry.set_text(subject.joinSpec or "")
-            entry.connect("changed", self._on_join_spec_change)
-            hbox.pack_start(entry, True, True, 0)
+        builder = new_builder("join-node-editor")
 
-        button = Gtk.CheckButton(gettext("Horizontal"))
-        button.set_active(self.item.matrix[2] != 0)
-        button.connect("toggled", self._on_horizontal_change)
-        page.pack_start(button, False, True, 0)
+        join_spec = builder.get_object("join-spec")
+        join_spec.set_text(subject.joinSpec or "")
 
-        return page
+        builder.connect_signals({"join-spec-changed": (self._on_join_spec_change,)})
+        return builder.get_object("join-node-editor")
 
     @transactional
     def _on_join_spec_change(self, entry):
         value = entry.get_text().strip()
         self.subject.joinSpec = value
 
-    def _on_horizontal_change(self, button):
-        if button.get_active():
-            self.item.matrix.rotate(math.pi / 2)
-        else:
-            self.item.matrix.rotate(-math.pi / 2)
-        self.item.request_update()
-
 
 @PropertyPages.register(UML.ControlFlow)
 @PropertyPages.register(UML.ObjectFlow)
-class FlowPropertyPageAbstract(NamedElementPropertyPage):
+class FlowPropertyPageAbstract(PropertyPageBase):
     """Flow item element editor."""
 
-    subject: UML.ActivityEdge
+    order = 15
 
-    def construct(self):
-        assert self.watcher
+    subject: UML.ActivityEdge
 
-        page = super().construct()
+    def __init__(self, subject):
+        self.subject = subject
+        self.watcher = subject.watcher() if subject else None
 
+    def construct(self):
         subject = self.subject
 
         if not subject:
-            return page
+            return
+
+        builder = new_builder("transition-editor")
 
-        hbox = create_hbox_label(self, page, gettext("Guard"))
-        entry = Gtk.Entry()
-        entry.set_text(subject.guard or "")
-        changed_id = entry.connect("changed", self._on_guard_change)
-        hbox.pack_start(entry, True, True, 0)
+        guard = builder.get_object("guard")
+        guard.set_text(subject.guard or "")
 
         def handler(event):
-            entry.handler_block(changed_id)
             v = event.new_value
-            entry.set_text(v if v else "")
-            entry.handler_unblock(changed_id)
+            guard.set_text(v if v else "")
 
         self.watcher.watch("guard", handler).subscribe_all()
-        entry.connect("destroy", self.watcher.unsubscribe_all)
 
-        return page
+        builder.connect_signals(
+            {
+                "guard-changed": (self._on_guard_change,),
+                "transition-destroy": (self.watcher.unsubscribe_all,),
+            }
+        )
+        return builder.get_object("transition-editor")
 
     @transactional
     def _on_guard_change(self, entry):

gaphor/diagram/actions/partition.py

@@ -50,6 +50,10 @@ def __init__(self, id=None, model=None):
         self.min_width = 100
         self.min_height = 300
 
+    @property
+    def toplevel(self):
+        return self._toplevel
+
     def pre_update(self, context):
         assert self.canvas
 

gaphor/diagram/actions/partitionpage.py

@@ -4,34 +4,32 @@
 
 from gaphor.core import gettext, transactional
 from gaphor.diagram.actions.partition import PartitionItem
-from gaphor.diagram.propertypages import NamedItemPropertyPage, PropertyPages
+from gaphor.diagram.propertypages import PropertyPageBase, PropertyPages, new_builder
 
 
 @PropertyPages.register(PartitionItem)
-class PartitionPropertyPage(NamedItemPropertyPage):
+class PartitionPropertyPage(PropertyPageBase):
     """Partition property page."""
 
+    order = 15
+
+    def __init__(self, item):
+        self.item = item
+
     def construct(self):
         item = self.item
 
-        page = super().construct()
+        if item.toplevel:
+            return
 
-        if item.subject:
-            if not item._toplevel:
-                hbox = Gtk.HBox(spacing=12)
-                button = Gtk.CheckButton(gettext("External"))
-                button.set_active(item.subject.isExternal)
-                button.connect("toggled", self._on_external_change)
-                hbox.pack_start(button, True, True, 0)
-                page.pack_start(hbox, False, True, 0)
-            else:
-                pass
-                # hbox = Gtk.HBox(spacing=12)
-                # button = Gtk.CheckButton(_('Dimension'))
-                # button.set_active(item.subject.isDimension)
-                # button.connect('toggled', self._on_dimension_change)
-
-        return page
+        builder = new_builder("partition-editor")
+
+        external = builder.get_object("external")
+        external.set_active(item.subject.isExternal)
+
+        builder.connect_signals({"external-changed": (self._on_external_change,)})
+
+        return builder.get_object("partition-editor")
 
     @transactional
     def _on_external_change(self, button):

gaphor/diagram/classes/classeseditors.py

@@ -42,13 +42,16 @@ def update_end_text(text):
         end_item = item.tail_end
 
     if end_item:
-        text = UML.format(
-            end_item.subject,
-            visibility=True,
-            is_derived=True,
-            type=True,
-            multiplicity=True,
-            default=True,
+        text = (
+            UML.format(
+                end_item.subject,
+                visibility=True,
+                is_derived=True,
+                type=True,
+                multiplicity=True,
+                default=True,
+            )
+            or ""
         )
         entry = popup_entry(text, update_end_text)
         bb = end_item.name_bounds