--- a/canvas.d	Sun Jul 12 00:39:35 2009 +0930
+++ b/canvas.d	Sun Jul 12 01:04:35 2009 +0930
@@ -38,9 +38,13 @@
 
         mLayers = layers.dup;
         mEventHandler = event_handler;
+        mPPI = ppi;
 
         const double MM_PER_INCH = 25.4;
-        mZoom = 0.25 * ppi / MM_PER_INCH;
+        mZoom = 0.25 * mPPI / MM_PER_INCH;
+
+        // Take the union of the bounds of each layer to
+        // determine the canvas size
 
         Rectangle total_layer_bounds;
 
@@ -48,11 +52,15 @@
             total_layer_bounds = total_layer_bounds | layer.bounds;
         }
 
+        assert(total_layer_bounds.valid);
+
         mCanvasLeftBottom = total_layer_bounds.min_corner - total_layer_bounds.size;
         mCanvasRightTop = total_layer_bounds.max_corner + total_layer_bounds.size;
         mViewCentre = mCanvasLeftBottom + (mCanvasRightTop - mCanvasLeftBottom) / 2.0;
 
-        mHRuler = new HRuler();
+        // Create our child widgets and register callbacks
+
+        mHRuler = new HRuler;
         attach(mHRuler,
                1, 2,
                0, 1,
@@ -60,7 +68,7 @@
                0, 0);
         mHRuler.setMetric(GtkMetricType.CENTIMETERS);
 
-        mVRuler = new VRuler();
+        mVRuler = new VRuler;
         attach(mVRuler,
                0, 1,
                1, 2,
@@ -68,7 +76,7 @@
                0, 0);
         mVRuler.setMetric(GtkMetricType.CENTIMETERS);
 
-        mDrawingArea = new DrawingArea();
+        mDrawingArea = new DrawingArea;
         mDrawingArea.addOnRealize(&onRealize);
         mDrawingArea.addOnConfigure(&onConfigure);
         mDrawingArea.addOnExpose(&onExpose);
@@ -118,29 +126,55 @@
 
         //Point new_model_datum = screen_to_model(screen_datum);
 
-        update_adjustments();
+        update_adjustments;
         //update_rulers(new_model_datum);
-        update_rulers();
-        queueDraw();
+        update_rulers;
+        queueDraw;
     }
 
     override void rel_pan(Vector screen_displacement) {
         mViewCentre = mViewCentre + screen_to_model(screen_displacement);
 
-        update_adjustments();
-        update_rulers();
-        queueDraw();
+        update_adjustments;
+        update_rulers;
+        queueDraw;
+    }
+
+    override double zoom() const {
+        return mZoom;
+    }
+
+    override Point model_to_screen(Point model) const {
+        return Point.DEFAULT + mViewSize / 2.0 + mZoom * (model - mViewCentre);
+    }
+
+    override Point screen_to_model(Point screen) const {
+        return mViewCentre + (screen - mViewSize / 2.0 - Point.DEFAULT) / mZoom;
     }
 
-    override double zoom() const { return mZoom; }
-    override Point model_to_screen(Point model) const { return Point.DEFAULT + mViewSize / 2.0 + mZoom * (model - mViewCentre); }
-    override Point screen_to_model(Point screen) const { return mViewCentre + (screen - mViewSize / 2.0 - Point.DEFAULT) / mZoom; }
-    override Vector model_to_screen(Vector model) const { return mZoom * model; }
-    override Vector screen_to_model(Vector screen) const { return screen / mZoom; }
-    override double model_to_screen(double model) const { return mZoom * model; }
-    override double screen_to_model(double screen) const { return screen / mZoom; }
-    override Rectangle model_to_screen(Rectangle model) const { return Rectangle(model_to_screen(model.position), model_to_screen(model.size)); }
-    override Rectangle screen_to_model(Rectangle model) const { return Rectangle(screen_to_model(model.position), screen_to_model(model.size)); }
+    override Vector model_to_screen(Vector model) const {
+        return mZoom * model;
+    }
+
+    override Vector screen_to_model(Vector screen) const {
+        return screen / mZoom;
+    }
+
+    override double model_to_screen(double model) const {
+        return mZoom * model;
+    }
+
+    override double screen_to_model(double screen) const {
+        return screen / mZoom;
+    }
+
+    override Rectangle model_to_screen(Rectangle model) const {
+        return Rectangle(model_to_screen(model.position), model_to_screen(model.size));
+    }
+
+    override Rectangle screen_to_model(Rectangle model) const {
+        return Rectangle(screen_to_model(model.position), screen_to_model(model.size));
+    }
 
     private {
 
@@ -153,8 +187,8 @@
             assert(widget is mDrawingArea);
 
             mViewSize = Vector(cast(double)event.width, cast(double)event.height);
-            update_adjustments();
-            update_rulers();
+            update_adjustments;
+            update_rulers;
 
 
             return true;
@@ -163,7 +197,7 @@
         bool onExpose(GdkEventExpose * event, Widget widget) {
             assert(widget is mDrawingArea);
 
-            Drawable dr = mDrawingArea.getWindow();
+            Drawable dr = mDrawingArea.getWindow;
 
             int width, height;
             dr.getSize(width, height);
@@ -178,41 +212,43 @@
                 Rectangle(Point(cast(double)event.area.x, cast(double)event.area.y),
                           Vector(cast(double)event.area.width, cast(double)event.area.height));
 
-            model_cr.save(); screen_cr.save(); {
+            model_cr.save; screen_cr.save; {
                 // Setup model context
 
                 rectangle(model_cr, damage);
-                model_cr.clip();
+                model_cr.clip;
 
                 GtkAdjustment * h_gtkAdjustment = mHAdjustment.getAdjustmentStruct();
                 GtkAdjustment * v_gtkAdjustment = mVAdjustment.getAdjustmentStruct();
 
                 model_cr.translate(mCanvasLeftBottom.x - gtk_adjustment_get_value(h_gtkAdjustment),
                                    mCanvasLeftBottom.y - gtk_adjustment_get_value(v_gtkAdjustment));
-                model_cr.scale(mZoom, mZoom);
+                model_cr.scale(mZoom, -mZoom);
 
                 // Setup screen context
 
+                screen_cr.translate(0.0, mViewSize.y);
+                screen_cr.scale(1.0, -1.0);
                 rectangle(screen_cr, damage);
-                screen_cr.clip();
+                screen_cr.clip;
 
                 // Fill the background
 
-                screen_cr.save(); {
+                screen_cr.save; {
                     // Make the window light grey
                     screen_cr.setSourceRgba(1.0, 1.0, 1.0, 0.7);
                     rectangle(screen_cr, damage);
-                    screen_cr.fill();
-                } screen_cr.restore();
+                    screen_cr.fill;
+                } screen_cr.restore;
 
                 // Draw each layer
 
                 foreach(ref layer; mLayers) {
-                    model_cr.save(); screen_cr.save(); {
+                    model_cr.save; screen_cr.save; {
                         layer.draw(this, damage, model_cr, screen_cr);
-                    } screen_cr.restore(); model_cr.restore();
+                    } screen_cr.restore; model_cr.restore;
                 }
-            } screen_cr.restore(); model_cr.restore();
+            } screen_cr.restore; model_cr.restore;
 
             return true;
         }
@@ -299,8 +335,8 @@
         }
 
         void onValueChanged(Adjustment adjustment) {
-            GtkAdjustment * h_gtkAdjustment = mHAdjustment.getAdjustmentStruct();
-            GtkAdjustment * v_gtkAdjustment = mVAdjustment.getAdjustmentStruct();
+            GtkAdjustment * h_gtkAdjustment = mHAdjustment.getAdjustmentStruct;
+            GtkAdjustment * v_gtkAdjustment = mVAdjustment.getAdjustmentStruct;
 
             Point view_left_bottom = Point(gtk_adjustment_get_value(h_gtkAdjustment),
                                              gtk_adjustment_get_value(v_gtkAdjustment));
@@ -308,9 +344,9 @@
             Vector model_size = screen_to_model(mViewSize);
             mViewCentre = view_left_bottom + model_size / 2.0;
 
-            update_rulers();
+            update_rulers;
 
-            queueDraw();
+            queueDraw;
         }
 
         void update_rulers() {
@@ -365,16 +401,14 @@
             gtk_adjustment_set_page_increment(v_gtkAdjustment, canvas_size.y / 5.0);
             gtk_adjustment_set_page_size(v_gtkAdjustment, model_size.y);
 
-            mHAdjustment.changed();
-            mHAdjustment.valueChanged();
-            mVAdjustment.changed();
-            mVAdjustment.valueChanged();
+            mHAdjustment.changed;
+            mHAdjustment.valueChanged;
+            mVAdjustment.changed;
+            mVAdjustment.valueChanged;
         }
 
         double clamp_zoom(double zoom) { return clamp(zoom, 0.02, 50.0); }
 
-        EventHandler mEventHandler;
-
         // Model units are in millimetres
         // Screen units are in pixels
 
@@ -397,5 +431,7 @@
 
         // Layers:
         Layer[] mLayers;
+        EventHandler mEventHandler;
+        double mPPI;
     }
 }