Changeset 1109

Timestamp:

12/14/06 14:08:36 (2 years ago)

Author:

arjanmol

Message:

Added Fork/Join and Decision/Merge node connectors. Added ElementFactory?.swap_element()

Files:

• gaphor/branches/new-canvas/gaphor/UML/__init__.py (modified) (1 diff)
• gaphor/branches/new-canvas/gaphor/UML/elementfactory.py (modified) (2 diffs)
• gaphor/branches/new-canvas/gaphor/adapters/connectors.py (modified) (2 diffs)
• gaphor/branches/new-canvas/gaphor/adapters/tests/test_connector.py (modified) (2 diffs)

gaphor/branches/new-canvas/gaphor/UML/__init__.py

@@ -36 +36 @@
-    _default_element_factory.flush()
-
+def swap_element(element, new_class):
+    """Swap the class for an element
+    """
+    _default_element_factory.swap_element(element, new_class)
+
-if 0 and __debug__: 
-    # Keep track of all model elements that are created

gaphor/branches/new-canvas/gaphor/UML/elementfactory.py

@@ -10 +10 @@
-from gaphor.UML.event import CreateElementEvent, RemoveElementEvent, \
-                             FlushFactoryEvent, ModelFactoryEvent
-
-# TODO: create an ElementFactory method that allows to swap instances of
-#       one type to another (e.g. ForkNode <-> DescisionNode)
-
-
@@ -167 +164 @@
-    def swap_element(self, element, new_class):
-        assert element in self._elements.values()
-
-
+
+
+
-
-    def connect(self, callback, *data):

gaphor/branches/new-canvas/gaphor/adapters/connectors.py

@@ -966 +966 @@
-        edge (incoming or outgoing).
-        """
+        opposite = self.line.opposite(handle)
-        line = self.line
-        element = self.element
-        subject = element.subject
+        connected_to = opposite.connected_to
+
+        # Element can not connect back to itself
+        if connected_to is element:
+            return None
+
+        # Same goes for subjects:
+        if connected_to and \
+                (not (connected_to.subject or element.subject)) \
+                 and connected_to.subject is element.subject:
+            return None
-
-        # If one side of self.element has more than one edge, the
-        # type of node is determined (either join or fork).
-        if handle is line.head and len(subject.incoming) > 1 and len(subject.outgoing) > 0:
-            print 'head: type determined'
-            return None
-
-        if handle is line.tail and len(subject.incoming) > 0 and len(subject.outgoing) > 1:
-            print 'tail: type determined'
-            return None
-
@@ -984 +994 @@
-    def connect_subject(self):
-        super(FlowForkNodeConnect, self).connect_subject()
+
-        # Switch class for self.element Join/Fork depending on the number
-        # of incoming/outgoing edges.
+        subject = self.element.subject
+        if len(subject.incoming) > 1 and len(subject.outgoing) < 2:
+            UML.swap_element(subject, UML.JoinNode)
+        elif len(subject.incoming) < 2 and len(subject.outgoing) > 1:
+            UML.swap_element(subject, UML.ForkNode)
+        elif len(subject.incoming) > 1 and len(subject.outgoing) > 1:
+            raise RuntimeError, 'Inconsistent state'
-
-component.provideAdapter(FlowForkNodeConnect)
-
-
+class FlowDecisionNodeConnect(FlowConnect):
+    """
+    Connect Flow to a ForkNode
+    """
+    component.adapts(items.DecisionNodeItem, items.FlowItem)
+
+    def glue(self, handle, x, y):
+        """
+        In addition to the normal check, one end should have at most one
+        edge (incoming or outgoing).
+        """
+        opposite = self.line.opposite(handle)
+        line = self.line
+        element = self.element
+        subject = element.subject
+        connected_to = opposite.connected_to
+
+        # Element can not connect back to itself
+        if connected_to is element:
+            return None
+
+        # Same goes for subjects:
+        if connected_to and \
+                (not (connected_to.subject or element.subject)) \
+                 and connected_to.subject is element.subject:
+            return None
+
+        # If one side of self.element has more than one edge, the
+        # type of node is determined (either join or fork).
+        if handle is line.head and len(subject.incoming) > 1 and len(subject.outgoing) > 0:
+            return None
+
+        if handle is line.tail and len(subject.incoming) > 0 and len(subject.outgoing) > 1:
+            return None
+
+        return super(FlowDecisionNodeConnect, self).glue(handle, x, y)
+
+    def connect_subject(self):
+        super(FlowDecisionNodeConnect, self).connect_subject()
+
+        # Switch class for self.element Join/Fork depending on the number
+        # of incoming/outgoing edges.
+        subject = self.element.subject
+        if len(subject.incoming) > 1 and len(subject.outgoing) < 2:
+            UML.swap_element(subject, UML.MergeNode)
+        elif len(subject.incoming) < 2 and len(subject.outgoing) > 1:
+            UML.swap_element(subject, UML.DecisionNode)
+        elif len(subject.incoming) > 1 and len(subject.outgoing) > 1:
+            raise RuntimeError, 'Inconsistent state'
+
+component.provideAdapter(FlowDecisionNodeConnect)
+
+
-# vim:sw=4:et:ai

gaphor/branches/new-canvas/gaphor/adapters/tests/test_connector.py

@@ -588 +588 @@
-        assert flow1.subject.source is a2.subject
-
-
+, itemClass=items.ForkNodeItem, forkNodeClass=UML.ForkNode, joinNodeClass=UML.JoinNode
-        """
-        Test fork/decision behaviour.
+         [1] A join node has one outgoing edge.
+             self.outgoing->size() = 1
+         [2] If a join node has an incoming object flow, it must have an
+             outgoing object flow, otherwise, it must have an outgoing control
+             flow.
+
+         [1] A fork node has one incoming edge.
+         [2] The edges coming into and out of a fork node must be either all
+             object flows or all control flows.
-        """
-        assert len(list(UML.select())) == 0
@@ -597 +606 @@
-        flow1 = diagram.create(items.FlowItem)
-        flow2 = diagram.create(items.FlowItem)
+        flow3 = diagram.create(items.FlowItem)
+        flow4 = diagram.create(items.FlowItem)
-        a1 = diagram.create(items.ActionItem, subject=UML.create(UML.Action))
-        a2 = diagram.create(items.ActionItem, subject=UML.create(UML.Action))
-
-
-
+
+
+
+
-
-        # Connect between two actions (ControlFlow)
+        # Connecting line this:
+        #                  |--flow2-->[ a2 ]
+        # [ a1 ] --flow1-->|
+        #                  |--flow3-->[ a3 ]
+
+        # First connect the Actions:
+
-        adapter = component.queryMultiAdapter((a1, flow1), IConnect)
-        assert adapter
-        adapter.connect(flow1.head, flow1.head.x, flow1.head.y)
-
+        adapter = component.queryMultiAdapter((a2, flow2), IConnect)
+        assert adapter
+        adapter.connect(flow2.tail, flow2.tail.x, flow2.tail.y)
+
+        adapter = component.queryMultiAdapter((a3, flow3), IConnect)
+        assert adapter
+        adapter.connect(flow3.tail, flow3.tail.x, flow3.tail.y)
+
+        # Now connect to ForkNode:
+
-        adapter = component.queryMultiAdapter((f1, flow1), IConnect)
-        assert adapter
-        adapter.connect(flow1.tail, flow1.tail.x, flow1.tail.y)
+        assert flow1.tail.connected_to is f1
-        assert flow1.subject
-        assert flow1.subject.target is f1.subject
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-# vim:sw=4:et:ai