--- a/doodle/gtk/canvas.d	Tue Aug 03 16:57:06 2010 +0930
+++ b/doodle/gtk/canvas.d	Tue Aug 03 17:37:21 2010 +0930
@@ -36,10 +36,10 @@
 //
 // Model units are millimetres.
 //
-// mZoom         -> pixels-per-model-unit
-// mViewSize     -> size of view window in pixels
-// mViewCentre   -> location in model corresponding to centre of view
-// mCanvasBounds -> size of the virtual canvas in model coordinates
+// _zoom         -> pixels-per-model-unit
+// _viewSize     -> size of view window in pixels
+// _viewCentre   -> location in model corresponding to centre of view
+// _canvasBounds -> size of the virtual canvas in model coordinates
 //
 // User operations:
 //   pan (middle click and drag)
@@ -47,57 +47,57 @@
 //   resize the widget
 
 class Canvas : Table, Viewport {
-    this(in Layer[] layers, EventHandler event_handler, Grid grid, in double ppi) {
+    this(in Layer[] layers, EventHandler eventHandler, Grid grid, in double ppi) {
         super(3, 3, 0);
 
-        mDamage = Rectangle.DEFAULT;
+        _damage = Rectangle.DEFAULT;
 
-        mLayers = layers.dup;
-        mEventHandler = event_handler;
-        mGrid = grid;
-        mPPI = ppi;
+        _layers = layers.dup;
+        _eventHandler = eventHandler;
+        _grid = grid;
+        _ppi = ppi;
 
         /*
-        writefln("Layer bounds: %s", layer_bounds);
-        writefln("Canvas bounds: %s", mCanvasBounds);
-        writefln("View centre: %s", mViewCentre);
-        */
+           writefln("Layer bounds: %s", layerBounds);
+           writefln("Canvas bounds: %s", _canvasBounds);
+           writefln("View centre: %s", _viewCentre);
+         */
 
         // Create our child widgets and register callbacks
 
         info("B1");
-        mHRuler = new HRuler;
-        attach(mHRuler,
+        _hRuler = new HRuler;
+        attach(_hRuler,
                1, 2,
                0, 1,
                AttachOptions.FILL | AttachOptions.EXPAND, AttachOptions.SHRINK,
                0, 0);
-        mHRuler.setMetric(MetricType.PIXELS);
+        _hRuler.setMetric(MetricType.PIXELS);
 
         info("B2");
-        mVRuler = new VRuler;
-        attach(mVRuler,
+        _vRuler = new VRuler;
+        attach(_vRuler,
                0, 1,
                1, 2,
                AttachOptions.SHRINK, AttachOptions.FILL | AttachOptions.EXPAND,
                0, 0);
         info("B3");
-        mVRuler.setMetric(MetricType.PIXELS);
+        _vRuler.setMetric(MetricType.PIXELS);
         info("J");
 
-        mDrawingArea = new DrawingArea;
-        mDrawingArea.addOnRealize(&on_realize);
-        mDrawingArea.addOnConfigure(&on_configure);
-        mDrawingArea.addOnExpose(&on_expose);
-        mDrawingArea.addOnButtonPress(&on_button_press);
-        mDrawingArea.addOnButtonRelease(&on_button_release);
-        mDrawingArea.addOnKeyPress(&on_key_event);
-        mDrawingArea.addOnKeyRelease(&on_key_event);
-        mDrawingArea.addOnMotionNotify(&on_motion_notify);
-        mDrawingArea.addOnScroll(&on_scroll);
-        mDrawingArea.addOnEnterNotify(&on_enter_notify);
-        mDrawingArea.addOnLeaveNotify(&on_leave_notify);
-        mDrawingArea.setEvents(EventMask.EXPOSURE_MASK |
+        _drawingArea = new DrawingArea;
+        _drawingArea.addOnRealize(&onRealize);
+        _drawingArea.addOnConfigure(&onConfigure);
+        _drawingArea.addOnExpose(&onExpose);
+        _drawingArea.addOnButtonPress(&onButtonPress);
+        _drawingArea.addOnButtonRelease(&onButtonRelease);
+        _drawingArea.addOnKeyPress(&onKeyEvent);
+        _drawingArea.addOnKeyRelease(&onKeyEvent);
+        _drawingArea.addOnMotionNotify(&onMotionNotify);
+        _drawingArea.addOnScroll(&onScroll);
+        _drawingArea.addOnEnterNotify(&onEnterNotify);
+        _drawingArea.addOnLeaveNotify(&onLeaveNotify);
+        _drawingArea.setEvents(EventMask.EXPOSURE_MASK |
                                EventMask.POINTER_MOTION_MASK |
                                EventMask.POINTER_MOTION_HINT_MASK |
                                EventMask.BUTTON_MOTION_MASK |
@@ -111,7 +111,7 @@
                                EventMask.SCROLL_MASK);
         info("M");
 
-        attach(mDrawingArea,
+        attach(_drawingArea,
                1, 2,
                1, 2, 
                AttachOptions.FILL | AttachOptions.EXPAND, AttachOptions.FILL | AttachOptions.EXPAND,
@@ -119,22 +119,22 @@
 
         // 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, 0.5);
-        mHAdjustment.addOnValueChanged(&onValueChanged);
-        mHScrollbar = new HScrollbar(mHAdjustment);
-        mHScrollbar.setInverted(false);
-        attach(mHScrollbar,
+        _hAdjustment = new Adjustment(0.0, 0.0, 1.0, 0.2, 0.5, 0.5);
+        _hAdjustment.addOnValueChanged(&onValueChanged);
+        _hScrollbar = new HScrollbar(_hAdjustment);
+        _hScrollbar.setInverted(false);
+        attach(_hScrollbar,
                1, 2,
                2, 3,
                AttachOptions.FILL | AttachOptions.EXPAND, AttachOptions.SHRINK,
                0, 0);
         info("Q");
 
-        mVAdjustment = new Adjustment(0.0, 0.0, 1.0, 0.2, 0.5, 0.5);
-        mVAdjustment.addOnValueChanged(&onValueChanged);
-        mVScrollbar = new VScrollbar(mVAdjustment);
-        mVScrollbar.setInverted(true);
-        attach(mVScrollbar,
+        _vAdjustment = new Adjustment(0.0, 0.0, 1.0, 0.2, 0.5, 0.5);
+        _vAdjustment.addOnValueChanged(&onValueChanged);
+        _vScrollbar = new VScrollbar(_vAdjustment);
+        _vScrollbar.setInverted(true);
+        attach(_vScrollbar,
                2, 3,
                1, 2,
                AttachOptions.SHRINK,
@@ -142,31 +142,31 @@
                0, 0);
     }
 
-    override void zoom_relative(in Point pixel_datum, in double factor) {
+    override void zoomRelative(in Point pixelDatum, in 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 = pixel_to_model(pixel_datum);
-        Vector pixel_distance = model_to_pixel(old_model_datum - mViewCentre);
-        mZoom = clamp_zoom(factor * mZoom);
-        mViewCentre = old_model_datum - pixel_to_model(pixel_distance);
+        Point oldModelDatum = pixelToModel(pixelDatum);
+        Vector pixelDistance = modelToPixel(oldModelDatum - _viewCentre);
+        _zoom = clampZoom(factor * _zoom);
+        _viewCentre = oldModelDatum - pixelToModel(pixelDistance);
 
-        update_adjustments;
-        update_rulers;
-        mGrid.zoom_changed(mZoom);
+        updateAdjustments;
+        updateRulers;
+        _grid.zoomChanged(_zoom);
         queueDraw;
     }
 
-    override void pan_relative(in Vector pixel_displacement) {
-        mViewCentre = mViewCentre + pixel_to_model(pixel_displacement);
+    override void panRelative(in Vector pixelDisplacement) {
+        _viewCentre = _viewCentre + pixelToModel(pixelDisplacement);
 
-        update_adjustments;
-        update_rulers;
+        updateAdjustments;
+        updateRulers;
         queueDraw;
     }
 
-    override void set_cursor(in Cursor cursor) {
+    override void setCursor(in Cursor cursor) {
         CursorType cursor_type;
 
         switch (cursor) {
@@ -183,15 +183,15 @@
             assert(0);
         }
 
-        mDrawingArea.setCursor(new gdk.Cursor.Cursor(cursor_type));
+        _drawingArea.setCursor(new gdk.Cursor.Cursor(cursor_type));
     }
 
-    override void damage_model(in Rectangle area) {
-        mDamage = mDamage | model_to_pixel(area);
+    override void damageModel(in Rectangle area) {
+        _damage = _damage | modelToPixel(area);
     }
 
-    override void damage_pixel(in Rectangle area) {
-        mDamage = mDamage | area;
+    override void damagePixel(in Rectangle area) {
+        _damage = _damage | area;
     }
 
     private {
@@ -200,389 +200,389 @@
         }
 
 
-        bool on_configure(GdkEventConfigure * event, Widget widget) {
-            assert(widget is mDrawingArea);
+        bool onConfigure(GdkEventConfigure * event, Widget widget) {
+            assert(widget is _drawingArea);
 
-            mViewSize = Vector(cast(double)event.width, cast(double)event.height);
+            _viewSize = Vector(cast(double)event.width, cast(double)event.height);
 
-            Rectangle layer_bounds = Rectangle.DEFAULT;
+            Rectangle layerBounds = Rectangle.DEFAULT;
 
-            foreach (ref layer; mLayers) {
-                layer_bounds = layer_bounds | layer.bounds;
+            foreach (ref layer; _layers) {
+                layerBounds = layerBounds | layer.bounds;
             }
 
-            assert(layer_bounds.valid);
+            assert(layerBounds.valid);
 
-            Rectangle padded_layer_bounds = expand(move(layer_bounds, - layer_bounds.size), 2.0 * layer_bounds.size);
+            Rectangle paddedLayerBounds = expand(move(layerBounds, - layerBounds.size), 2.0 * layerBounds.size);
 
-            if (!mHadConfigure) {
+            if (!_hadConfigure) {
                 info("1");
                 const double MM_PER_INCH = 25.4;
-                mZoom = 0.25 * mPPI / MM_PER_INCH;
+                _zoom = 0.25 * _ppi / MM_PER_INCH;
 
-                mCanvasBounds = padded_layer_bounds;
-                mViewCentre = mCanvasBounds.centre;
+                _canvasBounds = paddedLayerBounds;
+                _viewCentre = _canvasBounds.centre;
 
-                mGrid.zoom_changed(mZoom);
+                _grid.zoomChanged(_zoom);
 
-                mHadConfigure = true;
+                _hadConfigure = true;
             }
             else {
                 // Use configure events as an opportunity
                 // to consolidate the canvas-bounds
                 // XXX nasty code.
-                Vector z = mViewSize / mZoom;
-                Rectangle r = Rectangle(mViewCentre - z / 2.0, z);
-                mCanvasBounds = r | padded_layer_bounds;
+                Vector z = _viewSize / _zoom;
+                Rectangle r = Rectangle(_viewCentre - z / 2.0, z);
+                _canvasBounds = r | paddedLayerBounds;
             }
 
-            update_adjustments;
-            update_rulers;
+            updateAdjustments;
+            updateRulers;
 
-            //writefln("Canvas bounds: %s", mCanvasBounds);
-            //writefln("View centre: %s", mViewCentre);
+            //writefln("Canvas bounds: %s", _canvasBounds);
+            //writefln("View centre: %s", _viewCentre);
 
             return true;
         }
 
-        bool on_expose(GdkEventExpose * event, Widget widget) {
-            assert(widget is mDrawingArea);
+        bool onExpose(GdkEventExpose * event, Widget widget) {
+            assert(widget is _drawingArea);
 
-            Drawable dr = mDrawingArea.getWindow;
+            Drawable dr = _drawingArea.getWindow;
 
             int width, height;
             dr.getSize(width, height);
             //writefln("Got expose %dx%d\n", width, height);
 
-            scope model_cr = new Context(dr);
-            scope pixel_cr = new Context(dr);
+            scope modelCr = new Context(dr);
+            scope pixelCr = new Context(dr);
 
             Rectangle pixel_damage =
                 event is null ?
-                Rectangle(Point(0.0, 0.0), mViewSize) :
-                Rectangle(Point(cast(double)event.area.x, mViewSize.y - cast(double)(event.area.y + event.area.height)),
+                Rectangle(Point(0.0, 0.0), _viewSize) :
+                Rectangle(Point(cast(double)event.area.x, _viewSize.y - cast(double)(event.area.y + event.area.height)),
                           Vector(cast(double)event.area.width, cast(double)event.area.height));
 
-            Rectangle model_damage = pixel_to_model(pixel_damage);
+            Rectangle model_damage = pixelToModel(pixel_damage);
 
             //writefln("Pixel damage: %s, model damage: %s", pixel_damage, model_damage);
 
-            model_cr.save; pixel_cr.save; {
+            modelCr.save; pixelCr.save; {
                 // Setup model context and clip
 
-                GtkAdjustment * h_gtkAdjustment = mHAdjustment.getAdjustmentStruct;
-                GtkAdjustment * v_gtkAdjustment = mVAdjustment.getAdjustmentStruct;
+                GtkAdjustment * h_gtkAdjustment = _hAdjustment.getAdjustmentStruct;
+                GtkAdjustment * v_gtkAdjustment = _vAdjustment.getAdjustmentStruct;
 
-                model_cr.scale(mZoom, -mZoom);
-                model_cr.translate(-gtk_adjustment_get_value(h_gtkAdjustment),
-                                   -gtk_adjustment_get_value(v_gtkAdjustment) - gtk_adjustment_get_page_size(v_gtkAdjustment));
+                modelCr.scale(_zoom, -_zoom);
+                modelCr.translate(-gtk_adjustment_get_value(h_gtkAdjustment),
+                                  -gtk_adjustment_get_value(v_gtkAdjustment) - gtk_adjustment_get_page_size(v_gtkAdjustment));
 
-                rectangle(model_cr, model_damage);
-                model_cr.clip;
+                rectangle(modelCr, model_damage);
+                modelCr.clip;
 
                 // Setup pixel context and clip
 
-                pixel_cr.translate(0.0, mViewSize.y);
-                pixel_cr.scale(1.0, -1.0);
+                pixelCr.translate(0.0, _viewSize.y);
+                pixelCr.scale(1.0, -1.0);
 
-                rectangle(pixel_cr, pixel_damage);
-                pixel_cr.clip;
+                rectangle(pixelCr, pixel_damage);
+                pixelCr.clip;
 
                 // Fill the background
 
-                pixel_cr.save; {
+                pixelCr.save; {
                     // Make the window light grey
-                    pixel_cr.setSourceRgba(0.9, 0.9, 0.9, 1.0);
-                    rectangle(pixel_cr, pixel_damage);
-                    pixel_cr.fill;
-                } pixel_cr.restore;
+                    pixelCr.setSourceRgba(0.9, 0.9, 0.9, 1.0);
+                    rectangle(pixelCr, pixel_damage);
+                    pixelCr.fill;
+                } pixelCr.restore;
 
                 // Draw each layer
 
-                foreach(ref layer; mLayers) {
-                    model_cr.save; pixel_cr.save; {
-                        layer.draw(this, pixel_damage, pixel_cr, model_damage, model_cr);
-                    } pixel_cr.restore; model_cr.restore;
+                foreach(ref layer; _layers) {
+                    modelCr.save; pixelCr.save; {
+                        layer.draw(this, pixel_damage, pixelCr, model_damage, modelCr);
+                    } pixelCr.restore; modelCr.restore;
                 }
-            } pixel_cr.restore; model_cr.restore;
+            } pixelCr.restore; modelCr.restore;
 
             return true;
         }
 
-        bool on_button_press(GdkEventButton * event, Widget widget) {
-            assert(widget is mDrawingArea);
+        bool onButtonPress(GdkEventButton * event, Widget widget) {
+            assert(widget is _drawingArea);
             //writefln("Got button event\n");
 
-            Point pixel_point = Point(event.x + 0.5, mViewSize.y - (event.y + 0.5));
-            Point model_point = pixel_to_model(pixel_point);
+            Point pixelPoint = Point(event.x + 0.5, _viewSize.y - (event.y + 0.5));
+            Point modelPoint = pixelToModel(pixelPoint);
 
-            auto button_event = new ButtonEvent(gtk2tk_button_action(event.type),
-                                                gtk2tk_button_name(event.button),
-                                                pixel_point,
-                                                model_point,
-                                                gtk2tk_mask(event.state));
+            auto buttonEvent = new ButtonEvent(gtk2tkButtonAction(event.type),
+                                               gtk2tkButtonName(event.button),
+                                               pixelPoint,
+                                               modelPoint,
+                                               gtk2tkMask(event.state));
 
-            mEventHandler.handle_button_press(this, button_event);
+            _eventHandler.handleButtonPress(this, buttonEvent);
 
-            fix_damage;
+            fixDamage;
 
             return true;
         }
 
-        bool on_button_release(GdkEventButton * event, Widget widget) {
-            assert(widget is mDrawingArea);
+        bool onButtonRelease(GdkEventButton * event, Widget widget) {
+            assert(widget is _drawingArea);
             //writefln("Got button event\n");
 
-            Point pixel_point = Point(event.x + 0.5, mViewSize.y - (event.y + 0.5));
-            Point model_point = pixel_to_model(pixel_point);
+            Point pixelPoint = Point(event.x + 0.5, _viewSize.y - (event.y + 0.5));
+            Point modelPoint = pixelToModel(pixelPoint);
 
-            auto button_event = new ButtonEvent(gtk2tk_button_action(event.type),
-                                                gtk2tk_button_name(event.button),
-                                                pixel_point,
-                                                model_point,
-                                                gtk2tk_mask(event.state));
+            auto buttonEvent = new ButtonEvent(gtk2tkButtonAction(event.type),
+                                               gtk2tkButtonName(event.button),
+                                               pixelPoint,
+                                               modelPoint,
+                                               gtk2tkMask(event.state));
 
-            mEventHandler.handle_button_release(this, button_event);
+            _eventHandler.handleButtonRelease(this, buttonEvent);
 
-            fix_damage;
+            fixDamage;
 
             return true;
         }
 
-        bool on_key_event(GdkEventKey * event, Widget widget) {
-            assert(widget is mDrawingArea);
+        bool onKeyEvent(GdkEventKey * event, Widget widget) {
+            assert(widget is _drawingArea);
             //writefln("Got key event\n");
 
             //auto key_event = new KeyEvent("",
             // mEventHandle.handle_key(key_event);
 
-            fix_damage;
+            fixDamage;
 
             return true;
         }
 
-        bool on_motion_notify(GdkEventMotion * event, Widget widget) {
-            assert(widget is mDrawingArea);
+        bool onMotionNotify(GdkEventMotion * event, Widget widget) {
+            assert(widget is _drawingArea);
             //writefln("Got motion notify\n");
-            gtk_widget_event(mHRuler.getWidgetStruct(), cast(GdkEvent *)event);
-            gtk_widget_event(mVRuler.getWidgetStruct(), cast(GdkEvent *)event);
+            gtk_widget_event(_hRuler.getWidgetStruct(), cast(GdkEvent *)event);
+            gtk_widget_event(_vRuler.getWidgetStruct(), cast(GdkEvent *)event);
 
-            Point pixel_point = Point(event.x + 0.5, mViewSize.y - (event.y + 0.5));
-            Point model_point = pixel_to_model(pixel_point);
+            Point pixelPoint = Point(event.x + 0.5, _viewSize.y - (event.y + 0.5));
+            Point modelPoint = pixelToModel(pixelPoint);
 
-            auto motion_event = new MotionEvent(pixel_point,
-                                                model_point,
-                                                gtk2tk_mask(event.state));
+            auto motion_event = new MotionEvent(pixelPoint,
+                                                modelPoint,
+                                                gtk2tkMask(event.state));
 
-            mEventHandler.handle_motion(this, motion_event);
+            _eventHandler.handleMotion(this, motion_event);
 
-            fix_damage;
+            fixDamage;
 
             return true;
         }
 
-        bool on_scroll(GdkEventScroll * event, Widget widget) {
-            assert(widget is mDrawingArea);
+        bool onScroll(GdkEventScroll * event, Widget widget) {
+            assert(widget is _drawingArea);
             //writefln("Got scroll\n");
 
-            Point pixel_point = Point(event.x + 0.5, mViewSize.y - (event.y + 0.5));
-            Point model_point = pixel_to_model(pixel_point);
+            Point pixelPoint = Point(event.x + 0.5, _viewSize.y - (event.y + 0.5));
+            Point modelPoint = pixelToModel(pixelPoint);
 
-            auto scroll_event = new ScrollEvent(gtk2tk_direction(event.direction),
-                                                pixel_point,
-                                                model_point,
-                                                gtk2tk_mask(event.state));
+            auto scroll_event = new ScrollEvent(gtk2tkDirection(event.direction),
+                                                pixelPoint,
+                                                modelPoint,
+                                                gtk2tkMask(event.state));
 
-            mEventHandler.handle_scroll(this, scroll_event);
+            _eventHandler.handleScroll(this, scroll_event);
 
-            fix_damage;
+            fixDamage;
 
             return true;
         }
 
         /*
-        public enum GdkCrossingMode {       
-            NORMAL,
-            GRAB,
-            UNGRAB,
-            GTK_GRAB,
-            GTK_UNGRAB,
-            STATE_CHANGED
-        }
+           public enum GdkCrossingMode {       
+           NORMAL,
+           GRAB,
+           UNGRAB,
+           GTK_GRAB,
+           GTK_UNGRAB,
+           STATE_CHANGED
+           }
 
-        public struct GdkEventCrossing {
-            GdkEventType type;
-            GdkWindow *window;
-            byte sendEvent;
-            GdkWindow *subwindow;
-            uint time;
-            double x;
-            double y;
-            double xRoot;
-            double yRoot;
-            GdkCrossingMode mode;
-            GdkNotifyType detail;
-            int focus;
-            uint state;
-        }
-        */
+           public struct GdkEventCrossing {
+           GdkEventType type;
+           GdkWindow *window;
+           byte sendEvent;
+           GdkWindow *subwindow;
+           uint time;
+           double x;
+           double y;
+           double xRoot;
+           double yRoot;
+           GdkCrossingMode mode;
+           GdkNotifyType detail;
+           int focus;
+           uint state;
+           }
+         */
 
-        bool on_enter_notify(GdkEventCrossing * event, Widget widget) {
-            assert(widget is mDrawingArea);
+        bool onEnterNotify(GdkEventCrossing * event, Widget widget) {
+            assert(widget is _drawingArea);
             //writefln("Enter %d %d %d", cast(int)event.mode, event.focus, event.state);
             // TODO
             return true;
         }
 
-        bool on_leave_notify(GdkEventCrossing * event, Widget widget) {
-            assert(widget is mDrawingArea);
+        bool onLeaveNotify(GdkEventCrossing * event, Widget widget) {
+            assert(widget is _drawingArea);
             //writefln("Leave %d %d %d", cast(int)event.mode, event.focus, event.state);
             // TODO
             return true;
         }
 
         void onValueChanged(Adjustment adjustment) {
-            GtkAdjustment * h_gtkAdjustment = mHAdjustment.getAdjustmentStruct;
-            GtkAdjustment * v_gtkAdjustment = mVAdjustment.getAdjustmentStruct;
+            GtkAdjustment * h_gtkAdjustment = _hAdjustment.getAdjustmentStruct;
+            GtkAdjustment * v_gtkAdjustment = _vAdjustment.getAdjustmentStruct;
 
-            Point view_left_top = Point(gtk_adjustment_get_value(h_gtkAdjustment),
-                                        gtk_adjustment_get_value(v_gtkAdjustment));
+            Point viewLeftTop = Point(gtk_adjustment_get_value(h_gtkAdjustment),
+                                      gtk_adjustment_get_value(v_gtkAdjustment));
 
-            Vector model_size = pixel_to_model(mViewSize);
+            Vector modelSize = pixelToModel(_viewSize);
 
-            //writefln("%s", view_left_bottom);
-            mViewCentre = view_left_top + model_size / 2.0;
-            //writefln("onValueChanged mViewCentre: %s", mViewCentre);
+            //writefln("%s", viewLeftBottom);
+            _viewCentre = viewLeftTop + modelSize / 2.0;
+            //writefln("onValueChanged _viewCentre: %s", _viewCentre);
 
-            update_rulers;
+            updateRulers;
 
             queueDraw;
         }
 
-        void update_rulers() {
-            invariant Vector model_size = pixel_to_model(mViewSize);
+        void updateRulers() {
+            invariant Vector modelSize = pixelToModel(_viewSize);
 
-            invariant Point view_left_bottom = mViewCentre - model_size / 2.0;
-            invariant Point view_right_top = mViewCentre + model_size / 2.0;
+            invariant Point viewLeftBottom = _viewCentre - modelSize / 2.0;
+            invariant Point viewRightTop = _viewCentre + modelSize / 2.0;
 
             // Define these just to obtain the position
             // below and we can preserve it
-            double lower, upper, position, max_size;
+            double lower, upper, position, maxSize;
 
-            mHRuler.getRange(lower, upper, position, max_size);
-            mHRuler.setRange(view_left_bottom.x,
-                             view_right_top.x,
+            _hRuler.getRange(lower, upper, position, maxSize);
+            _hRuler.setRange(viewLeftBottom.x,
+                             viewRightTop.x,
                              position,
-                             mZoom * 50.0);
+                             _zoom * 50.0);
 
-            mVRuler.getRange(lower, upper, position, max_size);
-            mVRuler.setRange(view_right_top.y,
-                             view_left_bottom.y,
+            _vRuler.getRange(lower, upper, position, maxSize);
+            _vRuler.setRange(viewRightTop.y,
+                             viewLeftBottom.y,
                              position,
-                             mZoom * 50.0);
+                             _zoom * 50.0);
         }
 
-        void update_adjustments() {
-            invariant Vector model_size = pixel_to_model(mViewSize);
+        void updateAdjustments() {
+            invariant Vector modelSize = pixelToModel(_viewSize);
 
-            invariant Point view_left_bottom = mViewCentre - model_size / 2.0;
-            invariant Point view_right_top = mViewCentre + model_size / 2.0;
+            invariant Point viewLeftBottom = _viewCentre - modelSize / 2.0;
+            invariant Point viewRightTop = _viewCentre + modelSize / 2.0;
 
             // Adjust the canvas size if necessary
-            mCanvasBounds = Rectangle(min_extents(mCanvasBounds.min_corner, view_left_bottom),
-                                      max_extents(mCanvasBounds.max_corner, view_right_top));
+            _canvasBounds = Rectangle(minExtents(_canvasBounds.minCorner, viewLeftBottom),
+                                      maxExtents(_canvasBounds.maxCorner, viewRightTop));
 
             // Update the adjustments
 
-            GtkAdjustment * h_gtkAdjustment = mHAdjustment.getAdjustmentStruct;
-            GtkAdjustment * v_gtkAdjustment = mVAdjustment.getAdjustmentStruct;
+            GtkAdjustment * h_gtkAdjustment = _hAdjustment.getAdjustmentStruct;
+            GtkAdjustment * v_gtkAdjustment = _vAdjustment.getAdjustmentStruct;
 
-            gtk_adjustment_set_lower(h_gtkAdjustment, mCanvasBounds.min_corner.x);
-            gtk_adjustment_set_upper(h_gtkAdjustment, mCanvasBounds.max_corner.x);
-            gtk_adjustment_set_value(h_gtkAdjustment, view_left_bottom.x);
-            gtk_adjustment_set_step_increment(h_gtkAdjustment, mCanvasBounds.size.x / 16.0);
-            gtk_adjustment_set_page_increment(h_gtkAdjustment, mCanvasBounds.size.x / 4.0);
-            gtk_adjustment_set_page_size(h_gtkAdjustment, model_size.x);
+            gtk_adjustment_set_lower(h_gtkAdjustment, _canvasBounds.minCorner.x);
+            gtk_adjustment_set_upper(h_gtkAdjustment, _canvasBounds.maxCorner.x);
+            gtk_adjustment_set_value(h_gtkAdjustment, viewLeftBottom.x);
+            gtk_adjustment_set_step_increment(h_gtkAdjustment, _canvasBounds.size.x / 16.0);
+            gtk_adjustment_set_page_increment(h_gtkAdjustment, _canvasBounds.size.x / 4.0);
+            gtk_adjustment_set_page_size(h_gtkAdjustment, modelSize.x);
 
-            gtk_adjustment_set_lower(v_gtkAdjustment, mCanvasBounds.min_corner.y);
-            gtk_adjustment_set_upper(v_gtkAdjustment, mCanvasBounds.max_corner.y);
-            gtk_adjustment_set_value(v_gtkAdjustment, view_left_bottom.y);
-            gtk_adjustment_set_step_increment(v_gtkAdjustment, mCanvasBounds.size.y / 16.0);
-            gtk_adjustment_set_page_increment(v_gtkAdjustment, mCanvasBounds.size.y / 4.0);
-            gtk_adjustment_set_page_size(v_gtkAdjustment, model_size.y);
+            gtk_adjustment_set_lower(v_gtkAdjustment, _canvasBounds.minCorner.y);
+            gtk_adjustment_set_upper(v_gtkAdjustment, _canvasBounds.maxCorner.y);
+            gtk_adjustment_set_value(v_gtkAdjustment, viewLeftBottom.y);
+            gtk_adjustment_set_step_increment(v_gtkAdjustment, _canvasBounds.size.y / 16.0);
+            gtk_adjustment_set_page_increment(v_gtkAdjustment, _canvasBounds.size.y / 4.0);
+            gtk_adjustment_set_page_size(v_gtkAdjustment, modelSize.y);
 
-            mHAdjustment.changed;
-            mHAdjustment.valueChanged;
-            mVAdjustment.changed;
-            mVAdjustment.valueChanged;
+            _hAdjustment.changed;
+            _hAdjustment.valueChanged;
+            _vAdjustment.changed;
+            _vAdjustment.valueChanged;
         }
 
-        void fix_damage() {
-            if (mDamage.valid) {
-                //writefln("Damage: %s", mDamage);
+        void fixDamage() {
+            if (_damage.valid) {
+                //writefln("Damage: %s", _damage);
                 int x, y, w, h;
-                mDamage.get_quantised(x, y, w, h);
-                mDrawingArea.queueDrawArea(x, cast(int)mViewSize.y - (y + h), w, h);
-                mDamage = Rectangle.DEFAULT;
+                _damage.getQuantised(x, y, w, h);
+                _drawingArea.queueDrawArea(x, cast(int)_viewSize.y - (y + h), w, h);
+                _damage = Rectangle.DEFAULT;
             }
             else {
                 //writefln("No damage");
             }
         }
 
-        double clamp_zoom(in double zoom) { return clamp(zoom, 0.2, 10.0); }
+        double clampZoom(in double zoom) { return clamp(zoom, 0.2, 10.0); }
 
-        Point model_to_pixel(in Point model) const {
-            return Point.DEFAULT + mViewSize / 2.0 + mZoom * (model - mViewCentre);
+        Point modelToPixel(in Point model) const {
+            return Point.DEFAULT + _viewSize / 2.0 + _zoom * (model - _viewCentre);
         }
 
-        Point pixel_to_model(in Point pixel) const {
-            return mViewCentre + (pixel - mViewSize / 2.0 - Point.DEFAULT) / mZoom;
+        Point pixelToModel(in Point pixel) const {
+            return _viewCentre + (pixel - _viewSize / 2.0 - Point.DEFAULT) / _zoom;
         }
 
-        Vector model_to_pixel(in Vector model) const {
-            return mZoom * model;
+        Vector modelToPixel(in Vector model) const {
+            return _zoom * model;
         }
 
-        Vector pixel_to_model(in Vector pixel) const {
-            return pixel / mZoom;
+        Vector pixelToModel(in Vector pixel) const {
+            return pixel / _zoom;
         }
 
-        Rectangle model_to_pixel(in Rectangle model) const {
-            return Rectangle(model_to_pixel(model.position), model_to_pixel(model.size));
+        Rectangle modelToPixel(in Rectangle model) const {
+            return Rectangle(modelToPixel(model.position), modelToPixel(model.size));
         }
 
-        Rectangle pixel_to_model(in Rectangle model) const {
-            return Rectangle(pixel_to_model(model.position), pixel_to_model(model.size));
+        Rectangle pixelToModel(in Rectangle model) const {
+            return Rectangle(pixelToModel(model.position), pixelToModel(model.size));
         }
 
-        void on_realize(Widget widget) {
-            assert(widget is mDrawingArea);
+        void onRealize(Widget widget) {
+            assert(widget is _drawingArea);
             //writefln("Got realize\n");
         }
 
-        bool mHadConfigure;
-        Rectangle mDamage;          // pixels
+        bool _hadConfigure;
+        Rectangle _damage;          // pixels
 
         // Model units are in millimetres
         // Screen units are in pixels
-        double mZoom;               // pixels-per-model-unit
-        Vector mViewSize;           // pixel: size of view window in pixels
-        Point mViewCentre;          // model: where in the model is the centre of our view
-        Rectangle mCanvasBounds;    // model:
+        double _zoom;               // pixels-per-model-unit
+        Vector _viewSize;           // pixel: size of view window in pixels
+        Point _viewCentre;          // model: where in the model is the centre of our view
+        Rectangle _canvasBounds;    // model:
 
         // Child widgets:
-        HRuler mHRuler;
-        VRuler mVRuler;
-        DrawingArea mDrawingArea;
-        Adjustment mHAdjustment;
-        HScrollbar mHScrollbar;
-        Adjustment mVAdjustment;
-        VScrollbar mVScrollbar;
+        HRuler _hRuler;
+        VRuler _vRuler;
+        DrawingArea _drawingArea;
+        Adjustment _hAdjustment;
+        HScrollbar _hScrollbar;
+        Adjustment _vAdjustment;
+        VScrollbar _vScrollbar;
 
-        Layer[] mLayers;
-        EventHandler mEventHandler;
-        Grid mGrid;
-        double mPPI;
+        Layer[] _layers;
+        EventHandler _eventHandler;
+        Grid _grid;
+        double _ppi;
     }
 }