Changeset 1670

Timestamp:

07/18/07 11:13:12 (1 year ago)

Author:

wrobe..@pld-linux.org

Message:

- merged hw branch on trunk

Files:

• gaphas/trunk/demo.py (modified) (3 diffs)
• gaphas/trunk/demo_profile.py (modified) (2 diffs)
• gaphas/trunk/gaphas/canvas.py (modified) (16 diffs)
• gaphas/trunk/gaphas/constraint.py (modified) (5 diffs)
• gaphas/trunk/gaphas/decorators.py (modified) (1 diff)
• gaphas/trunk/gaphas/examples.py (modified) (8 diffs)
• gaphas/trunk/gaphas/item.py (modified) (15 diffs)
• gaphas/trunk/gaphas/painter.py (modified) (4 diffs)
• gaphas/trunk/gaphas/solver.py (modified) (2 diffs)
• gaphas/trunk/gaphas/tests/test_element.py (modified) (1 diff)
• gaphas/trunk/gaphas/tests/test_solver.py (modified) (2 diffs)
• gaphas/trunk/gaphas/tool.py (modified) (9 diffs)
• gaphas/trunk/gaphas/view.py (modified) (7 diffs)

gaphas/trunk/demo.py

@@ -25 +25 @@
-import cairo
-from gaphas import Canvas, GtkView, View
-
+FatLine, Circle, 
-from gaphas.item import Line, NW, SE
-from gaphas.tool import PlacementTool, HandleTool
@@ -300 +300 @@
-    print 'box', b
-    b.matrix=(1.0, 0.0, 0.0, 1, 20,20)
-=
+ = 
-    c.add(b)
-
@@ -307 +307 @@
-    bb.matrix=(1.0, 0.0, 0.0, 1, 10,10)
-    c.add(bb, parent=b)
-
+
+
+
+
+
+
+
+
+
+
+
+
-
-    # AJM: extra boxes:

gaphas/trunk/demo_profile.py

@@ -174 +174 @@
-        c.add(bb, parent=b)
-
-count
+40
-        bb = MyBox()
-        bb.width = bb.height = 15
@@ -210 +210 @@
-
-if __name__ == '__main__':
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-# vim: sw=4:et:

gaphas/trunk/gaphas/canvas.py

@@ -6 +6 @@
-__version__ = "$Revision$"
-# $HeadURL$
-
-
-import cairo
@@ -14 +13 @@
-from gaphas.decorators import nonrecursive, async, PRIORITY_HIGH_IDLE
-from state import observed, reversible_method, reversible_pair
+from gaphas.constraint import Projector
-
-
@@ -38 +38 @@
-class Canvas(object):
-    """
-
+
+
+
+
+
+
-    """
-
@@ -48 +53 @@
-
-        self._registered_views = set()
+        self._canvas_constraints = {}
+
+        self.projector = CanvasProjector(self)
-
-    solver = property(lambda s: s._solver)
@@ -68 +76 @@
-        item.canvas = self
-        self._tree.add(item, parent)
+        self._canvas_constraints[item] = {}
+
+        for v in self._registered_views:
+            v.update_matrix(item)
+
-        self.request_update(item)
-        self._update_views((item,))
+
-
-    @observed
@@ -92 +106 @@
-        self._tree.remove(item)
-        self.remove_connections_to_item(item)
+        del self._canvas_constraints[item]
-        self._update_views((item,))
-        self._dirty_items.discard(item)
@@ -98 +113 @@
-    reversible_pair(add, remove,
-                    bind1={'parent': lambda self, item: self.get_parent(item) })
+
+
+    def add_canvas_constraint(self, item, handle, c):
+        """
+        Add constraint between items.
+
+        Parameters:
+         - item: item holding constraint
+         - handle: handle holding constraint
+         - c: constraint between items
+        """
+        if item not in self._canvas_constraints:
+            raise ValueError, 'Item not added to canvas'
+
+        i_cons = self._canvas_constraints[item]
+        if handle not in i_cons:
+            i_cons[handle] = set()
+        i_cons[handle].add(c)
+        self._solver.add_constraint(c)
+
+
+    def remove_canvas_constraint(self, item, handle, c=None):
+        """
+        Remove constraint set between item.
+
+        If constraint is not set then all constraints are removed for given
+        item and handle.
+
+        Parameters:
+         - item: item holding constraint
+         - handle: handle holding constraint
+         - c: constraint between items
+        """
+        if item not in self._canvas_constraints:
+            raise ValueError, 'Item not added to canvas'
+
+        i_cons = self._canvas_constraints[item]
+
+        if c is None: # remove all handle's constraints
+            h_cons = i_cons[handle]
+            for c in h_cons:
+                self._solver.remove_constraint(c)
+            h_cons.clear()
+        else:
+            # remove specific constraint
+            self._solver.remove_constraint(c)
+            i_cons[handle].remove(c)
+
+
+    def canvas_constraints(self, item):
+        """
+        Get all constraints set between items for specific item.
+        """
+        if item not in self._canvas_constraints:
+            raise ValueError, 'Item not added to canvas'
+
+        i_cons = self._canvas_constraints[item]
+
+        for cons in i_cons.values():
+            for c in cons:
+                yield c
+
-
-    def remove_connections_to_item(self, item):
@@ -262 +339 @@
-        return connected_items
-
-w
+c
-        """
-        Get the Item to World matrix for @item.
@@ -272 +349 @@
-              yet. Note that out-of-date matrices are not recalculated.
-        """
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
-        """
-        Get the World to Item matrix for @item.
-        See get_matrix_i2w().
-        """
-
-
-
-
-
-
-
-
-
+
+
+
+
-
-    @observed
@@ -314 +381 @@
-            0
-        """
-        assert item in self.get_all_items()
-        self._dirty_items.add(item)
-        self._dirty_matrix_items.add(item)
@@ -332 +398 @@
-        Schedule only the matrix to be updated.
-        """
-        assert item in self.get_all_items()
-        self._dirty_matrix_items.add(item)
-        self.update()
@@ -434 +499 @@
-            >>> c.add(ii, i)
-            >>> c.update_matrices()
-i._canvas_matrix_i2w
+c.get_matrix_i2c(i)
-            cairo.Matrix(1, 0, 0, 1, 5, 0)
-ii._canvas_matrix_i2w
+c.get_matrix_i2c(ii)
-            cairo.Matrix(1, 0, 0, 1, 5, 8)
-            >>> len(c._dirty_items)
@@ -463 +528 @@
-                return
-            else:
-canvas_matrix_i2w
-canvas_matrix_i2w *= parent._canvas_matrix_i2w
+matrix_i2c
+matrix_i2c *= self.get_matrix_i2c(parent)
-        else:
-canvas_matrix_i2w
+matrix_i2c
-
-        # It's nice to have the W2I matrix present too:
-
-
+
+
+
+
-
-        # Make sure handles are marked (for constraint solving)
-        request_resolve = self._solver.request_resolve
-
-
-
-
+
+
+
-        if recursive:
-            for child in self._tree.get_children(item):
-                self.update_matrix(child)
+
-
-    def _update_handles(self, item):
@@ -523 +590 @@
-                h.y._value -= y
-
+
-    def register_view(self, view):
-        """
@@ -529 +597 @@
-        """
-        self._registered_views.add(view)
+        for item in self.get_all_items():
+            view.update_matrix(item)
+
-
-    def unregister_view(self, view):
@@ -567 +638 @@
-
-
+
+class CanvasProjector(Projector):
+    """
+    Canvas constraint projector between item and canvas coordinates.
+
+    Attributes:
+     - _canvas: canvas reference
+    """
+    def __init__(self, canvas):
+        super(CanvasProjector, self).__init__()
+        self._canvas = canvas
+
+
+    def _cproj(self, c, x=None, y=None, xy=None, **kw):
+        if xy is not None:
+            for point, item in xy.items():
+                x, y = point
+                i2c = self._canvas.get_matrix_i2c(item).transform_point
+                x._value, y._value = i2c(x._value, y._value)
+        elif 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)
+        elif 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)
+        else:
+            raise AttributeError('Projection data not specified')
+
+
+    def _iproj(self, c, x=None, y=None, xy=None, **kw):
+        if xy is not None:
+            for point, item in xy.items():
+                x, y = point
+                c2i = self._canvas.get_matrix_c2i(item).transform_point
+                x._value, y._value = c2i(x._value, y._value)
+                item.request_update()
+        elif 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()
+        elif 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()
+        else:
+            raise AttributeError('Projection data not specified')
+
+
-# Additional tests in @observed methods
-__test__ = {

gaphas/trunk/gaphas/constraint.py

@@ -120 +120 @@
-        assert var in (self.a, self.b)
-
-
-
-
-
+
+
+
+
+
-
-
@@ -285 +286 @@
-            args[nm] = v.value
-            if v is var: arg = nm
-
+
+
+
+
-
-    def _solve_for(self, arg, args):
@@ -337 +341 @@
-
-
-class LineConstraint(Constraint):
-    """
-    Ensure a point is kept on a line, taking into account item
-    specific coordinates.
-
-    #>>> from solver import Variable
-    #>>> a, b = Variable(3.0), Variable(2.0)
-    #>>> lt = LessThanConstraint(smaller=a, bigger=b)
-    #>>> lt.solve_for('smaller')
-    #>>> a, b
-    #(Variable(3, 20), Variable(3, 20))
-    #>>> b.value = 0.8
-    #>>> lt.solve_for('bigger')
-    #>>> a, b
-    #(Variable(0.8, 20), Variable(0.8, 20))
-    """
-
-    def __init__(self, canvas, connect_to_item, handle_1, handle_2,
-                 connected_item, connected_handle):
-        super(LineConstraint, self).__init__(handle_1.x,
-                handle_1.y,
-                handle_2.x,
-                handle_2.y,
-                connected_handle.x,
-                connected_handle.y)
-
-        self._canvas = canvas
-        self._connect_to_item = connect_to_item
-        self._handle_1 = handle_1
-        self._handle_2 = handle_2
-        self._connected_item = connected_item
-        self._connected_handle = connected_handle
-        self.update_ratio()
-
-
-    def update_ratio(self):
-        """
-        >>> from item import Handle, Item
-        >>> from canvas import Canvas
-        >>> c = Canvas()
-        >>> i1, i2 = Item(), Item()
-        >>> c.add(i1)
-        >>> c.add(i2)
-        >>> c.update_now()
-        >>> h1, h2, h3 = Handle(0, 0), Handle(30, 20), Handle(15, 4)
-        >>> eq = LineConstraint(c, i1, h1, h2, i2, h3)
-        >>> eq.ratio_x, eq.ratio_y
-        (0.5, 0.20000000000000001)
-        >>> h2.pos = 40, 30
-        >>> eq.solve_for(h3.x)
-        >>> eq.ratio_x, eq.ratio_y
-        (0.5, 0.20000000000000001)
-        >>> h3.pos
-        (Variable(20, 20), Variable(6, 20))
-        """
-        start = self._handle_1
-        end = self._handle_2
-        point = self._connected_handle
-
-        get_i2w = self._canvas.get_matrix_i2w
-
-        sx, sy = get_i2w(self._connect_to_item, calculate=True).transform_point(start.x, start.y)
-        ex, ey = get_i2w(self._connect_to_item).transform_point(end.x, end.y)
-        px, py = get_i2w(self._connected_item, calculate=True).transform_point(point.x, point.y)
-
-        try:
-            self.ratio_x = float(px - sx) / float(ex - sx)
-        except ZeroDivisionError:
-            self.ratio_x = 0.0
-        try:
-            self.ratio_y = float(py - sy) / float(ey - sy)
-        except ZeroDivisionError:
-            self.ratio_y = 0.0
-        
-    def solve_for(self, var=None):
-        self._solve()
-
-    def _solve(self):
-        """
-        Solve the equation for the connected_handle.
-        >>> from item import Handle, Item
-        >>> from canvas import Canvas
-        >>> c = Canvas()
-        >>> i1, i2 = Item(), Item()
-        >>> c.add(i1)
-        >>> c.add(i2)
-        >>> c.update_now()
-        >>> h1, h2, h3 = Handle(0, 0), Handle(30, 20), Handle(15, 4)
-        >>> eq = LineConstraint(c, i1, h1, h2, i2, h3)
-        >>> eq.solve_for(h3.x)
-        >>> h3.pos
-        (Variable(15, 20), Variable(4, 20))
-        >>> h2.pos = 40, 30
-        >>> eq.solve_for(h3.x)
-        >>> h3.pos
-        (Variable(20, 20), Variable(6, 20))
-        >>> i2.matrix.translate(5,5)
-        >>> i2.request_update()
-        >>> c.update_now()
-        >>> eq.solve_for(h3.x)
-        >>> h3.pos
-        (Variable(15, 20), Variable(1, 20))
-        """
-        start = self._handle_1
-        end = self._handle_2
-        point = self._connected_handle
-
-        get_i2w = self._canvas.get_matrix_i2w
-        get_w2i = self._canvas.get_matrix_w2i
-
-        sx, sy = get_i2w(self._connect_to_item).transform_point(start.x, start.y)
-        ex, ey = get_i2w(self._connect_to_item).transform_point(end.x, end.y)
-
-        px = sx + (ex - sx) * self.ratio_x
-        py = sy + (ey - sy) * self.ratio_y
-
-        point.x.value, point.y.value = \
-            get_w2i(self._connected_item).transform_point(px, py)
-        # Need to queue a redraw of the manipulated item.
-        self._canvas.request_update(self._connected_item)
-
-
-
-class BalanceConstraint(Constraint):
@@ -487 +369 @@
-    """
-
-
+, balance=None
-        super(BalanceConstraint, self).__init__(band[0], band[1], v)
-        self.band = band
+        self.balance = balance
+        self.v = v
+
+        if self.balance is None:
+            self.update_balance()
+
+
+    def update_balance(self):
-        b1, b2 = self.band
-        w = b2 - b1
-        if w != 0:
-
+self.
-        else:
-            self.balance = 0
-        self.v = v
-
-
@@ -502 +391 @@
-        b1, b2 = self.band
-        w = b2 - b1
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-

gaphas/trunk/gaphas/decorators.py

@@ -138 +138 @@
-    return wrapper
-
+class recursive(object):
+    """
+    This decorator limits the recursion for a specific function
+
+    >>> class A(object):
+    ...    def __init__(self): self.r = 0
+    ...    @recursive(10)
+    ...    def a(self, x=0):
+    ...        self.r += 1
+    ...        self.a()
+    >>> a = A()
+    >>> a.a()
+    >>> a.r
+    10
+    """
+
+    def __init__(self, limit=10000):
+        self.limit = limit
+
+    def __call__(self, func):
+        def wrapper(*args, **kwargs):
+            try:
+                func._recursion_level += 1
+            except AttributeError:
+                # _recursion_level not present
+                func._recursion_level = 0
+            if func._recursion_level < self.limit:
+                try:
+                    return func(*args, **kwargs)
+                finally:
+                    func._recursion_level -= 1
+        return wrapper
+
-
-if __name__ == '__main__':

gaphas/trunk/gaphas/examples.py

@@ -11 +11 @@
-from solver import solvable
-import tool
-
+, LessThanConstraint, EqualsConstraint
-from geometry import point_on_rectangle, distance_rectangle_point
-
+
+
-
-class Box(Element):
@@ -44 +45 @@
-        """
-        h = self._handles
-
-
-
-
-
+
+
-        por = point_on_rectangle(r, (x, y), border=True)
-#print 'Point', r, (x, y), por
-distance_rectangle_point(r, (x, y))
+p = distance_rectangle_point(r, (x, y))
+p
-
-
@@ -82 +80 @@
-
-
+class FatLine(Item):
+    def __init__(self):
+        super(FatLine, self).__init__()
+        self._handles.extend((Handle(), Handle()))
+
+        h1, h2 = self._handles
+        cons = self._constraints
+        cons.append(EqualsConstraint(a=h1.x, b=h2.x))
+        cons.append(LessThanConstraint(smaller=h1.y, bigger=h2.y, delta=20))
+
+
+    def _set_height(self, height):
+        h1, h2 = self._handles
+        h2.y = height
+
+
+    def _get_height(self):
+        h1, h2 = self._handles
+        return h2.y
+
+
+    height = property(_get_height, _set_height)
+
+
+    def draw(self, context):
+        cr = context.cairo
+        cr.set_line_width(10)
+        h1, h2 = self.handles()
+        cr.move_to(0, 0)
+        cr.line_to(0, self.height)
+        cr.stroke()
+
+
+
+class Circle(Item):
+    def __init__(self):
+        super(Circle, self).__init__()
+        self._handles.extend((Handle(), Handle()))
+
+
+    def _set_radius(self, r):
+        h1, h2 = self._handles
+        h2.x = r
+        h2.y = r
+
+
+    def _get_radius(self):
+        h1, h2 = self._handles
+        return ((h2.x - h1.x) ** 2 + (h2.y - h1.y) ** 2) ** 0.5
+
+    radius = property(_get_radius, _set_radius)
+
+
+    def setup_canvas(self):
+        super(Circle, self).setup_canvas()
+        h1, h2 = self._handles
+        h1.movable = False
+
+
+    def draw(self, context):
+        cr = context.cairo
+        path_ellipse(cr, 0, 0, 2 * self.radius, 2 * self.radius)
+        cr.stroke()
+
+
-class ConnectingHandleTool(tool.HandleTool):
-    """
@@ -96 +159 @@
-        if not handle.connectable:
-            return
-        matrix_w2i = view.canvas.get_matrix_w2i
-        matrix_i2w = view.canvas.get_matrix_i2w
-
-        # Make glue distance depend on the zoom ratio (should be about 10 pixels)
-
+
+
+
+
-        glue_point = None
-        glue_item = None
-        for i in view.canvas.get_all_items():
-            if not i is item:
-
+
+
-                try:
-                    distance, point = i.glue(item, handle, ix, iy)
-                    # print distance, point
-                    # Transform distance to world coordinates
-
+#
-                    if distance <= glue_distance:
-                        glue_distance = distance
-
+
+
-                        glue_item = i
-                except AttributeError:
-                    pass
-        if glue_point:
-
+
+
-        return glue_item
-
@@ -131 +197 @@
-        """
-        def side(handle, glued):
-
-
-
+
+
+
+
+
-            if abs(hx - ax) < 0.01:
-side = 3
+return handles[NW], handles[SW]
-            elif abs(hy - ay) < 0.01:
-side = 0
+return handles[NW], handles[NE]
-            elif abs(hx - bx) < 0.01:
-side = 1
+return handles[NE], handles[SE]
-            else:
-side = 2
-return sid
+return handles[SW], handles[SE]
+assert Fals
-
-
-        def handle_disconnect():
-            try:
-solver.remove_constraint(handle._connect_constraint
+remove_canvas_constraint(item, handle
-            except KeyError:
-                pass # constraint was alreasy removed
-            handle._connect_constraint = None
-            handle.connected_to = None
-            # Remove disconnect handler:
@@ -158 +225 @@
-        glue_item = self.glue(view, item, handle, wx, wy)
-        if glue_item and glue_item is handle.connected_to:
-            s = side(handle, glue_item)
-            try:
-solver.remove_constraint(handle._connect_constraint
+remove_canvas_constraint(item, handle
-            except KeyError:
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-            handle.disconnect = handle_disconnect
-            return
@@ -174 +252 @@
-        if glue_item:
-            if isinstance(glue_item, Box):
-
+
+
-                # Make a constraint that keeps into account item coordinates.
-
-
+
+
+
+
+
+
+
+
+
+
+
+
-                handle.connected_to = glue_item
-                handle.disconnect = handle_disconnect
@@ -184 +273 @@
-        if handle.connected_to:
-            #print 'Handle.disconnect', view, item, handle
-solver.remove_constraint(handle._connect_constraint
+remove_canvas_constraint(item, handle
-
-