--- a/canvas.d	Wed May 13 17:50:25 2009 +0930
+++ b/canvas.d	Fri Jul 10 15:15:27 2009 +0930
@@ -20,7 +20,7 @@
 import gtk.Adjustment;
 
 import tk.misc;
-import tk.geometry;
+import tk.geometry2;
 import tk.types;
 import tk.events;
 import tk.gtk_support;
@@ -28,27 +28,14 @@
 private import gtkc.gtk;
 
 import icanvas;
+import cairo_support;
 
 // x and y run right and up respectively
 
-void rectangle(Context cr, Point corner1, Point corner2) {
-    double x = corner1.x;
-    double y = corner1.y;
-    double w = corner2.x - corner1.x;
-    double h = corner2.y - corner1.y;
-
-    if (w < 0.0) { x += w; w = -w; }
-    if (h < 0.0) { y += h; h = -h; }
-
-    //writefln("Rect: %f %f %f %f\n", x, y, w, h);
-
-    cr.rectangle(x, y, w, h);
-}
-
 class Canvas : Table, ICanvas {
     static this() {
-        ORIGIN = new Point(0.0, 0.0);
-        INITIAL_PAGE_SIZE = new Vector(210.0, 297.0);       // A4
+        ORIGIN = Point2(0.0, 0.0);
+        INITIAL_PAGE_SIZE = Vector2(210.0, 297.0);       // A4
     }
 
     this(ICanvasEventHandler event_handler) {
@@ -60,7 +47,7 @@
         const double MM_PER_INCH = 25.4;
         mZoom = 0.25 * PPI / MM_PER_INCH;
 
-        mPageLeftBottom = ORIGIN.clone();
+        mPageLeftBottom = ORIGIN;
         mPageRightTop = ORIGIN + INITIAL_PAGE_SIZE;
         mViewCentre = ORIGIN + INITIAL_PAGE_SIZE / 2.0;
 
@@ -101,7 +88,7 @@
 
         // value, lower, upper, step-inc, page-inc, page-size
         // Give the adjustments dummy values until we receive a configure
-        mHAdjustment = new Adjustment(0.0, 0.0, 1.0, 0.2, 0.5, 1.0);
+        mHAdjustment = new Adjustment(0.25, 0.0, 1.0, 0.2, 0.5, 0.5);
         mHAdjustment.addOnValueChanged(&onValueChanged);
         mHScrollbar = new HScrollbar(mHAdjustment);
         attach(mHScrollbar,
@@ -110,7 +97,7 @@
                AttachOptions.FILL | AttachOptions.EXPAND, AttachOptions.SHRINK,
                0, 0);
 
-        mVAdjustment = new Adjustment(0.0, 0.0, 1.0, 0.2, 0.5, 0.4);
+        mVAdjustment = new Adjustment(0.0, 0.0, 1.0, 0.2, 0.5, 0.5);
         mVAdjustment.addOnValueChanged(&onValueChanged);
         mVScrollbar = new VScrollbar(mVAdjustment);
         attach(mVScrollbar,
@@ -121,17 +108,17 @@
                0, 0);
     }
 
-    override void rel_zoom(Point screen_datum, double factor) {
+    override void rel_zoom(Point2 screen_datum, double factor) {
         // Work out pixel distance from current centre to datum,
         // Do the zoom, then work out the new centre that keeps the
         // pixel distance the same
 
-        Point old_model_datum = screen_to_model(screen_datum);
-        Vector pixel_distance = model_to_screen(old_model_datum - mViewCentre);
+        Point2 old_model_datum = screen_to_model(screen_datum);
+        Vector2 pixel_distance = model_to_screen(old_model_datum - mViewCentre);
         mZoom = clamp_zoom(factor * mZoom);
         mViewCentre = old_model_datum - screen_to_model(pixel_distance);
 
-        Point new_model_datum = screen_to_model(screen_datum);
+        Point2 new_model_datum = screen_to_model(screen_datum);
 
         update_adjustments();
         //update_rulers(new_model_datum);
@@ -139,7 +126,7 @@
         queueDraw();
     }
 
-    override void rel_pan(Vector screen_displacement) {
+    override void rel_pan(Vector2 screen_displacement) {
         mViewCentre = mViewCentre + screen_to_model(screen_displacement);
 
         update_adjustments();
@@ -157,12 +144,12 @@
         bool onConfigure(GdkEventConfigure * event, Widget widget) {
             assert(widget is mDrawingArea);
 
-            mViewSize = new Vector(cast(double)event.width, cast(double)event.height);
+            mViewSize = Vector2(cast(double)event.width, cast(double)event.height);
             update_adjustments();
             update_rulers();
 
 
-            return 1;
+            return true;
         }
 
         bool onExpose(GdkEventExpose * event, Widget widget) {
@@ -194,8 +181,8 @@
             {
                 // Make the paper white, with a border
 
-                Point screen_page_left_bottom = model_to_screen(mPageLeftBottom);
-                Point screen_page_right_top = model_to_screen(mPageRightTop);
+                Point2 screen_page_left_bottom = model_to_screen(mPageLeftBottom);
+                Point2 screen_page_right_top = model_to_screen(mPageRightTop);
 
                 cr.setSourceRgba(1.0, 1.0, 1.0, 1.0);
                 rectangle(cr, screen_page_left_bottom, screen_page_right_top);
@@ -206,15 +193,15 @@
                 cr.stroke();
             }
 
-            return 1;
+            return true;
         }
 
         bool onButtonEvent(GdkEventButton * event, Widget widget) {
             assert(widget is mDrawingArea);
             //writefln("Got button event\n");
 
-            Point screen_point = new Point(event.x + 0.5, event.y + 0.5);
-            Point model_point = screen_to_model(screen_point);
+            Point2 screen_point = Point2(event.x + 0.5, event.y + 0.5);
+            Point2 model_point = screen_to_model(screen_point);
 
             auto button_event = new ButtonEvent(gtk2tk_click(event.type),
                                                 gtk2tk_button(event.button),
@@ -224,7 +211,7 @@
 
             //mEventHandle.handle_button_press
 
-            return 1;
+            return true;
         }
 
         bool onKeyEvent(GdkEventKey * event, Widget widget) {
@@ -234,7 +221,7 @@
             //auto key_event = new KeyEvent("",
             // mEventHandle.handle_key(key_event);
 
-            return 1;
+            return true;
         }
 
         bool onMotionNotify(GdkEventMotion * event, Widget widget) {
@@ -243,8 +230,8 @@
             gtk_widget_event(mHRuler.getWidgetStruct(), cast(GdkEvent *)event);
             gtk_widget_event(mVRuler.getWidgetStruct(), cast(GdkEvent *)event);
 
-            Point screen_point = new Point(event.x + 0.5, event.y + 0.5);
-            Point model_point = screen_to_model(screen_point);
+            Point2 screen_point = Point2(event.x + 0.5, event.y + 0.5);
+            Point2 model_point = screen_to_model(screen_point);
 
             auto motion_event = new MotionEvent(screen_point,
                                                 model_point,
@@ -252,15 +239,15 @@
 
             mEventHandler.handle_motion(this, motion_event);
 
-            return 1;
+            return true;
         }
 
         bool onScroll(GdkEventScroll * event, Widget widget) {
             assert(widget is mDrawingArea);
             //writefln("Got scroll\n");
 
-            Point screen_point = new Point(event.x + 0.5, event.y + 0.5);
-            Point model_point = screen_to_model(screen_point);
+            Point2 screen_point = Point2(event.x + 0.5, event.y + 0.5);
+            Point2 model_point = screen_to_model(screen_point);
 
             auto scroll_event = new ScrollEvent(gtk2tk_direction(event.direction),
                                                 screen_point,
@@ -269,16 +256,17 @@
 
             mEventHandler.handle_scroll(this, scroll_event);
 
-            return 1;
+            return true;
         }
 
         void onValueChanged(Adjustment adjustment) {
             GtkAdjustment * h_gtkAdjustment = mHAdjustment.getAdjustmentStruct();
             GtkAdjustment * v_gtkAdjustment = mVAdjustment.getAdjustmentStruct();
 
-            Point view_left_bottom = new Point(h_gtkAdjustment.value, v_gtkAdjustment.value);
+            Point2 view_left_bottom = Point2(gtk_adjustment_get_value(h_gtkAdjustment),
+                                             gtk_adjustment_get_value(v_gtkAdjustment));
             writefln("%s", view_left_bottom);
-            Vector model_size = screen_to_model(mViewSize);
+            Vector2 model_size = screen_to_model(mViewSize);
             mViewCentre = view_left_bottom + model_size / 2.0;
 
             update_rulers();
@@ -287,10 +275,10 @@
         }
 
         void update_rulers() {
-            Vector model_size = screen_to_model(mViewSize);
+            Vector2 model_size = screen_to_model(mViewSize);
 
-            Point view_left_bottom = mViewCentre - model_size / 2.0;
-            Point view_right_top = mViewCentre + model_size / 2.0;
+            Point2 view_left_bottom = mViewCentre - model_size / 2.0;
+            Point2 view_right_top = mViewCentre + model_size / 2.0;
 
             mHRuler.setRange(view_left_bottom.x,
                              view_right_top.x,
@@ -303,36 +291,36 @@
         }
 
         void update_adjustments() {
-            Vector model_size = screen_to_model(mViewSize);
+            Vector2 model_size = screen_to_model(mViewSize);
 
-            Point view_left_bottom = mViewCentre - model_size / 2.0;
-            Point view_right_top = mViewCentre + model_size / 2.0;
+            Point2 view_left_bottom = mViewCentre - model_size / 2.0;
+            Point2 view_right_top = mViewCentre + model_size / 2.0;
 
             // Adjust the canvas size if necessary
             mCanvasLeftBottom = min_extents(mCanvasLeftBottom, view_left_bottom);
             mCanvasRightTop = max_extents(mCanvasRightTop, view_right_top);
 
-            Vector canvas_size = mCanvasRightTop - mCanvasLeftBottom;
-            Vector page_size = mPageRightTop - mPageLeftBottom;
+            Vector2 canvas_size = mCanvasRightTop - mCanvasLeftBottom;
+            Vector2 page_size = mPageRightTop - mPageLeftBottom;
 
             // Update the adjustments
 
             GtkAdjustment * h_gtkAdjustment = mHAdjustment.getAdjustmentStruct();
             GtkAdjustment * v_gtkAdjustment = mVAdjustment.getAdjustmentStruct();
 
-            h_gtkAdjustment.lower = mCanvasLeftBottom.x;
-            h_gtkAdjustment.upper = mCanvasRightTop.x;
-            h_gtkAdjustment.value = view_left_bottom.x;
-            h_gtkAdjustment.step_increment = canvas_size.x / 10.0;
-            h_gtkAdjustment.page_increment = canvas_size.x / 5.0;
-            h_gtkAdjustment.page_size = model_size.x;
+            gtk_adjustment_set_lower(h_gtkAdjustment, mCanvasLeftBottom.x);
+            gtk_adjustment_set_upper(h_gtkAdjustment, mCanvasRightTop.x);
+            gtk_adjustment_set_value(h_gtkAdjustment, view_left_bottom.x);
+            gtk_adjustment_set_step_increment(h_gtkAdjustment, canvas_size.x / 10.0);
+            gtk_adjustment_set_page_increment(h_gtkAdjustment, canvas_size.x / 5.0);
+            gtk_adjustment_set_page_size(h_gtkAdjustment, model_size.x);
 
-            v_gtkAdjustment.lower = mCanvasLeftBottom.y;
-            v_gtkAdjustment.upper = mCanvasRightTop.y;
-            v_gtkAdjustment.value = view_left_bottom.y;
-            v_gtkAdjustment.step_increment = canvas_size.y / 10.0;
-            v_gtkAdjustment.page_increment = canvas_size.y / 5.0;
-            v_gtkAdjustment.page_size = model_size.y;
+            gtk_adjustment_set_lower(v_gtkAdjustment, mCanvasLeftBottom.y);
+            gtk_adjustment_set_upper(v_gtkAdjustment, mCanvasRightTop.y);
+            gtk_adjustment_set_value(v_gtkAdjustment, view_left_bottom.y);
+            gtk_adjustment_set_step_increment(v_gtkAdjustment, canvas_size.y / 10.0);
+            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();
@@ -340,32 +328,32 @@
             mVAdjustment.valueChanged();
         }
 
-        Point model_to_screen(Point model) { return ORIGIN + mViewSize / 2.0 + mZoom * (model - mViewCentre); }
-        Point screen_to_model(Point screen) { return mViewCentre + (screen - mViewSize / 2.0 - ORIGIN) / mZoom; }
-        Vector model_to_screen(Vector model) { return mZoom * model; }
-        Vector screen_to_model(Vector screen) { return screen / mZoom; }
+        Point2 model_to_screen(Point2 model) { return ORIGIN + mViewSize / 2.0 + mZoom * (model - mViewCentre); }
+        Point2 screen_to_model(Point2 screen) { return mViewCentre + (screen - mViewSize / 2.0 - ORIGIN) / mZoom; }
+        Vector2 model_to_screen(Vector2 model) { return mZoom * model; }
+        Vector2 screen_to_model(Vector2 screen) { return screen / mZoom; }
         double model_to_screen(double model) { return mZoom * model; }
         double screen_to_model(double screen) { return screen / mZoom; }
 
         double clamp_zoom(double zoom) { return clamp(zoom, 0.1, 10.0); }
 
-        static const Point ORIGIN;
-        static const Vector INITIAL_PAGE_SIZE;
+        static const Point2 ORIGIN;
+        static const Vector2 INITIAL_PAGE_SIZE;
 
         ICanvasEventHandler mEventHandler;
 
         // Model units are in millimetres
         // Screen units are in pixels
 
-        double mZoom;               // pixels-per-mm
-        Point mViewCentre;          // model: where in the model is the centre of our view
+        double mZoom;                // pixels-per-mm
+        Point2 mViewCentre;          // model: where in the model is the centre of our view
 
-        Point mCanvasLeftBottom;    // model: bottom left corner of canvas
-        Point mCanvasRightTop;      // model: top right corner of canvas
-        Point mPageLeftBottom;      // model: bottom left corner of page
-        Point mPageRightTop;        // model: top right corner of page
+        Point2 mCanvasLeftBottom;    // model: bottom left corner of canvas
+        Point2 mCanvasRightTop;      // model: top right corner of canvas
+        Point2 mPageLeftBottom;      // model: bottom left corner of page
+        Point2 mPageRightTop;        // model: top right corner of page
 
-        Vector mViewSize;           // screen: size of view window in pixels
+        Vector2 mViewSize;           // screen: size of view window in pixels
 
         HRuler mHRuler;
         VRuler mVRuler;