--- a/build.sh	Sat Jul 11 23:32:22 2009 +0930
+++ b/build.sh	Sun Jul 12 00:39:35 2009 +0930
@@ -2,7 +2,7 @@
 
 dmd \
         -ofgui \
-        gui.d tool_stack.d tool.d icanvas.d canvas.d \
+        gui.d tool_layer.d tool.d icanvas.d canvas.d \
         tk/geometry.d tk/gtk_support.d tk/misc.d tk/types.d tk/events.d \
         cairo_support.d standard_tools.d \
         page_layer.d \

--- a/canvas.d	Sat Jul 11 23:32:22 2009 +0930
+++ b/canvas.d	Sun Jul 12 00:39:35 2009 +0930
@@ -86,7 +86,7 @@
 
         // value, lower, upper, step-inc, page-inc, page-size
         // Give the adjustments dummy values until we receive a configure
-        mHAdjustment = new Adjustment(0.25, 0.0, 1.0, 0.2, 0.5, 0.5);
+        mHAdjustment = new Adjustment(0.0, 0.0, 1.0, 0.2, 0.5, 0.5);
         mHAdjustment.addOnValueChanged(&onValueChanged);
         mHScrollbar = new HScrollbar(mHAdjustment);
         attach(mHScrollbar,
@@ -116,7 +116,7 @@
         mZoom = clamp_zoom(factor * mZoom);
         mViewCentre = old_model_datum - screen_to_model(pixel_distance);
 
-        Point new_model_datum = screen_to_model(screen_datum);
+        //Point new_model_datum = screen_to_model(screen_datum);
 
         update_adjustments();
         //update_rulers(new_model_datum);
@@ -169,28 +169,50 @@
             dr.getSize(width, height);
             //writefln("Got expose %dx%d\n", width, height);
 
-            scope cr = new Context(dr);
+            scope model_cr = new Context(dr);
+            scope screen_cr = new Context(dr);
+
             Rectangle damage =
                 event is null ?
                 Rectangle(Point(0.0, 0.0), Vector(cast(double)width, cast(double)height)) :
                 Rectangle(Point(cast(double)event.area.x, cast(double)event.area.y),
                           Vector(cast(double)event.area.width, cast(double)event.area.height));
 
-            cr.save(); {
-                rectangle(cr, damage);
-                cr.clip();
+            model_cr.save(); screen_cr.save(); {
+                // Setup model context
+
+                rectangle(model_cr, damage);
+                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);
 
-                cr.save(); {
+                // Setup screen context
+
+                rectangle(screen_cr, damage);
+                screen_cr.clip();
+
+                // Fill the background
+
+                screen_cr.save(); {
                     // Make the window light grey
-                    cr.setSourceRgba(1.0, 1.0, 1.0, 0.7);
-                    rectangle(cr, damage);
-                    cr.fill();
-                } cr.restore();
+                    screen_cr.setSourceRgba(1.0, 1.0, 1.0, 0.7);
+                    rectangle(screen_cr, damage);
+                    screen_cr.fill();
+                } screen_cr.restore();
+
+                // Draw each layer
 
                 foreach(ref layer; mLayers) {
-                    layer.draw(this, damage, cr);
+                    model_cr.save(); screen_cr.save(); {
+                        layer.draw(this, damage, model_cr, screen_cr);
+                    } screen_cr.restore(); model_cr.restore();
                 }
-            } cr.restore();
+            } screen_cr.restore(); model_cr.restore();
 
             return true;
         }
@@ -297,10 +319,15 @@
             Point view_left_bottom = mViewCentre - model_size / 2.0;
             Point view_right_top = mViewCentre + model_size / 2.0;
 
+            double lower, upper, position, max_size;
+
+            mHRuler.getRange(lower, upper, position, max_size);
             mHRuler.setRange(view_left_bottom.x,
                              view_right_top.x,
-                             0.0,       // TODO preserve the value
+                             position,
                              mZoom * 2000.0);
+
+            mVRuler.getRange(lower, upper, position, max_size);
             mVRuler.setRange(view_right_top.y,
                              view_left_bottom.y,
                              0.0,
@@ -318,7 +345,6 @@
             mCanvasRightTop = max_extents(mCanvasRightTop, view_right_top);
 
             Vector canvas_size = mCanvasRightTop - mCanvasLeftBottom;
-            Vector page_size = mPageRightTop - mPageLeftBottom;
 
             // Update the adjustments
 
@@ -357,8 +383,6 @@
 
         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
 
         Vector mViewSize;           // screen: size of view window in pixels
 

--- a/grid_layer.d	Sat Jul 11 23:32:22 2009 +0930
+++ b/grid_layer.d	Sun Jul 12 00:39:35 2009 +0930
@@ -13,7 +13,8 @@
         return Rectangle();
     }
 
-    override void draw(const Viewport viewport, in Rectangle damage, Context cr) const {
+    override void draw(const Viewport viewport, in Rectangle damage,
+                       Context model_cr, Context screen_cr) const {
         double zoom = viewport.zoom;
 
         double start_x = modf(damage.min_corner.x, zoom);

--- a/gui.d	Sat Jul 11 23:32:22 2009 +0930
+++ b/gui.d	Sun Jul 12 00:39:35 2009 +0930
@@ -2,7 +2,7 @@
 
 import icanvas;
 import canvas;
-import tool_stack;
+import tool_layer;
 import tool;
 import standard_tools;
 import page_layer;
@@ -23,10 +23,11 @@
     Tool[] tools;
     tools ~= new PanTool;
     tools ~= new ZoomTool;
-    auto event_handler = new ToolStack(tools);
+    auto tool_layer = new ToolLayer(tools, "Tools");
     Layer[] layers;
-    layers ~= new PageLayer;
-    auto canvas = new Canvas(layers, event_handler, 120.0);
+    layers ~= new PageLayer("Page");
+    layers ~= tool_layer;
+    auto canvas = new Canvas(layers, tool_layer, 120.0);
     window.add(canvas);
     window.setDefaultSize(420, 340);
     window.showAll();

--- a/icanvas.d	Sat Jul 11 23:32:22 2009 +0930
+++ b/icanvas.d	Sun Jul 12 00:39:35 2009 +0930
@@ -35,7 +35,17 @@
 }
 
 abstract class Layer {
+    this(in string name) {
+        mName = name;
+    }
+
+    string name() const { return mName; }
+
     Rectangle bounds() const;
     //void zoom_changed
-    void draw(const Viewport viewport, in Rectangle damage, Context cr) const;
+    void draw(const Viewport viewport, in Rectangle damage, Context model_cr, Context screen_cr) const;
+
+    private {
+        invariant string mName;
+    }
 }

--- a/page_layer.d	Sat Jul 11 23:32:22 2009 +0930
+++ b/page_layer.d	Sun Jul 12 00:39:35 2009 +0930
@@ -7,7 +7,8 @@
 }
 
 class PageLayer : Layer, Page {
-    this() {
+    this(in string name) {
+        super(name);
         mPageGeometry = Rectangle(Point.DEFAULT,
                                   Vector(210.0, 297.0));
     }
@@ -16,16 +17,29 @@
         return mPageGeometry;
     }
 
-    override void draw(const Viewport viewport, in Rectangle damage, Context cr) const {
+    override void draw(const Viewport viewport, in Rectangle damage,
+                       Context model_cr, Context screen_cr) const {
         // Make the paper white, with a border
 
-        cr.setSourceRgba(1.0, 1.0, 1.0, 1.0);
-        rectangle(cr, viewport.model_to_screen(mPageGeometry));
-        cr.fill();
+        /*
+        model_cr.setSourceRgba(1.0, 1.0, 1.0, 1.0);
+        rectangle(model_cr, mPageGeometry);
+        model_cr.fill();
 
-        cr.setSourceRgba(0.0, 0.0, 0.0, 1.0);
-        rectangle(cr, viewport.model_to_screen(mPageGeometry));
-        cr.stroke();
+        model_cr.setSourceRgba(0.0, 0.0, 0.0, 1.0);
+        rectangle(model_cr, mPageGeometry);
+        rectangle(model_cr, Rectangle(mPageGeometry.position, mPageGeometry.size / 2.0));
+        model_cr.stroke();
+        */
+
+        screen_cr.setSourceRgba(1.0, 1.0, 1.0, 1.0);
+        rectangle(screen_cr, viewport.model_to_screen(mPageGeometry));
+        screen_cr.fill();
+
+        screen_cr.setSourceRgba(0.0, 0.0, 0.0, 1.0);
+        rectangle(screen_cr, viewport.model_to_screen(mPageGeometry));
+        rectangle(screen_cr, viewport.model_to_screen(Rectangle(mPageGeometry.position, mPageGeometry.size / 2.0)));
+        screen_cr.stroke();
     }
 
     private {

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/tool_layer.d	Sun Jul 12 00:39:35 2009 +0930
@@ -0,0 +1,120 @@
+module tool_layer;
+
+import std.stdio;
+
+import cairo.Context;
+import cairo_support;
+import tool;
+private import icanvas;
+private import tk.types;
+private import tk.geometry;
+private import tk.events;
+
+class ToolLayer : Layer, EventHandler {
+    this(in Tool[] tools, in string name) {
+        super(name);
+        mTools = tools.dup;
+    }
+
+    override bool handle_button_press(Viewport viewport, in ButtonEvent event) {
+        writefln("%s", event);
+
+        if (mGrabbedTool is null) {
+            foreach_reverse(ref tool; mTools) {
+                if (tool.handle_button_press(viewport, event)) {
+                    mGrabbedTool = &tool;
+                    mGrabbedButton = event.button_name;
+                    break;
+                }
+            }
+        }
+        else {
+            mGrabbedTool.handle_button_press(viewport, event);
+        }
+
+        return true;
+    }
+
+    override bool handle_button_release(Viewport viewport, in ButtonEvent event) {
+        writefln("%s", event);
+
+        if (mGrabbedTool !is null) {
+            mGrabbedTool.handle_button_release(viewport, event);
+
+            if (mGrabbedButton == event.button_name) {
+                mGrabbedTool = null;
+            }
+        }
+
+        return true;
+    }
+
+    override bool handle_key_press(Viewport viewport, in KeyEvent event) {
+        writefln("%s", event);
+        return true;
+    }
+
+    override bool handle_key_release(Viewport viewport, in KeyEvent event) {
+        writefln("%s", event);
+        return true;
+    }
+
+    override bool handle_motion(Viewport viewport, in MotionEvent event) {
+        writefln("%s", event);
+
+        if (mGrabbedTool is null) {
+            foreach_reverse(ref tool; mTools) {
+                if (tool.handle_motion(viewport, event)) {
+                    break;
+                }
+            }
+        }
+        else {
+            mGrabbedTool.handle_motion(viewport, event);
+        }
+
+        return true;
+    }
+
+    override bool handle_scroll(Viewport viewport, in ScrollEvent event) {
+        writefln("%s", event);
+
+        if (mGrabbedTool is null) {
+            foreach_reverse(ref tool; mTools) {
+                if (tool.handle_scroll(viewport, event)) {
+                    break;
+                }
+            }
+        }
+        else {
+            mGrabbedTool.handle_scroll(viewport, event);
+        }
+
+        return true;
+    }
+
+    override Rectangle bounds() const {
+        return Rectangle();
+    }
+
+    override void draw(const Viewport viewport, in Rectangle damage,
+                       Context model_cr, Context screen_cr) const {
+    }
+
+    /*
+    override void push(Tool tool) {
+    }
+
+    override void pop() {
+    }
+
+    override void replace(Tool tool) {
+    }
+    */
+
+    private {
+        Tool[] mTools;
+        Tool * mGrabbedTool;
+        ButtonName mGrabbedButton;
+    }
+}

--- a/tool_stack.d	Sat Jul 11 23:32:22 2009 +0930
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,109 +0,0 @@
-module tool_stack;
-
-import std.stdio;
-
-import tool;
-private import icanvas;
-private import tk.types;
-private import tk.geometry;
-private import tk.events;
-
-class ToolStack : EventHandler {
-    this(in Tool[] tools) {
-        mTools = tools.dup;
-    }
-
-    override bool handle_button_press(Viewport viewport, in ButtonEvent event) {
-        writefln("%s", event);
-
-        if (mGrabbedTool is null) {
-            foreach_reverse(ref tool; mTools) {
-                if (tool.handle_button_press(viewport, event)) {
-                    mGrabbedTool = &tool;
-                    mGrabbedButton = event.button_name;
-                    break;
-                }
-            }
-        }
-        else {
-            mGrabbedTool.handle_button_press(viewport, event);
-        }
-
-        return true;
-    }
-
-    override bool handle_button_release(Viewport viewport, in ButtonEvent event) {
-        writefln("%s", event);
-
-        if (mGrabbedTool !is null) {
-            mGrabbedTool.handle_button_release(viewport, event);
-
-            if (mGrabbedButton == event.button_name) {
-                mGrabbedTool = null;
-            }
-        }
-
-        return true;
-    }
-
-    override bool handle_key_press(Viewport viewport, in KeyEvent event) {
-        writefln("%s", event);
-        return true;
-    }
-
-    override bool handle_key_release(Viewport viewport, in KeyEvent event) {
-        writefln("%s", event);
-        return true;
-    }
-
-    override bool handle_motion(Viewport viewport, in MotionEvent event) {
-        writefln("%s", event);
-
-        if (mGrabbedTool is null) {
-            foreach_reverse(ref tool; mTools) {
-                if (tool.handle_motion(viewport, event)) {
-                    break;
-                }
-            }
-        }
-        else {
-            mGrabbedTool.handle_motion(viewport, event);
-        }
-
-        return true;
-    }
-
-    override bool handle_scroll(Viewport viewport, in ScrollEvent event) {
-        writefln("%s", event);
-
-        if (mGrabbedTool is null) {
-            foreach_reverse(ref tool; mTools) {
-                if (tool.handle_scroll(viewport, event)) {
-                    break;
-                }
-            }
-        }
-        else {
-            mGrabbedTool.handle_scroll(viewport, event);
-        }
-
-        return true;
-    }
-
-    /*
-    override void push(Tool tool) {
-    }
-
-    override void pop() {
-    }
-
-    override void replace(Tool tool) {
-    }
-    */
-
-    private {
-        Tool[] mTools;
-        Tool * mGrabbedTool;
-        ButtonName mGrabbedButton;
-    }
-}