Changeset 1637

Timestamp:

07/16/07 08:26:30 (1 year ago)

Author:

wrobe..@pld-linux.org

Message:

- added canvas constraint projector to convert variables into canvas space

before constraint solving

- use constraint projector to keep line's handle on box's side
- added Item._iconstraints dictionary to

• add and remove inter-item constraints easily
  
• request resolve of inter-item constraints by canvas in case of matrix
  changes
  

- added Item._constraints list to add/remove item's constraints by

Item.{setup,teardown}_canvas methods

- use positional arguments instead of dictionary for projection callable to

provide nicer interface for deriving classes

Files:

• gaphas/branches/hw/gaphas/canvas.py (modified) (4 diffs)
• gaphas/branches/hw/gaphas/constraint.py (modified) (2 diffs)
• gaphas/branches/hw/gaphas/examples.py (modified) (8 diffs)
• gaphas/branches/hw/gaphas/item.py (modified) (6 diffs)
• gaphas/branches/hw/gaphas/solver.py (modified) (1 diff)
• gaphas/branches/hw/gaphas/tests/test_canvas.py (added)
• gaphas/branches/hw/gaphas/tool.py (modified) (2 diffs)

gaphas/branches/hw/gaphas/canvas.py

@@ -15 +15 @@
-from gaphas.decorators import nonrecursive, async, PRIORITY_HIGH_IDLE
-from state import observed, reversible_method, reversible_pair
+from gaphas.constraint import Projector
-
-
@@ -71 +72 @@
-        self._registered_views = set()
-        self._cache = WeakKeyDictionary()
+
+        self.proj = CanvasProjector(self)
-
-    solver = property(lambda s: s._solver)
@@ -497 +500 @@
-        # Make sure handles are marked (for constraint solving)
-        request_resolve = self._solver.request_resolve
-
-
-
+
+
-            
-        if recursive:
@@ -597 +599 @@
-
-
+
+class CanvasProjector(Projector):
+    def __init__(self, canvas):
+        super(CanvasProjector, self).__init__()
+        self._canvas = canvas
+
+
+    def _cproj(self, c, x=None, y=None, xy=None, **kw):
+        if x is not None:
+            for v, item in x.items():
+                i2c = self._canvas.get_matrix_i2c(item).transform_point
+                v._value, _ = i2c(v._value, 0)
+        if y is not None:
+            for v, item in y.items():
+                i2c = self._canvas.get_matrix_i2c(item).transform_point
+                _, v._value = i2c(0, v._value)
+
+
+    def _iproj(self, c, x=None, y=None, xy=None, **kw):
+        if x is not None:
+            for v, item in x.items():
+                c2i = self._canvas.get_matrix_c2i(item).transform_point
+                v._value, _ = c2i(v._value, 0)
+                item.request_update()
+        if y is not None:
+            for v, item in y.items():
+                c2i = self._canvas.get_matrix_c2i(item).transform_point
+                _, v._value = c2i(0, v._value)
+                item.request_update()
+
+
-# Additional tests in @observed methods
-__test__ = {

gaphas/branches/hw/gaphas/constraint.py

@@ -490 +490 @@
-
-
-data
+*args, **kw
-        """
-        Decorator for Constraint.solve_for method to perform
@@ -498 +498 @@
-        f = c.solve_for
-        def wrapper(var):
-data
+*args, **kw
-            f(var)
-data
+*args, **kw
-        c.solve_for = wrapper
-

gaphas/branches/hw/gaphas/examples.py

@@ -45 +45 @@
-        """
-        h = self._handles
-
-
-
-
-
+
+
-        por = point_on_rectangle(r, (x, y), border=True)
-        p = distance_rectangle_point(r, (x, y))
@@ -172 +169 @@
-        inverse = Matrix(*view.matrix)
-        inverse.invert()
-
+
+
-        glue_point = None
-        glue_item = None
-        for i in view.canvas.get_all_items():
-            if not i is item:
-#ix, iy = matrix_w2i(i).transform_point(wx, wy)
-wx, wy
+v2i = view.get_matrix_v2i(i).transform_point
+v2i(wx, wy)
-                try:
-                    distance, point = i.glue(item, handle, ix, iy)
@@ -185 +183 @@
-                    if distance <= glue_distance:
-                        glue_distance = distance
-
+
+
-                        glue_item = i
-                except AttributeError:
-                    pass
-        if glue_point:
-x, y = glue
-glue_point
+v2i = view.get_matrix_v2i(item).transform
+v2i(*glue_point)
-        return glue_item
-
@@ -205 +204 @@
-        def side(handle, glued):
-            handles = glued.handles()
-
-
-
+
+
+
+
-            if abs(hx - ax) < 0.01:
-
+, (hy - ay) / (by - ay)
-            elif abs(hy - ay) < 0.01:
-
+, (hx - ax) / (bx - ax)
-            elif abs(hx - bx) < 0.01:
-
+,  (hy - ay) / (by - ay)
-            else:
-
+, (hx - ax) / (bx - ax)
-            assert False
-
@@ -221 +221 @@
-        def handle_disconnect():
-            try:
-
-
+
-            except KeyError:
-                pass # constraint was alreasy removed
@@ -240 +239 @@
-
-
-
+
+
-            handle._c1 = BalanceConstraint(band=(h1.x, h1.x), v=handle.x)
-            handle._c2 = BalanceConstraint(band=(h2.y, h2.y), v=handle.y)
@@ -254 +254 @@
-        if glue_item:
-            if isinstance(glue_item, Box):
-
+, b
-
-                # Make a constraint that keeps into account item coordinates.
-
-
-
-
+
+
+
+
+
+
-
-                handle.connected_to = glue_item
@@ -268 +270 @@
-        if handle.connected_to:
-            #print 'Handle.disconnect', view, item, handle
-
-
+
-
-

gaphas/branches/hw/gaphas/item.py

@@ -126 +126 @@
-        self._matrix = Matrix()
-        self._handles = []
+        self._constraints = []
+        self._iconstraints = {}
+
+
+    def add_iconstraint(self, h, c):
+        if h not in self._iconstraints:
+            self._iconstraints[h] = set()
+        self._iconstraints[h].add(c)
+        self._canvas.solver.add_constraint(c)
+
+
+    def remove_iconstraint(self, h, c=None):
+        if c is None: # remove all handle's constraints
+            cons = self._iconstraints[h]
+            for c in cons:
+                self._canvas.solver.remove_constraint(c)
+            cons.clear()
+        else:
+            # remove specific constraint
+            self._canvas.solver.remove_constraint(c)
+            self._iconstraints[h].remove(c)
+
+
+    def iconstraints(self):
+        for cons in self._iconstraints.values():
+            for c in cons:
+                yield c
+
-
-    @observed
@@ -149 +177 @@
-                    "Canvas.add() and Canvas.remove().")
-
+
-    def setup_canvas(self):
-        """
@@ -154 +183 @@
-        This method can be used to create constraints.
-        """
-
+
+
+
+
-
-    def teardown_canvas(self):
@@ -161 +193 @@
-        This method can be used to dispose constraints.
-        """
+        super(Item, self).teardown_canvas()
-        for h in self.handles():
-            h.disconnect()
+
+        for c in self._constraints:
+            self.canvas.solver.remove_constraint(c)
+
-
-    @observed
@@ -238 +275 @@
-        super(Element, self).__init__()
-        self._handles = [ h(strength=VERY_STRONG) for h in [Handle]*4 ]
-
-
-# create minimal size constraints
+
+
+lt = LessThanConstraint
-        handles = self._handles
-        h_nw = handles[NW]
+        h_ne = handles[NE]
+        h_sw = handles[SW]
-        h_se = handles[SE]
+
+        # create minimal size constraints
-        self._c_min_w = LessThanConstraint(smaller=h_nw.y, bigger=h_se.y, delta=10)
-        self._c_min_h = LessThanConstraint(smaller=h_nw.x, bigger=h_se.x, delta=10)
+
+        # setup constraints
+        self._constraints.extend([
+            eq(a=h_nw.y, b=h_ne.y),
+            eq(a=h_nw.x, b=h_sw.x),
+            eq(a=h_se.y, b=h_sw.y),
+            eq(a=h_se.x, b=h_ne.x),
+            # set h_nw < h_se constraints
+            # with minimal size functionality
+            self._c_min_w,
+            self._c_min_h,
+        ])
-
-        # set width/height when minimal size constraints exist
-        self.width = width
-        self.height = height
+
+        # immediately solve the constraints, ensuring the box is drawn okay
+        solve_for = (h_ne.y, h_sw.y, h_sw.x, h_ne.x)
+        for c, v in zip(self._constraints, solve_for):
+            c.solve_for(v)
-
-
@@ -336 +394 @@
-    min_height = reversible_property(lambda s: s._c_min_h.delta, _set_min_height)
-
-    def setup_canvas(self):
-        """
-        >>> from canvas import Canvas
-        >>> c=Canvas()
-        >>> c.solver._constraints
-        set([])
-        >>> b = Element()
-        >>> c.add(b)
-        >>> b.canvas is c
-        True
-        >>> len(c.solver._constraints)
-        8
-        >>> len(c.solver._marked_cons)
-        0
-        >>> c.solver.solve()
-        >>> len(c.solver._constraints)
-        8
-        >>> len(c.solver._marked_cons)
-        0
-        >>> b._handles[SE].pos = (25,30)
-        >>> len(c.solver._marked_cons)
-        4
-        >>> c.solver.solve()
-        >>> float(b._handles[NE].x)
-        25.0
-        >>> float(b._handles[SW].y)
-        30.0
-        """
-        eq = EqualsConstraint
-        lt = LessThanConstraint
-
-        handles = self._handles
-        h_nw = handles[NW]
-        h_ne = handles[NE]
-        h_sw = handles[SW]
-        h_se = handles[SE]
-
-        add = self.canvas.solver.add_constraint
-        self._constraints = [
-            add(eq(a=h_nw.y, b=h_ne.y)),
-            add(eq(a=h_nw.x, b=h_sw.x)),
-            add(eq(a=h_se.y, b=h_sw.y)),
-            add(eq(a=h_se.x, b=h_ne.x)),
-            # set h_nw < h_se constraints
-            # with minimal size functionality
-            add(self._c_min_w),
-            add(self._c_min_h),
-        ]
-
-        # Immediately solve the constraints, ensuring the box is drawn okay
-        solve_for = (h_ne.y, h_sw.y, h_sw.x, h_ne.x)
-        for c, v in zip(self._constraints, solve_for):
-            c.solve_for(v)
-
-        
-    def teardown_canvas(self):
-        """
-        Remove constraints created in setup_canvas().
-        >>> from canvas import Canvas
-        >>> c=Canvas()
-        >>> c.solver._constraints
-        set([])
-        >>> b = Element()
-        >>> c.add(b)
-        >>> b.canvas is c
-        True
-        >>> len(c.solver._constraints)
-        8
-        >>> b.teardown_canvas()
-        >>> len(c.solver._constraints)
-        0
-        """
-        super(Element, self).teardown_canvas()
-        for c in self._constraints:
-            self.canvas.solver.remove_constraint(c)
-
-
-    def point(self, x, y):
-        """

gaphas/branches/hw/gaphas/solver.py

@@ -350 +350 @@
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
-
-    @observed

gaphas/branches/hw/gaphas/tool.py

@@ -475 +475 @@
-            view = context.view
-            if self._grabbed_handle and self._grabbed_handle.connectable:
-wx, wy = view.get_matrix_v2i(self._grabbed_item).transform_point(event.x, event.y)
-wx, w
+x, y = event.x, event.y
+x, 
-        finally:
-            context.view.queue_draw_item(context.view.hovered_item)
@@ -507 +507 @@
-            
-            item.request_update()
-            #canvas.update_matrix(item)
-            try:
-                if self._grabbed_handle.connectable:
-x, 
+event.x, event.
-            finally:
-                pass