--- a/doodle/dia/grid_layer.d	Sun Aug 15 23:18:05 2010 +0930
+++ b/doodle/dia/grid_layer.d	Sun Aug 15 23:43:04 2010 +0930
@@ -32,8 +32,9 @@
         return Rectangle();
     }
 
-    override void draw(in Rectangle pixelDamage, scope Context pixelCr,
-                       in Rectangle modelDamage, scope Context modelCr) const {
+    override void draw(in Rectangle screenDamage, scope Drawable screenDrawable,
+                       in Rectangle modelDamage, scope Drawable modelDrawable) const {
+        /+
         assert(_zoomValid);
 
         double xx = 1.0, yy = 1.0;
@@ -86,6 +87,7 @@
                 }
             }
         } modelCr.restore();
+        +/
     }
 
     // IGrid overrides:

--- a/doodle/dia/icanvas.d	Sun Aug 15 23:18:05 2010 +0930
+++ b/doodle/dia/icanvas.d	Sun Aug 15 23:43:04 2010 +0930
@@ -3,7 +3,7 @@
 public {
     import doodle.tk.geometry;
     import doodle.tk.events;
-    import cairo.Context;
+    import doodle.tk.drawable;
 }
 
 private {
@@ -67,8 +67,8 @@
 
     Rectangle bounds() const;
 
-    void draw(in Rectangle screenDamage, scope Context screenCr,
-              in Rectangle modelDamage, scope Context modelCr) const;
+    void draw(in Rectangle screenDamage, scope Drawable screenDrawable,
+              in Rectangle modelDamage, scope Drawable modelDrawable) const;
 
     private {
         immutable string _name;

--- a/doodle/dia/layer_stack.d	Sun Aug 15 23:18:05 2010 +0930
+++ b/doodle/dia/layer_stack.d	Sun Aug 15 23:43:04 2010 +0930
@@ -17,10 +17,10 @@
         return bounds;
     }
 
-    void draw(in Rectangle pixelDamage, scope Context pixelCr,
-              in Rectangle modelDamage, scope Context modelCr) {
+    void draw(in Rectangle screenDamage, scope Drawable screenDrawable,
+              in Rectangle modelDamage, scope Drawable modelDrawable) {
         foreach(layer; _layers) {
-            layer.draw(pixelDamage, pixelCr, modelDamage, modelCr);
+            layer.draw(screenDamage, screenDrawable, modelDamage, modelDrawable);
         }
     }
 

--- a/doodle/dia/page_layer.d	Sun Aug 15 23:18:05 2010 +0930
+++ b/doodle/dia/page_layer.d	Sun Aug 15 23:43:04 2010 +0930
@@ -21,21 +21,19 @@
         return _pageGeometry;
     }
 
-    override void draw(in Rectangle pixelDamage, scope Context pixelCr,
-                       in Rectangle modelDamage, scope Context modelCr) const {
+    override void draw(in Rectangle screenDamage, scope Drawable screenDrawable,
+                       in Rectangle modelDamage, scope Drawable modelDrawable) const {
         // Make the paper white, with a border
 
-        modelCr.save; {
-            modelCr.setSourceRgba(0.0, 0.0, 0.0, 1.0);
-            rectangle(modelCr, _pageGeometry);
-            modelCr.stroke;
-        } modelCr.restore;
+        modelDrawable.pushState; {
+            modelDrawable.setColor(Color(0.0, 0.0, 0.0, 1.0));
+            modelDrawable.drawRectangle(_pageGeometry, false);
+        } modelDrawable.popState;
 
-        modelCr.save; {
-            modelCr.setSourceRgba(1.0, 1.0, 1.0, 1.0);
-            rectangle(modelCr, _pageGeometry);
-            modelCr.fill;
-        } modelCr.restore;
+        modelDrawable.pushState; {
+            modelDrawable.setColor(Color(1.0, 1.0, 1.0, 1.0));
+            modelDrawable.drawRectangle(_pageGeometry, true);
+        } modelDrawable.popState;
     }
 
     // IPage overrides:

--- a/doodle/dia/standard_tools.d	Sun Aug 15 23:18:05 2010 +0930
+++ b/doodle/dia/standard_tools.d	Sun Aug 15 23:43:04 2010 +0930
@@ -15,7 +15,7 @@
 
     override bool handleButtonPress(scope IViewport viewport, in ButtonEvent event) {
         if (event.buttonName == ButtonName.MIDDLE) {
-            mLastPosition = event.pixelPoint;
+            mLastPosition = event.screenPoint;
             return true;
         }
         else {
@@ -25,8 +25,8 @@
 
     override bool handleMotion(scope IViewport viewport, in MotionEvent event) {
         if (event.mask.isSet(Modifier.MIDDLE_BUTTON)) {
-            viewport.panRelative(mLastPosition - event.pixelPoint);
-            mLastPosition = event.pixelPoint;
+            viewport.panRelative(mLastPosition - event.screenPoint);
+            mLastPosition = event.screenPoint;
 
             return true;
         }
@@ -106,11 +106,11 @@
     override bool handleScroll(scope IViewport viewport, in ScrollEvent event) {
         if (event.mask.isSet(Modifier.CONTROL)) {
             if (event.scrollDirection == ScrollDirection.DOWN) {
-                viewport.zoomRelative(event.pixelPoint, 1.0 / ZOOM);
+                viewport.zoomRelative(event.screenPoint, 1.0 / ZOOM);
                 return true;
             }
             else if (event.scrollDirection == ScrollDirection.UP) {
-                viewport.zoomRelative(event.pixelPoint, ZOOM);
+                viewport.zoomRelative(event.screenPoint, ZOOM);
                 return true;
             }
             else {

--- a/doodle/dia/tool.d	Sun Aug 15 23:18:05 2010 +0930
+++ b/doodle/dia/tool.d	Sun Aug 15 23:43:04 2010 +0930
@@ -24,7 +24,7 @@
     //bool handleFocusIn(scope IViewport viewport, FocusEvent event) { return false; }
     //bool handleFocusOut(scope IViewport viewport, FocusEvent event) { return false; }
 
-    void draw(in Rectangle pixelDamage, scope Context pixelCr) const { }
+    void draw(in Rectangle screenDamage, scope Drawable screenDrawable) const { }
 
     private {
         immutable string _name;

--- a/doodle/dia/tool_layer.d	Sun Aug 15 23:18:05 2010 +0930
+++ b/doodle/dia/tool_layer.d	Sun Aug 15 23:43:04 2010 +0930
@@ -40,10 +40,10 @@
         return Rectangle();
     }
 
-    override void draw(in Rectangle pixelDamage, scope Context pixelCr,
-                       in Rectangle modelDamage, scope Context modelCr) const {
+    override void draw(in Rectangle screenDamage, scope Drawable screenDrawable,
+                       in Rectangle modelDamage, scope Drawable modelDrawable) const {
         if (_grabbedTool) {
-            _grabbedTool.draw(pixelDamage, pixelCr);
+            _grabbedTool.draw(screenDamage, screenDrawable);
         }
     }
 

--- a/doodle/fig/diagram_elements.d	Sun Aug 15 23:18:05 2010 +0930
+++ b/doodle/fig/diagram_elements.d	Sun Aug 15 23:43:04 2010 +0930
@@ -2,7 +2,7 @@
 
 private {
     import doodle.tk.geometry;
-    import doodle.tk.cairo;
+    import doodle.tk.drawable;
 }
 
 interface IDiagram {
@@ -12,7 +12,7 @@
 abstract class DiagramElement {
     Rectangle bounds() const;
 
-    void draw(in Rectangle damage, scope Context cr) const;
+    void draw(in Rectangle damage, scope Drawable cr) const;
 
     private {
         //GraphElement _container;                // FIXME use an interface to the container
@@ -64,8 +64,8 @@
  */
 
 final class RectanglePrimitive : GraphicPrimitive {
-    override void draw(in Rectangle damage, scope Context cr) const {
-        rectangle(cr, bounds);
+    override void draw(in Rectangle damage, scope Drawable drawable) const {
+        drawable.drawRectangle(bounds, false);
     }
 
     override Rectangle bounds() const { return _bounds; }

--- a/doodle/fig/diagram_layer.d	Sun Aug 15 23:18:05 2010 +0930
+++ b/doodle/fig/diagram_layer.d	Sun Aug 15 23:43:04 2010 +0930
@@ -23,11 +23,11 @@
         return Rectangle.DEFAULT;
     }
 
-    override void draw(in Rectangle pixelDamage, scope Context pixelCr,
-                       in Rectangle modelDamage, scope Context modelCr) const {
+    override void draw(in Rectangle screenDamage, scope Drawable screenDrawable,
+                       in Rectangle modelDamage, scope Drawable modelDrawable) const {
         foreach (e; _elements) {
             if ((e.bounds & modelDamage).valid) {
-                e.draw(modelDamage, modelCr);
+                e.draw(modelDamage, modelDrawable);
             }
         }
     }

--- a/doodle/fig/select_tool.d	Sun Aug 15 23:18:05 2010 +0930
+++ b/doodle/fig/select_tool.d	Sun Aug 15 23:43:04 2010 +0930
@@ -16,7 +16,7 @@
     override bool handleButtonPress(scope IViewport viewport, in ButtonEvent event) {
         if (event.buttonName == ButtonName.LEFT) {
             _active = true;
-            _anchorPoint = _currentPoint = event.pixelPoint;
+            _anchorPoint = _currentPoint = event.screenPoint;
             viewport.setCursor(Cursor.HAND);
             return true;
         }
@@ -40,31 +40,39 @@
     override bool handleMotion(scope IViewport viewport, in MotionEvent event) {
         if (_active) {
             viewport.damageScreen(growCentre(Rectangle(_anchorPoint, _currentPoint), LINE_WIDTH));
-            _currentPoint = event.pixelPoint;
+            _currentPoint = event.screenPoint;
             viewport.damageScreen(growCentre(Rectangle(_anchorPoint, _currentPoint), LINE_WIDTH));
         }
 
         return false;
     }
 
-    override void draw(in Rectangle pixelDamage, scope Context pixelCr) const {
+    override void draw(in Rectangle screenDamage, scope Drawable screenDrawable) const {
         if (_active) {
             /*
-               pixelCr.save; {
-               pixelCr.setSourceRgba(0.0, 0.0, 0.8, 0.3);
-               rectangle(pixelCr, Rectangle(_currentPoint, _anchorPoint));
-               pixelCr.fill();
-               } pixelCr.restore();
+               screenCr.save; {
+               screenCr.setSourceRgba(0.0, 0.0, 0.8, 0.3);
+               rectangle(screenCr, Rectangle(_currentPoint, _anchorPoint));
+               screenCr.fill();
+               } screenCr.restore();
              */
 
-            pixelCr.save(); {
+            screenDrawable.pushState; {
+                screenDrawable.setLineWidth(LINE_WIDTH);
+                screenDrawable.setColor(Color(0.0, 0.0, 0.5, 1.0));
+                screenDrawable.drawRectangle(Rectangle(_currentPoint, _anchorPoint), false);
+            } screenDrawable.popState;
+
+            /*
+            screenCr.save(); {
                 double[] dashes = [ 4.0, 4.0 ];
-                pixelCr.setDash(dashes, 0.0);
-                pixelCr.setSourceRgba(0.0, 0.0, 0.5, 1.0);
-                pixelCr.setLineWidth(LINE_WIDTH);
-                rectangle(pixelCr, Rectangle(_currentPoint, _anchorPoint));
-                pixelCr.stroke;
-            } pixelCr.restore;
+                screenCr.setDash(dashes, 0.0);
+                screenCr.setSourceRgba(0.0, 0.0, 0.5, 1.0);
+                screenCr.setLineWidth(LINE_WIDTH);
+                rectangle(screenCr, Rectangle(_currentPoint, _anchorPoint));
+                screenCr.stroke;
+            } screenCr.restore;
+            */
         }
     }
 

--- a/doodle/gtk/cairo.d	Sun Aug 15 23:18:05 2010 +0930
+++ b/doodle/gtk/cairo.d	Sun Aug 15 23:43:04 2010 +0930
@@ -1,7 +1,7 @@
 module doodle.gtk.cairo;
 
 public {
-    import doodle.tk.drawing;
+    import doodle.tk.drawable;
     import cairo.Context;
 }
 
@@ -42,6 +42,7 @@
     void drawRectangle(in Rectangle rectangle, bool fill) {
         _cr.rectangle(rectangle.position.x, rectangle.position.y,
                       rectangle.size.x, rectangle.size.y);
+        if (fill) { _cr.fill; } else { _cr.stroke; }
     }
 
     void drawEllipse(in Rectangle rectangle, bool fill) {

--- a/doodle/gtk/canvas.d	Sun Aug 15 23:18:05 2010 +0930
+++ b/doodle/gtk/canvas.d	Sun Aug 15 23:43:04 2010 +0930
@@ -3,6 +3,7 @@
 public {
     import doodle.dia.icanvas;
     import doodle.gtk.events;
+    import doodle.gtk.cairo;
 }
 
 private {
@@ -208,7 +209,7 @@
         bool onExpose(GdkEventExpose * event, Widget widget) {
             assert(widget is _drawingArea);
 
-            Drawable dr = _drawingArea.getWindow;
+            gdk.Drawable.Drawable dr = _drawingArea.getWindow;
 
             int width, height;
             dr.getSize(width, height);
@@ -253,7 +254,8 @@
                     screenCr.fill;
                 } screenCr.restore;
 
-                _layerStack.draw(screenDamage, screenCr, modelDamage, modelCr);
+                _layerStack.draw(screenDamage, new CairoDrawable(screenCr),
+                                 modelDamage, new CairoDrawable(modelCr));
             } screenCr.restore; modelCr.restore;
 
             return true;

--- a/doodle/gtk/opengl.d	Sun Aug 15 23:18:05 2010 +0930
+++ b/doodle/gtk/opengl.d	Sun Aug 15 23:43:04 2010 +0930
@@ -1,7 +1,7 @@
 module doodle.gtk.opengl;
 
 public {
-    import doodle.tk.drawing;
+    import doodle.tk.drawable;
 }
 
 /*

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/doodle/tk/drawable.d	Sun Aug 15 23:43:04 2010 +0930
@@ -0,0 +1,47 @@
+module doodle.tk.drawable;
+
+public {
+    import doodle.tk.geometry;
+    import doodle.tk.color;
+}
+
+interface Drawable {
+    enum LineStyle {
+        SOLID,
+        DASHED,
+        DOTTED
+    }
+
+    enum FontFace {
+        NORMAL
+    }
+
+    // Low-level state manipulation
+
+    void setLineStyle(LineStyle style);
+    void setLineWidth(in double width);
+    void setColor(in Color color);
+
+    void translate(in Point p);
+    void scale(in double s);
+
+    void pushState();           // Copies all of current state
+    void popState();            // Restores all of previous state
+
+    // High-level drawing routines
+
+    void drawRectangle(in Rectangle rectangle, bool fill);
+    void drawEllipse(in Rectangle rectangle, bool fill);
+    void drawSegment(in Segment segment);
+    void drawHLine(in double y, in double x0, in double x1);
+    void drawVLine(in double x, in double y0, in double y1);
+    void drawPoly(in Point[] points, bool fill);
+
+    // Text routines
+
+    void setFontFace(in FontFace face);
+    void setFontSize(in double size);
+    void drawText(in string text);
+
+    void measureText(in string text, out Rectangle logicalBounds, out Rectangle totalBounds) const;
+}

--- a/doodle/tk/drawing.d	Sun Aug 15 23:18:05 2010 +0930
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,47 +0,0 @@
-module doodle.tk.drawing;
-
-public {
-    import doodle.tk.geometry;
-    import doodle.tk.color;
-}
-
-interface Drawable {
-    enum LineStyle {
-        SOLID,
-        DASHED,
-        DOTTED
-    }
-
-    enum FontFace {
-        NORMAL
-    }
-
-    // Low-level state manipulation
-
-    void setLineStyle(LineStyle style);
-    void setLineWidth(in double width);
-    void setColor(in Color color);
-
-    void translate(in Point p);
-    void scale(in double s);
-
-    void pushState();           // Copies all of current state
-    void popState();            // Restores all of previous state
-
-    // High-level drawing routines
-
-    void drawRectangle(in Rectangle rectangle, bool fill);
-    void drawEllipse(in Rectangle rectangle, bool fill);
-    void drawSegment(in Segment segment);
-    void drawHLine(in double y, in double x0, in double x1);
-    void drawVLine(in double x, in double y0, in double y1);
-    void drawPoly(in Point[] points, bool fill);
-
-    // Text routines
-
-    void setFontFace(in FontFace face);
-    void setFontSize(in double size);
-    void drawText(in string text);
-
-    void measureText(in string text, out Rectangle logicalBounds, out Rectangle totalBounds) const;
-}

--- a/doodle/tk/events.d	Sun Aug 15 23:18:05 2010 +0930
+++ b/doodle/tk/events.d	Sun Aug 15 23:43:04 2010 +0930
@@ -95,34 +95,34 @@
 }
 
 abstract class PointerEvent : Event {
-    this(in Point pixelPoint, in Point modelPoint, in Mask mask) {
+    this(in Point screenPoint, in Point modelPoint, in Mask mask) {
         super(mask);
-        _pixelPoint = pixelPoint;
+        _screenPoint = screenPoint;
         _modelPoint = modelPoint;
     }
 
-    Point pixelPoint() const { return _pixelPoint; }
+    Point screenPoint() const { return _screenPoint; }
     Point modelPoint() const { return _modelPoint; }
 
     private {
-        Point _pixelPoint;
+        Point _screenPoint;
         Point _modelPoint;
     }
 }
 
 final class CrossingEvent : PointerEvent {
     this(in CrossingMode crossingMode,
-         in Point pixelPoint,
+         in Point screenPoint,
          in Point modelPoint,
          in Mask mask) {
-        super(pixelPoint, modelPoint, mask);
+        super(screenPoint, modelPoint, mask);
         _crossingMode = crossingMode;
     }
 
     CrossingMode crossingMode() const { return _crossingMode; }
 
     override string toString() const {
-        return std.string.format("Crossing event: %s, %s, %s, %s", enumToString(_crossingMode), pixelPoint, modelPoint, mask);
+        return std.string.format("Crossing event: %s, %s, %s, %s", enumToString(_crossingMode), screenPoint, modelPoint, mask);
     }
 
     private {
@@ -133,10 +133,10 @@
 final class ButtonEvent : PointerEvent {
     this(in ButtonAction buttonAction,
          in ButtonName buttonName,
-         in Point pixelPoint,
+         in Point screenPoint,
          in Point modelPoint,
          in Mask mask) {   
-        super(pixelPoint, modelPoint, mask);
+        super(screenPoint, modelPoint, mask);
         _buttonAction = buttonAction;
         _buttonName = buttonName;
     }
@@ -144,7 +144,7 @@
     override string toString() const {
         return std.string.format("Button event: %s, %s, %s, %s, %s",
                                  enumToString(_buttonAction), enumToString(_buttonName),
-                                 _pixelPoint, _modelPoint, _mask);
+                                 _screenPoint, _modelPoint, _mask);
     }
 
     ButtonAction buttonAction() const { return _buttonAction; }
@@ -157,30 +157,30 @@
 }
 
 final class MotionEvent : PointerEvent {
-    this(in Point pixelPoint,
+    this(in Point screenPoint,
          in Point modelPoint,
          in Mask mask) {
-        super(pixelPoint, modelPoint, mask);
+        super(screenPoint, modelPoint, mask);
     }
 
     override string toString() const {
         return std.string.format("Motion event: %s, %s, %s",
-                                 _pixelPoint, _modelPoint, _mask);
+                                 _screenPoint, _modelPoint, _mask);
     }
 }
 
 final class ScrollEvent : PointerEvent {
     this(in ScrollDirection scrollDirection,
-         in Point pixelPoint,
+         in Point screenPoint,
          in Point modelPoint,
          in Mask mask) {
-        super(pixelPoint, modelPoint, mask);
+        super(screenPoint, modelPoint, mask);
         _scrollDirection = scrollDirection;
     }
 
     override string toString() const {
         return std.string.format("Scroll event: %s, %s, %s, %s",
-                                 enumToString(_scrollDirection), _pixelPoint, _modelPoint, _mask);
+                                 enumToString(_scrollDirection), _screenPoint, _modelPoint, _mask);
     }
 
     ScrollDirection scrollDirection() const { return _scrollDirection; }