Changeset 1130

Timestamp:

02/15/07 00:06:18 (2 years ago)

Author:

arjanmol

Message:

split View into View (baseclass) and GtkView?. Updated demo with SVG and PNG export.

Files:

• gaphas/trunk/demo.py (modified) (3 diffs)
• gaphas/trunk/gaphas/__init__.py (modified) (1 diff)
• gaphas/trunk/gaphas/view.py (modified) (21 diffs)

gaphas/trunk/demo.py

@@ -12 +12 @@
-import math
-import gtk
-
+
+
-from gaphas.examples import Box, Text, DefaultExampleTool
-from gaphas.item import Line, NW, SE
-from gaphas.tool import PlacementTool, HandleTool
+from gaphas.painter import ItemPainter
-
-class MyBox(Box):
@@ -50 +52 @@
-
-def create_window(canvas, zoom=1.0):
-
+Gtk
-    view.tool = DefaultExampleTool()
-
@@ -125 +127 @@
-    v.add(b)
-
+    b = gtk.Button('Write demo.png')
+
+    def on_clicked(button):
+        svgview = View(view.canvas)
+        svgview.painter = ItemPainter()
+
+        # Update bounding boxes with a temporaly CairoContext
+        # (used for stuff like calculating font metrics)
+        tmpsurface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 0, 0)
+        tmpcr = cairo.Context(tmpsurface)
+        svgview.update_bounding_box(tmpcr)
+        tmpcr.show_page()
+        tmpsurface.flush()
+       
+        w, h = svgview.bounding_box.width, svgview.bounding_box.height
+        surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, int(w), int(h))
+        cr = cairo.Context(surface)
+        svgview.matrix.translate(-svgview.bounding_box.x0, -svgview.bounding_box.y0)
+        cr.save()
+        svgview.paint(cr)
+
+        cr.restore()
+        cr.show_page()
+        surface.write_to_png('demo.png')
+
+    b.connect('clicked', on_clicked)
+    v.add(b)
+
+    b = gtk.Button('Write demo.svg')
+
+    def on_clicked(button):
+        svgview = View(view.canvas)
+        svgview.painter = ItemPainter()
+
+        # Update bounding boxes with a temporaly CairoContext
+        # (used for stuff like calculating font metrics)
+        tmpsurface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 0, 0)
+        tmpcr = cairo.Context(tmpsurface)
+        svgview.update_bounding_box(tmpcr)
+        tmpcr.show_page()
+        tmpsurface.flush()
+       
+        w, h = svgview.bounding_box.width, svgview.bounding_box.height
+        surface = cairo.SVGSurface('demo.svg', w, h)
+        cr = cairo.Context(surface)
+        svgview.matrix.translate(-svgview.bounding_box.x0, -svgview.bounding_box.y0)
+        svgview.paint(cr)
+        cr.show_page()
+        surface.flush()
+        surface.finish()
+
+    b.connect('clicked', on_clicked)
+    v.add(b)
+
+    
-#    b = gtk.Button('Cursor')
-#

gaphas/trunk/gaphas/__init__.py

@@ -14 +14 @@
-from canvas import Canvas
-from item import Item, Line, Element, Handle
-
+, GtkView
-

gaphas/trunk/gaphas/view.py

@@ -28 +28 @@
-
-class ToolContext(Context):
-
+
+
-    """
-
@@ -37 +38 @@
-
-    def grab(self):
-
+
+
-        """
-        self.view.grab_focus()
-
-    def ungrab(self):
-
+
+
-        """
-        pass
@@ -48 +51 @@
-
-class CairoContextWrapper(object):
-
+
+
-    stroke(), fill() and a few others so the bounding box of the
-    item involved can be calculated.
@@ -61 +65 @@
-
-    def get_bounds(self):
-
+
+
-        """
-        return self._bounds or Rectangle()
@@ -73 +78 @@
-
-    def _extents(self, extents_func, line_width=False):
-
+
+
-        if @line_width is True, the current line-width is taken into account.
-        """
@@ -115 +121 @@
-
-
+class View(object):
+    """
+    View class for gaphas.Canvas objects. 
+    """
+
+    def __init__(self, canvas=None):
+        self._canvas = canvas
+        self._bounds = Rectangle()
+        self._item_bounds = dict()
+
+        # Handling selections.
+        self._selected_items = set()
+        self._focused_item = None
+        self._hovered_item = None
+
+        self._matrix = Matrix()
+        self._painter = DefaultPainter()
+
+    matrix = property(lambda s: s._matrix)
+
+    def _set_canvas(self, canvas):
+        """
+        Use view.canvas = my_canvas to set the canvas to be rendered
+        in the view.
+        """
+        if self._canvas:
+            self._item_bounds = dict()
+
+        self._canvas = canvas
+        
+        if self._canvas:
+            self.request_update(self._canvas.get_all_items())
+
+    canvas = property(lambda s: s._canvas, _set_canvas)
+
+    def emit(self, args, **kwargs):
+        """
+        Placeholder method for signal emission functionality.
+        """
+        pass
+
+    def select_item(self, item):
+        """
+        Select an item. This adds @item to the set of selected items. Do
+           del view.selected_items
+        to clear the selected items list
+        """
+        self.queue_draw_item(item, handles=True)
+        if item not in self._selected_items:
+            self._selected_items.add(item)
+            self.emit('selection-changed', self._selected_items)
+
+    def unselect_item(self, item):
+        """
+        Unselect an item.
+        """
+        self.queue_draw_item(item, handles=True)
+        if item in self._selected_items:
+            self._selected_items.discard(item)
+            self.emit('selection-changed', self._selected_items)
+
+    def select_all(self):
+        for item in self.canvas.get_all_items():
+            self.select_item(item)
+
+    def unselect_all(self):
+        """
+        Clearing the selected_item also clears the focused_item.
+        """
+        self.queue_draw_item(handles=True, *self._selected_items)
+        self._selected_items.clear()
+        self.focused_item = None
+        self.emit('selection-changed', self._selected_items)
+
+    selected_items = property(lambda s: set(s._selected_items),
+                              select_item, unselect_all,
+                              "Items selected by the view")
+
+    def _set_focused_item(self, item):
+        """
+        Set the focused item, this item is also added to the selected_items
+        set.
+        """
+        if not item is self._focused_item:
+            self.queue_draw_item(self._focused_item, item, handles=True)
+
+        if item:
+            self.selected_items = item #.add(item)
+        if item is not self._focused_item:
+            self._focused_item = item
+            self.emit('focus-changed', item)
+
+    def _del_focused_item(self):
+        """
+        Items that loose focus remain selected.
+        """
+        self.focused_item = None
+        
+    focused_item = property(lambda s: s._focused_item,
+                            _set_focused_item, _del_focused_item,
+                            "The item with focus (receives key events a.o.)")
+
+    def _set_hovered_item(self, item):
+        """
+        Set the hovered item.
+        """
+        if not item is self._hovered_item:
+            self.queue_draw_item(self._hovered_item, item, handles=True)
+        if item is not self._hovered_item:
+            self._hovered_item = item
+            self.emit('hover-changed', item)
+
+    def _del_hovered_item(self):
+        """
+        Unset the hovered item.
+        """
+        self.hovered_item = None
+        
+    hovered_item = property(lambda s: s._hovered_item,
+                            _set_hovered_item, _del_hovered_item,
+                            "The item directly under the mouse pointer")
+
+    def _set_painter(self, painter):
+        """
+        Set the painter to use. Painters should implement painter.Painter.
+        """
+        self._painter = painter
+        self.emit('painter-changed')
+
+    painter = property(lambda s: s._painter, _set_painter)
+
+    def paint(self, cr):
+        """
+        Do the paint action, calling draw() on each item.
+        """
+        self._painter.paint(Context(view=self,
+                                    cairo=cr))
+
+    def get_item_at_point(self, x, y):
+        """
+        Return the topmost item located at (x, y).
+        """
+        point = (x, y)
+        for item in reversed(self._canvas.get_all_items()):
+            if point in self.get_item_bounding_box(item):
+                inverse = Matrix(*self._matrix)
+                inverse.invert()
+                wx, wy = inverse.transform_point(x, y)
+                ix, iy = self._canvas.get_matrix_w2i(item).transform_point(wx, wy)
+                if item.point(ix, iy) < 0.5:
+                    return item
+        return None
+
+    def select_in_rectangle(self, rect):
+        """
+        Select all items who have their bounding box within the
+        rectangle @rect.
+        """
+        for item in self._canvas.get_all_items():
+            if self.get_item_bounding_box(item) in rect:
+                self.select_item(item)
+
+    def zoom(self, factor):
+        """
+        Zoom in/out by factor @factor.
+        """
+        self._matrix.scale(factor, factor)
+
+        # Make sure everything's updated
+        self.request_update(self._canvas.get_all_items())
+
+    def set_item_bounding_box(self, item, bounds):
+        """
+        Update the bounding box of the item (in canvas coordinates).
+        """
+        self._item_bounds[item] = bounds
+        if bounds:
+            bounds.x1 += 1
+            bounds.y1 += 1
+            # Also update the view's overall bounding box.
+            self._bounds += bounds
+
+    def get_item_bounding_box(self, item):
+        """
+        Get the bounding box for the item, in canvas coordinates.
+        """
+        return self._item_bounds[item]
+
+    def get_canvas_size(self):
+        """
+        The canvas size (width, height) in canvas coordinates, determined
+        from the origin (0, 0).
+        """
+        inverse = Matrix(*self._matrix)
+        inverse.invert()
+        ww, wh = self.transform_point_c2w(self._bounds.x1, self._bounds.y1)
+        return self._matrix.transform_distance(ww, wh)
+
+    bounding_box = property(lambda s: s._bounds)
+
+    def update_bounding_box(self, cr, items=None):
+        """
+        Update the bounding boxes of the canvas items for this view.
+        """
+        self._item_bounds = dict()
+        self._bounds = Rectangle()
+
+        painter = BoundingBoxPainter()
+        painter.paint(Context(view=self,
+                              cairo=cr,
+                              items=items))
+
+        # Update the view's bounding box with the rest of the items
+        bounds = self._bounds
+        for b in self._item_bounds.itervalues():
+            bounds += b
+
+    def transform_distance_c2w(self, x, y):
+        """
+        Transform a point from canvas to world coordinates.
+        """
+        inverse = Matrix(*self._matrix)
+        inverse.invert()
+        return inverse.transform_distance(x, y)
+
+    def transform_distance_w2c(self, x, y):
+        """
+        Transform a distance from world to canvas coordinates.
+        """
+        return self._matrix.transform_distance(x, y)
+
+    def transform_point_c2w(self, x, y):
+        """
+        Transform a distance from canvas to world coordinates.
+        """
+        inverse = Matrix(*self._matrix)
+        inverse.invert()
+        return inverse.transform_point(x, y)
+
+    def transform_point_w2c(self, x, y):
+        """
+        Transform a point from world to canvas coordinates.
+        """
+        return self._matrix.transform_point(x, y)
+
+    def transform_point_c2i(self, item, x, y):
+        """
+        Transforma point from canvas to item coordinates.
+        """
+        assert self.canvas
+        wx, wy = self.transform_point_c2w(x, y)
+        return self._canvas.get_matrix_w2i(item).transform_point(wx, wy)
+
+    def transform_point_i2c(self, item, x, y):
+        """
+        Transform a point from item coordinates to canvas coordinates.
+        """
+        assert self.canvas
+        wx, wy = self._canvas.get_matrix_i2w(item).transform_point(x, y)
+        return self.transform_point_w2c(wx, wy)
+
+
+    def wrap_cairo_context(self, cr):
+        """
+        Create a wrapper class for the cairo context. This class is used
+        to calculate the items bounding box while the item is drawn (the
+        bounding box contains all drawn elements).
+        """
+        return CairoContextWrapper(cr)
+
+
-# Map GDK events to tool methods
-EVENT_HANDLERS = {
@@ -127 +404 @@
-
-
-
-
+
+
+
+
+
-    The view uses Tools from tool.py to handle events and Painters
-    from painter.py to draw. Both are configurable.
@@ -149 +429 @@
-                      ())
-    }
+
-    def __init__(self, canvas=None):
-
+
+
-        self.set_flags(gtk.CAN_FOCUS)
-        self.add_events(gtk.gdk.BUTTON_PRESS_MASK
@@ -157 +439 @@
-                        | gtk.gdk.KEY_PRESS_MASK
-                        | gtk.gdk.KEY_RELEASE_MASK)
-        self._canvas = canvas
-        self._bounds = Rectangle()
-        self._item_bounds = dict()
-
-        # Handling selections.
-        self._selected_items = set()
-        self._focused_item = None
-        self._hovered_item = None
-
-        self._matrix = Matrix()
-
-        self.hadjustment = gtk.Adjustment()
@@ -172 +444 @@
-
-        self._tool = DefaultTool()
-
-
-
+
+
+
+
+
+
-
-    def _set_canvas(self, canvas):
-
+
+
-        in the view.
+        This extends the behaviour of View.canvas.
-        """
-        if self._canvas:
-            self._canvas.unregister_view(self)
-
-
-
+
+
-        
-        if self._canvas:
-            self._canvas.register_view(self)
-            #for item in self._canvas.get_all_items():
-            #    self._canvas.request_update(item)
-            self.request_update(self._canvas.get_all_items())
-
-    canvas = property(lambda s: s._canvas, _set_canvas)
-
-    def select_item(self, item):
-        """Select an item. This adds @item to the set of selected items. Do
-           del view.selected_items
-        to clear the selected items list
-        
-        """
-        self.queue_draw_item(item, handles=True)
-        if item not in self._selected_items:
-            self._selected_items.add(item)
-            self.emit('selection-changed', self._selected_items)
-
-    def unselect_item(self, item):
-        """Unselect an item.
-        """
-        self.queue_draw_item(item, handles=True)
-        if item in self._selected_items:
-            self._selected_items.discard(item)
-            self.emit('selection-changed', self._selected_items)
-
-    def select_all(self):
-        for item in self.canvas.get_all_items():
-            self.select_item(item)
-
-    def unselect_all(self):
-        """Clearing the selected_item also clears the focused_item.
-        """
-        self.queue_draw_item(handles=True, *self._selected_items)
-        self._selected_items.clear()
-        self.focused_item = None
-        self.emit('selection-changed', self._selected_items)
-
-    selected_items = property(lambda s: set(s._selected_items),
-                              select_item, unselect_all,
-                              "Items selected by the view")
-
-    def _set_focused_item(self, item):
-        """Set the focused item, this item is also added to the selected_items
-        set.
-        """
-        if not item is self._focused_item:
-            self.queue_draw_item(self._focused_item, item, handles=True)
-
-        if item:
-            self.selected_items = item #.add(item)
-        if item is not self._focused_item:
-            self._focused_item = item
-            self.emit('focus-changed', item)
-
-    def _del_focused_item(self):
-        """Items that loose focus remain selected.
-        """
-        self.focused_item = None
-        
-    focused_item = property(lambda s: s._focused_item,
-                            _set_focused_item, _del_focused_item,
-                            "The item with focus (receives key events a.o.)")
-
-    def _set_hovered_item(self, item):
-        """Set the hovered item.
-        """
-        if not item is self._hovered_item:
-            self.queue_draw_item(self._hovered_item, item, handles=True)
-        if item is not self._hovered_item:
-            self._hovered_item = item
-            self.emit('hover-changed', item)
-
-    def _del_hovered_item(self):
-        """Unset the hovered item.
-        """
-        self.hovered_item = None
-        
-    hovered_item = property(lambda s: s._hovered_item,
-                            _set_hovered_item, _del_hovered_item,
-                            "The item directly under the mouse pointer")
-
-    def _set_tool(self, tool):
-
+
+
-        """
-        self._tool = tool
@@ -277 +476 @@
-    tool = property(lambda s: s._tool, _set_tool)
-
-    def _set_painter(self, painter):
-        """Set the painter to use. Painters should implement painter.Painter.
-        """
-        self._painter = painter
-        self.emit('painter-changed')
-
-    painter = property(lambda s: s._painter, _set_painter)
-
-    def _set_hadjustment(self, adj):
-
+
+
-        """
-        #if self._hadjustment:
@@ -296 +488 @@
-
-    def _set_vadjustment(self, adj):
-
+
+
-        """
-        #if self._vadjustment:
@@ -305 +498 @@
-    vadjustment = property(lambda s: s._vadjustment, _set_vadjustment)
-
-    def get_item_at_point(self, x, y):
-        """Return the topmost item located at (x, y).
-        """
-        point = (x, y)
-        for item in reversed(self._canvas.get_all_items()):
-            if point in self.get_item_bounding_box(item):
-                inverse = Matrix(*self._matrix)
-                inverse.invert()
-                wx, wy = inverse.transform_point(x, y)
-                ix, iy = self._canvas.get_matrix_w2i(item).transform_point(wx, wy)
-                if item.point(ix, iy) < 0.5:
-                    return item
-        return None
-
-    def select_in_rectangle(self, rect):
-        """Select all items who have their bounding box within the
-        rectangle @rect.
-        """
-        for item in self._canvas.get_all_items():
-            if self.get_item_bounding_box(item) in rect:
-                self.select_item(item)
-
-    def zoom(self, factor):
-
-
-
-
-
-
+
+
+
+
-        a = self.allocation
-
+Gtk
-
-    def _update_adjustment(self, adjustment, value, canvas_size, viewport_size):
-        """
-
+Gtk
-        >>> a = gtk.Adjustment()
-        >>> v._hadjustment = a
@@ -361 +530 @@
-            adjustment.value_changed()
-
-    def transform_distance_c2w(self, x, y):
-        """Transform a point from canvas to world coordinates.
-        """
-        inverse = Matrix(*self._matrix)
-        inverse.invert()
-        return inverse.transform_distance(x, y)
-
-    def transform_distance_w2c(self, x, y):
-        """Transform a distance from world to canvas coordinates.
-        """
-        return self._matrix.transform_distance(x, y)
-
-    def transform_point_c2w(self, x, y):
-        """Transform a distance from canvas to world coordinates.
-        """
-        inverse = Matrix(*self._matrix)
-        inverse.invert()
-        return inverse.transform_point(x, y)
-
-    def transform_point_w2c(self, x, y):
-        """Transform a point from world to canvas coordinates.
-        """
-        return self._matrix.transform_point(x, y)
-
-    def transform_point_c2i(self, item, x, y):
-        """Transforma point from canvas to item coordinates.
-        """
-        assert self.canvas
-        wx, wy = self.transform_point_c2w(x, y)
-        return self._canvas.get_matrix_w2i(item).transform_point(wx, wy)
-
-    def transform_point_i2c(self, item, x, y):
-        """Transform a point from item coordinates to canvas coordinates.
-        """
-        assert self.canvas
-        wx, wy = self._canvas.get_matrix_i2w(item).transform_point(x, y)
-        return self.transform_point_w2c(wx, wy)
-
-    def get_canvas_size(self):
-        """The canvas size (width, height) in canvas coordinates.
-        """
-        inverse = Matrix(*self._matrix)
-        inverse.invert()
-        ww, wh = self.transform_point_c2w(self._bounds.x1, self._bounds.y1)
-        return self._matrix.transform_distance(ww, wh)
-
-    def update_adjustments(self, allocation=None):
-
+
+
-        """
-        if not allocation:
@@ -423 +547 @@
-
-    def queue_draw_item(self, *items, **kwargs):
-
+
+
-        item as update areas. Of course with a pythonic flavor: update
-        any number of items at once.
@@ -442 +567 @@
-
-    def queue_draw_area(self, x, y, w, h):
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
-
-    @async(single=False, priority=PRIORITY_HIGH_IDLE)
-    def request_update(self, items):
-
+
+
-        """
-        if not self.window: return True
@@ -493 +598 @@
-
-        # Pseudo-draw
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
-
-        for i in items:
@@ -511 +611 @@
-    @nonrecursive
-    def do_size_allocate(self, allocation):
-
+
+
-        """
-        gtk.DrawingArea.do_size_allocate(self, allocation)
-
+Gtk
-        self.update_adjustments(allocation)
-       
-    def do_expose_event(self, event):
-
+
+
-        """
-        if not self._canvas:
@@ -527 +629 @@
-                                   area.x, area.y, area.width, area.height)
-
-ontext
+r
-
-        # Draw no more than nessesary.
-
-
-
-
-
+
+
+
+
-
-        if DEBUG_DRAW_BOUNDING_BOX:
-ontext
-ontext
-ontext
-ontext
+r
+r
+r
+r
-            b = self._bounds
-ontext
-ontext
-ontext
+r
+r
+r
-
-        return False
-
-    def do_event(self, event):
-
+
+
-        """
-        handler = EVENT_HANDLERS.get(event.type)
@@ -557 +659 @@
-
-    def on_adjustment_changed(self, adj):
-
+
+
-        value of the x/y adjustment (scrollbar).
-        """
@@ -569 +672 @@
-
-        a = self.allocation
-
+Gtk
-
-