--- a/doodle/gtk/canvas.d	Sat Aug 14 20:48:41 2010 +0930
+++ b/doodle/gtk/canvas.d	Sun Aug 15 00:30:03 2010 +0930
@@ -2,7 +2,7 @@
 
 public {
     import doodle.dia.icanvas;
-    import doodle.tk.events;
+    import doodle.gtk.events;
 }
 
 private {
@@ -33,8 +33,6 @@
 
     import std.math;
     import std.stdio;
-
-    import core.stdc.string : strlen;
 }
 
 final class Canvas : Table, private IViewport {
@@ -138,8 +136,8 @@
 
         // IViewport overrides:
 
-        void zoomRelative(in Point pixelDatum, in double factor) {
-            _pixelModel.zoomRelative(factor, pixelDatum);
+        void zoomRelative(in Point screenDatum, in double factor) {
+            _pixelModel.zoomRelative(factor, screenDatum);
 
             consolidateBounds;
 
@@ -149,8 +147,8 @@
             queueDraw;
         }
 
-        void panRelative(in Vector pixelDisplacement) {
-            _pixelModel.panRelativePixel(pixelDisplacement);
+        void panRelative(in Vector screenDisplacement) {
+            _pixelModel.panRelativePixel(screenDisplacement);
 
             consolidateBounds;
 
@@ -304,59 +302,22 @@
 
         bool onButtonPress(GdkEventButton * event, Widget widget) {
             assert(widget is _drawingArea);
-            //trace("Got button event\n");
 
-            Point pixelPoint = Point(event.x + 0.5, _pixelModel.viewBounds.h - (event.y + 0.5));
-            Point modelPoint = _pixelModel.pixelToModel(pixelPoint);
-
-            auto buttonEvent = new ButtonEvent(gtk2tkButtonAction(event.type),
-                                               gtk2tkButtonName(event.button),
-                                               pixelPoint,
-                                               modelPoint,
-                                               gtk2tkMask(event.state));
-
+            auto buttonEvent = makeButtonEvent(event, _pixelModel);
             _eventHandler.handleButtonPress(this, buttonEvent);
-
             fixDamage;
-
             return true;
         }
 
         bool onButtonRelease(GdkEventButton * event, Widget widget) {
             assert(widget is _drawingArea);
 
-            Point pixelPoint = Point(event.x + 0.5, _pixelModel.viewBounds.h - (event.y + 0.5));
-            Point modelPoint = _pixelModel.pixelToModel(pixelPoint);
-
-            auto buttonEvent = new ButtonEvent(gtk2tkButtonAction(event.type),
-                                               gtk2tkButtonName(event.button),
-                                               pixelPoint,
-                                               modelPoint,
-                                               gtk2tkMask(event.state));
-
+            auto buttonEvent = makeButtonEvent(event, _pixelModel);
             _eventHandler.handleButtonRelease(this, buttonEvent);
-
             fixDamage;
-
             return true;
         }
 
-        /*
-           public struct GdkEventKey {
-           GdkEventType type;
-           GdkWindow *window;
-           byte sendEvent;
-           uint time;
-           uint state;
-           uint keyval;
-           int length;
-           char *string;
-           ushort hardwareKeycode;
-           ubyte group;
-           uint bitfield0;
-           uint isModifier : 1;
-        }
-         */
         bool onKeyPressEvent(GdkEventKey * event, Widget widget) {
             assert(widget is _drawingArea);
 
@@ -387,18 +348,11 @@
 
         bool onMotionNotify(GdkEventMotion * event, Widget widget) {
             assert(widget is _drawingArea);
-            //writefln("Got motion notify\n");
+            // Pass the events on to the rulers
             gtk_widget_event(_hRuler.getWidgetStruct(), cast(GdkEvent *)event);
             gtk_widget_event(_vRuler.getWidgetStruct(), cast(GdkEvent *)event);
 
-            Point pixelPoint = Point(event.x + 0.5, _pixelModel.viewBounds.h - (event.y + 0.5));
-            Point modelPoint = _pixelModel.pixelToModel(pixelPoint);
-
-            auto motionEvent = new MotionEvent(pixelPoint,
-                                               modelPoint,
-                                               gtk2tkMask(event.state));
-
-            _eventHandler.handleMotion(this, motionEvent);
+            _eventHandler.handleMotion(this, makeMotionEvent(event, _pixelModel));
 
             fixDamage;
 

--- a/doodle/tk/events.d	Sat Aug 14 20:48:41 2010 +0930
+++ b/doodle/tk/events.d	Sun Aug 15 00:30:03 2010 +0930
@@ -2,6 +2,8 @@
 
 public {
     import doodle.tk.geometry;
+    import doodle.tk.pixel_model;
+    import gtkc.gdktypes;
 }
 
 private {

--- a/doodle/tk/pixel_model.d	Sat Aug 14 20:48:41 2010 +0930
+++ b/doodle/tk/pixel_model.d	Sun Aug 15 00:30:03 2010 +0930
@@ -18,20 +18,19 @@
 class PixelModel {
     this(in double zoom, in Rectangle canvasBounds, in Rectangle viewBounds) {
         _zoom = zoom;
-        _viewBounds = viewBounds;
-        _canvasBounds = canvasBounds;
+        _viewBoundsScreen = viewBounds;
+        _canvasBoundsModel = canvasBounds;
 
         // Choose the centre of the canvas as the centre of the view
-        _viewCentre = _canvasBounds.centre;
+        _viewCentreModel = _canvasBoundsModel.centre;
     }
 
     void consolidateCanvasBounds(in Rectangle requiredCanvasBounds) {
-        Rectangle r = pixelToModel(_viewBounds);
-        _canvasBounds = r | requiredCanvasBounds;
+        _canvasBoundsModel = pixelToModel(_viewBoundsScreen) | requiredCanvasBounds;
     }
 
     void canvasAccommodate(in Rectangle bounds) {
-        _canvasBounds = _canvasBounds | bounds;
+        _canvasBoundsModel = _canvasBoundsModel | bounds;
     }
 
     void zoomRelative(in double factor, in Point pixelDatum) {
@@ -40,28 +39,23 @@
         // pixel distance the same
 
         Point oldModelDatum = pixelToModel(pixelDatum);
-        Vector pixelDistance = modelToPixel(oldModelDatum - _viewCentre);
+        Vector pixelDistance = modelToPixel(oldModelDatum - _viewCentreModel);
         _zoom = clampZoom(zoom * factor);
-        _viewCentre = oldModelDatum - pixelToModel(pixelDistance);
+        _viewCentreModel = oldModelDatum - pixelToModel(pixelDistance);
     }
 
-    void panRelativePixel(in Vector pixelDisplacement) {
-        _viewCentre = _viewCentre + pixelToModel(pixelDisplacement);
-    }
-
-    void panRelativeModel(in Vector modelDisplacement) {
-        _viewCentre = _viewCentre + modelDisplacement;
-    }
+    void panRelativePixel(in Vector pixelDisplacement) { _viewCentreModel = _viewCentreModel + pixelToModel(pixelDisplacement); }
+    void panRelativeModel(in Vector modelDisplacement) { _viewCentreModel = _viewCentreModel + modelDisplacement; }
 
     // For normalZoom 1.0 -> 100% means the presentation on the screen is
     // one-to-one with real-life
     double normalZoom(in double pixelsPerMillimetre) const { return _zoom / pixelsPerMillimetre; }
     double zoom() const { return _zoom; }
-    Rectangle viewBounds() const { return _viewBounds; }
-    Rectangle canvasBounds() const { return _canvasBounds; }
+    Rectangle viewBounds() const { return _viewBoundsScreen; }
+    Rectangle canvasBounds() const { return _canvasBoundsModel; }
 
-    Point modelToPixel(in Point model) const { return _viewBounds.centre + _zoom * (model - _viewCentre); }
-    Point pixelToModel(in Point pixel) const { return _viewCentre + (pixel - _viewBounds.centre) / _zoom; }
+    Point modelToPixel(in Point model) const { return _viewBoundsScreen.centre + _zoom * (model - _viewCentreModel); }
+    Point pixelToModel(in Point pixel) const { return _viewCentreModel + (pixel - _viewBoundsScreen.centre) / _zoom; }
     Vector modelToPixel(in Vector model) const { return _zoom * model; }
     Vector pixelToModel(in Vector pixel) const { return pixel / _zoom; }
     Rectangle modelToPixel(in Rectangle model) const { return Rectangle(modelToPixel(model.position), modelToPixel(model.size)); }
@@ -72,9 +66,9 @@
 
         // Screen units are pixels
         // Model units are millimetres
-        double _zoom;               // pixels-per-millimetre
-        Rectangle _viewBounds;      // pixel: bounds of the viewport in pixels
-        Point _viewCentre;          // model: where in the model is the centre of our view
-        Rectangle _canvasBounds;    // model: the bounds of the canvas in millimetres
+        double    _zoom;                // pixels-per-millimetre
+        Rectangle _viewBoundsScreen;    // bounds of the viewport in pixels
+        Point     _viewCentreModel;     // where in the model is the centre of our view
+        Rectangle _canvasBoundsModel;   // the bounds of the canvas in millimetres
     }
 }