Mercurial > projects > doodle

changeset 48:1b4c9ba58673

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Stylistic overhaul.
author daveb
date Tue, 03 Aug 2010 17:37:21 +0930
parents 14f1c051c35b
children 576b9fba4677 dfa1e219eafe
files doodle/core/logging.d doodle/dia/grid_layer.d doodle/dia/icanvas.d doodle/dia/page_layer.d doodle/dia/standard_tools.d doodle/dia/tool.d doodle/dia/tool_layer.d doodle/fig/fig.d doodle/fig/fig_layer.d doodle/gtk/canvas.d doodle/gtk/conversions.d doodle/gtk/toolbar.d doodle/main/prog/doodler.d doodle/tk/events.d doodle/tk/geometry.d doodle/tk/test/test1.d doodle/tk/types.d
diffstat 17 files changed, 526 insertions(+), 526 deletions(-) [+]
line wrap: on
line diff
--- a/doodle/core/logging.d	Tue Aug 03 16:57:06 2010 +0930
+++ b/doodle/core/logging.d	Tue Aug 03 17:37:21 2010 +0930
@@ -34,17 +34,17 @@
     string mod_string(in Severity s) {
         switch (s) {
         case Severity.TRACE:
-            return modifier_string(Modifier.DIM) ~ fg_color_string(Color.CYAN);
+            return modifierString(Modifier.DIM) ~ fgColorString(Color.CYAN);
         case Severity.INFO:
-            return modifier_string(Modifier.UNDERLINE) ~ fg_color_string(Color.GREEN);
+            return modifierString(Modifier.UNDERLINE) ~ fgColorString(Color.GREEN);
         case Severity.MESSAGE:
-            return fg_color_string(Color.YELLOW);
+            return fgColorString(Color.YELLOW);
         case Severity.WARNING:
-            return modifier_string(Modifier.BRIGHT) ~ fg_color_string(Color.MAGENTA);
+            return modifierString(Modifier.BRIGHT) ~ fgColorString(Color.MAGENTA);
         case Severity.ERROR:
-            return modifier_string(Modifier.BRIGHT) ~ fg_color_string(Color.RED);
+            return modifierString(Modifier.BRIGHT) ~ fgColorString(Color.RED);
         case Severity.FATAL:
-            return modifier_string(Modifier.BRIGHT) ~ bg_color_string(Color.RED) ~ fg_color_string(Color.WHITE);
+            return modifierString(Modifier.BRIGHT) ~ bgColorString(Color.RED) ~ fgColorString(Color.WHITE);
         default:
             assert(0);
         }
@@ -54,7 +54,7 @@
     void log(in Severity severity, in string message) {
         write(mod_string(severity));
         write(message);
-        writeln(modifier_string(Modifier.RESET));
+        writeln(modifierString(Modifier.RESET));
     }
 
     enum Modifier {
@@ -78,9 +78,9 @@
         WHITE   = 7
     }
 
-    string modifier_string(Modifier m) { return std.string.format("\033[%dm", 0 + m); }
-    string fg_color_string(Color c)    { return std.string.format("\033[%dm", 30 + c); }
-    string bg_color_string(Color c)    { return std.string.format("\033[%dm", 40 + c); }
+    string modifierString(Modifier m) { return std.string.format("\033[%dm", 0 + m); }
+    string fgColorString(Color c)    { return std.string.format("\033[%dm", 30 + c); }
+    string bgColorString(Color c)    { return std.string.format("\033[%dm", 40 + c); }
 
     private const(char)[] right(in char[] str, int n) {
         int pos = str.length < n ? 0 : str.length - n;
--- a/doodle/dia/grid_layer.d	Tue Aug 03 16:57:06 2010 +0930
+++ b/doodle/dia/grid_layer.d	Tue Aug 03 17:37:21 2010 +0930
@@ -22,7 +22,7 @@
 
     this(in string name) {
         super(name);
-        mZoomValid = false;
+        _zoomValid = false;
     }
 
     // Layer overrides:
@@ -33,70 +33,70 @@
     }
 
     override void draw(in Viewport viewport,
-                       in Rectangle pixel_damage, scope Context pixel_cr,
-                       in Rectangle model_damage, scope Context model_cr) const {
-        assert(mZoomValid);
+                       in Rectangle pixelDamage, scope Context pixelCr,
+                       in Rectangle modelDamage, scope Context modelCr) const {
+        assert(_zoomValid);
 
         double xx = 1.0, yy = 1.0;
-        model_cr.userToDeviceDistance(xx, yy);
+        modelCr.userToDeviceDistance(xx, yy);
 
-        model_cr.save(); {
-            model_cr.setSourceRgba(0.0, 0.0, 0.0, 0.3);
-            model_cr.setLineWidth(0.5);
+        modelCr.save(); {
+            modelCr.setSourceRgba(0.0, 0.0, 0.0, 0.3);
+            modelCr.setLineWidth(0.5);
 
             {
                 // vertical grid lines
-                double x = start(model_damage.min_corner.x, mSpacing);
+                double x = start(modelDamage.minCorner.x, _spacing);
 
                 for (;;) {
-                    vline(model_cr, x, model_damage.min_corner.y, model_damage.max_corner.y);
+                    vline(modelCr, x, modelDamage.minCorner.y, modelDamage.maxCorner.y);
 
                     // Ensure 1 pixel wide FIXME is this naughty? We are sneaking
                     // through cairo to mix model and pixel coordinates...
-                    model_cr.save(); {
-                        model_cr.scale(1.0 / xx, 1.0 / yy);
-                        model_cr.stroke();
-                    } model_cr.restore();
+                    modelCr.save(); {
+                        modelCr.scale(1.0 / xx, 1.0 / yy);
+                        modelCr.stroke();
+                    } modelCr.restore();
 
-                    if (x > model_damage.max_corner.x) {
+                    if (x > modelDamage.maxCorner.x) {
                         break;
                     }
 
-                    x += mSpacing;
+                    x += _spacing;
                 }
             }
 
             {
                 // horizontal grid lines
-                double y = start(model_damage.min_corner.y, mSpacing);
+                double y = start(modelDamage.minCorner.y, _spacing);
 
                 for (;;) {
-                    hline(model_cr, y, model_damage.min_corner.x, model_damage.max_corner.x);
+                    hline(modelCr, y, modelDamage.minCorner.x, modelDamage.maxCorner.x);
 
                     // FIXME?
-                    model_cr.save(); {
-                        model_cr.scale(1.0 / xx, 1.0 / yy);
-                        model_cr.stroke();
-                    } model_cr.restore();
+                    modelCr.save(); {
+                        modelCr.scale(1.0 / xx, 1.0 / yy);
+                        modelCr.stroke();
+                    } modelCr.restore();
 
-                    if (y > model_damage.max_corner.y) {
+                    if (y > modelDamage.maxCorner.y) {
                         break;
                     }
 
-                    y += mSpacing;
+                    y += _spacing;
                 }
             }
-        } model_cr.restore();
+        } modelCr.restore();
     }
 
     // Grid overrides:
 
-    override void zoom_changed(double zoom) {
-        mZoom = zoom;
-        mZoomValid = true;
+    override void zoomChanged(double zoom) {
+        _zoom = zoom;
+        _zoomValid = true;
 
         // FIXME compute spacing properly
-        mSpacing = 20.0 / mZoom;        // mm
+        _spacing = 20.0 / _zoom;        // mm
     }
 
     // FIXME use inout parameter?
@@ -106,9 +106,9 @@
     }
 
     private {
-        bool mZoomValid;
-        double mZoom;           // pixels per millimetre
+        bool _zoomValid;
+        double _zoom;           // pixels per millimetre
 
-        double mSpacing;        // model spacing
+        double _spacing;        // model spacing
     }
 }
--- a/doodle/dia/icanvas.d	Tue Aug 03 16:57:06 2010 +0930
+++ b/doodle/dia/icanvas.d	Tue Aug 03 17:37:21 2010 +0930
@@ -14,43 +14,43 @@
                   "DEFAULT", "HAND", "CROSSHAIR"));
 
 interface Viewport {
-    void zoom_relative(in Point pixel_datum, in double factor);
-    void pan_relative(in Vector pixel_displacement);
-    void set_cursor(in Cursor cursor);
+    void zoomRelative(in Point pixelDatum, in double factor);
+    void panRelative(in Vector pixelDisplacement);
+    void setCursor(in Cursor cursor);
 
     // FIXME get rid of these and accumulate damage during event handling
-    void damage_model(in Rectangle area);      // FIXME could be an inout parameter of the event handling, or a special scope Damage object that supports growth only
-    void damage_pixel(in Rectangle area);      // FIXME as above
+    void damageModel(in Rectangle area);      // FIXME could be an inout parameter of the event handling, or a special scope Damage object that supports growth only
+    void damagePixel(in Rectangle area);      // FIXME as above
 
     /*
     // FIXME hoping we won't need anything like this
     double zoom() const;
-    Point model_to_pixel(in Point model) const;
-    Point pixel_to_model(in Point pixel) const;
-    Vector model_to_pixel(in Vector model) const;
-    Vector pixel_to_model(in Vector pixel) const;
-    Rectangle model_to_pixel(in Rectangle model) const;
-    Rectangle pixel_to_model(in Rectangle model) const;
-    double model_to_pixel(in double model) const;
-    double pixel_to_model(in double pixel) const;
+    Point modelToPixel(in Point model) const;
+    Point pixelToModel(in Point pixel) const;
+    Vector modelToPixel(in Vector model) const;
+    Vector pixelToModel(in Vector pixel) const;
+    Rectangle modelToPixel(in Rectangle model) const;
+    Rectangle pixelToModel(in Rectangle model) const;
+    double modelToPixel(in double model) const;
+    double pixelToModel(in double pixel) const;
     */
 }
 
 interface EventHandler {
-    bool handle_button_press(scope Viewport viewport, in ButtonEvent event);
-    bool handle_button_release(scope Viewport viewport, in ButtonEvent event);
-    bool handle_motion(scope Viewport viewport, in MotionEvent event);
-    bool handle_scroll(scope Viewport viewport, in ScrollEvent event);
-    //bool handle_enter(scope Viewport viewport, CrossingEvent event);
-    //bool handle_leave(scope Viewport viewport, CrossingEvent event);
-    //bool handle_focus_in(scope Viewport viewport, FocusEvent event);
-    //bool handle_focus_out(scope Viewport viewport, FocusEvent event);
-    bool handle_key_press(scope Viewport viewport, in KeyEvent event);
-    bool handle_key_release(scope Viewport viewport, in KeyEvent event);
+    bool handleButtonPress(scope Viewport viewport, in ButtonEvent event);
+    bool handleButtonRelease(scope Viewport viewport, in ButtonEvent event);
+    bool handleMotion(scope Viewport viewport, in MotionEvent event);
+    bool handleScroll(scope Viewport viewport, in ScrollEvent event);
+    //bool handleEnter(scope Viewport viewport, CrossingEvent event);
+    //bool handleLeave(scope Viewport viewport, CrossingEvent event);
+    //bool handleFocusIn(scope Viewport viewport, FocusEvent event);
+    //bool handleFocusOut(scope Viewport viewport, FocusEvent event);
+    bool handleKeyPress(scope Viewport viewport, in KeyEvent event);
+    bool handleKeyRelease(scope Viewport viewport, in KeyEvent event);
 }
 
 interface Grid {
-    void zoom_changed(double zoom);
+    void zoomChanged(double zoom);
 
     // TODO  inout?
     bool snap(in Point a, out Point b) const;
@@ -70,8 +70,8 @@
     Rectangle bounds() const;
 
     void draw(in Viewport viewport,
-              in Rectangle pixel_damage, scope Context pixel_cr,
-              in Rectangle model_damage, scope Context model_cr) const;
+              in Rectangle pixelDamage, scope Context pixelCr,
+              in Rectangle modelDamage, scope Context modelCr) const;
 
     private {
         invariant string mName;
--- a/doodle/dia/page_layer.d	Tue Aug 03 16:57:06 2010 +0930
+++ b/doodle/dia/page_layer.d	Tue Aug 03 17:37:21 2010 +0930
@@ -11,37 +11,37 @@
 class PageLayer : Layer, Page {
     this(in string name) {
         super(name);
-        mPageGeometry = Rectangle(Point.DEFAULT, Vector(210.0, 297.0));
-        //mPageGeometry = Rectangle(Point.DEFAULT, Vector(100.0, 100.0));
+        _pageGeometry = Rectangle(Point.DEFAULT, Vector(210.0, 297.0));
+        //_pageGeometry = Rectangle(Point.DEFAULT, Vector(100.0, 100.0));
     }
 
     // Layer overrides:
 
     override Rectangle bounds() const {
-        return mPageGeometry;
+        return _pageGeometry;
     }
 
     override void draw(in Viewport viewport,
-                       in Rectangle pixel_damage, scope Context pixel_cr,
-                       in Rectangle model_damage, scope Context model_cr) const {
+                       in Rectangle pixelDamage, scope Context pixelCr,
+                       in Rectangle modelDamage, scope Context modelCr) const {
         // Make the paper white, with a border
 
-        model_cr.save; {
-            model_cr.setSourceRgba(0.0, 0.0, 0.0, 1.0);
-            rectangle(model_cr, mPageGeometry);
-            model_cr.stroke;
-        } model_cr.restore;
+        modelCr.save; {
+            modelCr.setSourceRgba(0.0, 0.0, 0.0, 1.0);
+            rectangle(modelCr, _pageGeometry);
+            modelCr.stroke;
+        } modelCr.restore;
 
-        model_cr.save; {
-            model_cr.setSourceRgba(1.0, 1.0, 1.0, 1.0);
-            rectangle(model_cr, mPageGeometry);
-            model_cr.fill;
-        } model_cr.restore;
+        modelCr.save; {
+            modelCr.setSourceRgba(1.0, 1.0, 1.0, 1.0);
+            rectangle(modelCr, _pageGeometry);
+            modelCr.fill;
+        } modelCr.restore;
     }
 
     // Page overrides:
 
     private {
-        Rectangle mPageGeometry;
+        Rectangle _pageGeometry;
     }
 }
--- a/doodle/dia/standard_tools.d	Tue Aug 03 16:57:06 2010 +0930
+++ b/doodle/dia/standard_tools.d	Tue Aug 03 17:37:21 2010 +0930
@@ -11,9 +11,9 @@
 }
 
 final class PanTool : Tool {
-    override bool handle_button_press(scope Viewport viewport, in ButtonEvent event) {
+    override bool handleButtonPress(scope Viewport viewport, in ButtonEvent event) {
         if (event.button_name == ButtonName.MIDDLE) {
-            mLastPosition = event.pixel_point;
+            mLastPosition = event.pixelPoint;
             return true;
         }
         else {
@@ -21,10 +21,10 @@
         }
     }
 
-    override bool handle_motion(scope Viewport viewport, in MotionEvent event) {
-        if (event.mask.is_set(Modifier.MIDDLE_BUTTON)) {
-            viewport.pan_relative(mLastPosition - event.pixel_point);
-            mLastPosition = event.pixel_point;
+    override bool handleMotion(scope Viewport viewport, in MotionEvent event) {
+        if (event.mask.isSet(Modifier.MIDDLE_BUTTON)) {
+            viewport.panRelative(mLastPosition - event.pixelPoint);
+            mLastPosition = event.pixelPoint;
 
             return true;
         }
@@ -33,16 +33,16 @@
         }
     }
 
-    override bool handle_scroll(scope Viewport viewport, in ScrollEvent event) {
-        if (event.mask.is_unset(Modifier.MIDDLE_BUTTON)) {
+    override bool handleScroll(scope Viewport viewport, in ScrollEvent event) {
+        if (event.mask.isUnset(Modifier.MIDDLE_BUTTON)) {
             Vector delta;
 
-            switch (event.scroll_direction) {
+            switch (event.scrollDirection) {
             case ScrollDirection.UP:
-                delta = event.mask.is_set(Modifier.SHIFT) ? Vector(-AMOUNT, 0.0) : Vector(0.0, AMOUNT);
+                delta = event.mask.isSet(Modifier.SHIFT) ? Vector(-AMOUNT, 0.0) : Vector(0.0, AMOUNT);
                 break;
             case ScrollDirection.DOWN:
-                delta = event.mask.is_set(Modifier.SHIFT) ? Vector(AMOUNT, 0.0) : Vector(0.0, -AMOUNT);
+                delta = event.mask.isSet(Modifier.SHIFT) ? Vector(AMOUNT, 0.0) : Vector(0.0, -AMOUNT);
                 break;
             case ScrollDirection.LEFT:
                 delta = Vector(-AMOUNT, 0.0);
@@ -54,7 +54,7 @@
                 assert(0);
             }
 
-            viewport.pan_relative(delta);
+            viewport.panRelative(delta);
         }
 
         return true;
@@ -67,14 +67,14 @@
 }
 
 final class ZoomTool : Tool {
-    override bool handle_scroll(scope Viewport viewport, in ScrollEvent event) {
-        if (event.mask.is_set(Modifier.CONTROL)) {
-            if (event.scroll_direction == ScrollDirection.DOWN) {
-                viewport.zoom_relative(event.pixel_point, 1.0 / ZOOM);
+    override bool handleScroll(scope Viewport viewport, in ScrollEvent event) {
+        if (event.mask.isSet(Modifier.CONTROL)) {
+            if (event.scrollDirection == ScrollDirection.DOWN) {
+                viewport.zoomRelative(event.pixelPoint, 1.0 / ZOOM);
                 return true;
             }
-            else if (event.scroll_direction == ScrollDirection.UP) {
-                viewport.zoom_relative(event.pixel_point, ZOOM);
+            else if (event.scrollDirection == ScrollDirection.UP) {
+                viewport.zoomRelative(event.pixelPoint, ZOOM);
                 return true;
             }
             else {
@@ -92,11 +92,11 @@
 }
 
 final class LassoTool : Tool {      // TODO convert to SelectTool
-    override bool handle_button_press(scope Viewport viewport, in ButtonEvent event) {
+    override bool handleButtonPress(scope Viewport viewport, in ButtonEvent event) {
         if (event.button_name == ButtonName.LEFT) {
-            mActive = true;
-            mAnchorPoint = mCurrentPoint = event.pixel_point;
-            viewport.set_cursor(Cursor.HAND);
+            _active = true;
+            _anchorPoint = _currentPoint = event.pixelPoint;
+            viewport.setCursor(Cursor.HAND);
             return true;
         }
         else {
@@ -104,11 +104,11 @@
         }
     }
 
-    override bool handle_button_release(scope Viewport viewport, in ButtonEvent event) {
-        if (event.button_name == ButtonName.LEFT && mActive) {
-            mActive = false;
-            viewport.damage_pixel(feather(Rectangle(mAnchorPoint, mCurrentPoint), LINE_WIDTH / 2.0));
-            viewport.set_cursor(Cursor.DEFAULT);
+    override bool handleButtonRelease(scope Viewport viewport, in ButtonEvent event) {
+        if (event.button_name == ButtonName.LEFT && _active) {
+            _active = false;
+            viewport.damagePixel(feather(Rectangle(_anchorPoint, _currentPoint), LINE_WIDTH / 2.0));
+            viewport.setCursor(Cursor.DEFAULT);
             return true;
         }
         else {
@@ -116,42 +116,42 @@
         }
     }
 
-    override bool handle_motion(scope Viewport viewport, in MotionEvent event) {
-        if (mActive) {
-            viewport.damage_pixel(feather(Rectangle(mAnchorPoint, mCurrentPoint), LINE_WIDTH / 2.0));
-            mCurrentPoint = event.pixel_point;
-            viewport.damage_pixel(feather(Rectangle(mAnchorPoint, mCurrentPoint), LINE_WIDTH / 2.0));
+    override bool handleMotion(scope Viewport viewport, in MotionEvent event) {
+        if (_active) {
+            viewport.damagePixel(feather(Rectangle(_anchorPoint, _currentPoint), LINE_WIDTH / 2.0));
+            _currentPoint = event.pixelPoint;
+            viewport.damagePixel(feather(Rectangle(_anchorPoint, _currentPoint), LINE_WIDTH / 2.0));
         }
 
         return false;
     }
 
     override void draw(in Viewport viewport,
-                       in Rectangle pixel_damage, scope Context pixel_cr,
-                       in Rectangle model_damage, scope Context model_cr) const {
-        if (mActive) {
-            pixel_cr.save; {
-                pixel_cr.setSourceRgba(0.0, 0.0, 0.8, 0.3);
-                rectangle(pixel_cr, Rectangle(mCurrentPoint, mAnchorPoint));
-                pixel_cr.fill();
-            } pixel_cr.restore();
+                       in Rectangle pixelDamage, scope Context pixelCr,
+                       in Rectangle modelDamage, scope Context modelCr) const {
+        if (_active) {
+            pixelCr.save; {
+                pixelCr.setSourceRgba(0.0, 0.0, 0.8, 0.3);
+                rectangle(pixelCr, Rectangle(_currentPoint, _anchorPoint));
+                pixelCr.fill();
+            } pixelCr.restore();
 
-            pixel_cr.save(); {
+            pixelCr.save(); {
                 //double[] dashes = [ 4.0, 4.0 ];
-                //pixel_cr.setDash(dashes, 0.0);
-                pixel_cr.setSourceRgba(0.0, 0.0, 0.5, 1.0);
-                pixel_cr.setLineWidth(LINE_WIDTH);
-                //writefln("Drawing rectangle: %s", Rectangle(mCurrentPoint, mAnchorPoint));
-                rectangle(pixel_cr, Rectangle(mCurrentPoint, mAnchorPoint));
-                pixel_cr.stroke;
-            } pixel_cr.restore;
+                //pixelCr.setDash(dashes, 0.0);
+                pixelCr.setSourceRgba(0.0, 0.0, 0.5, 1.0);
+                pixelCr.setLineWidth(LINE_WIDTH);
+                //writefln("Drawing rectangle: %s", Rectangle(_currentPoint, _anchorPoint));
+                rectangle(pixelCr, Rectangle(_currentPoint, _anchorPoint));
+                pixelCr.stroke;
+            } pixelCr.restore;
         }
     }
 
     private {
-        bool mActive;
-        Point mCurrentPoint;
-        Point mAnchorPoint;      // Pixel
+        bool _active;
+        Point _currentPoint;
+        Point _anchorPoint;      // Pixel
         static invariant double LINE_WIDTH = 1.0;
     }
 }
--- a/doodle/dia/tool.d	Tue Aug 03 16:57:06 2010 +0930
+++ b/doodle/dia/tool.d	Tue Aug 03 17:37:21 2010 +0930
@@ -23,8 +23,8 @@
     */
 
     /*
-    abstract bool is_sticky();
-    abstract bool is_replaceable();
+    abstract bool isSticky();
+    abstract bool isReplaceable();
     */
 
     /*
@@ -32,18 +32,18 @@
     abstract void stop(IToolStack tool_stack);
     */
 
-    bool handle_button_press(scope Viewport viewport, in ButtonEvent event) { return false; }
-    bool handle_button_release(scope Viewport viewport, in ButtonEvent event) { return false; }
-    bool handle_motion(scope Viewport viewport, in MotionEvent event) { return false; }
-    bool handle_scroll(scope Viewport viewport, in ScrollEvent event) { return false; }
-    //bool handle_enter(scope viewport, CrossingEvent event) { return false; }
-    //bool handle_leave(scope viewport, CrossingEvent event) { return false; }
-    //bool handle_focus_in(scope viewport, FocusEvent event) { return false; }
-    //bool handle_focus_out(scope viewport, FocusEvent event) { return false; }
-    bool handle_key_press(scope Viewport viewport, in KeyEvent event) { return false; }
-    bool handle_key_release(scope Viewport viewport, in KeyEvent event) { return false; }
+    bool handleButtonPress(scope Viewport viewport, in ButtonEvent event) { return false; }
+    bool handleButtonRelease(scope Viewport viewport, in ButtonEvent event) { return false; }
+    bool handleMotion(scope Viewport viewport, in MotionEvent event) { return false; }
+    bool handleScroll(scope Viewport viewport, in ScrollEvent event) { return false; }
+    //bool handleEnter(scope viewport, CrossingEvent event) { return false; }
+    //bool handleLeave(scope viewport, CrossingEvent event) { return false; }
+    //bool handleFocusIn(scope viewport, FocusEvent event) { return false; }
+    //bool handleFocusOut(scope viewport, FocusEvent event) { return false; }
+    bool handleKeyPress(scope Viewport viewport, in KeyEvent event) { return false; }
+    bool handleKeyRelease(scope Viewport viewport, in KeyEvent event) { return false; }
 
     void draw(in Viewport viewport,
-              in Rectangle pixel_damage, scope Context pixel_cr,
-              in Rectangle model_damage, scope Context model_cr) const { }
+              in Rectangle pixelDamage, scope Context pixelCr,
+              in Rectangle modelDamage, scope Context modelCr) const { }
 }
--- a/doodle/dia/tool_layer.d	Tue Aug 03 16:57:06 2010 +0930
+++ b/doodle/dia/tool_layer.d	Tue Aug 03 17:37:21 2010 +0930
@@ -12,7 +12,7 @@
 class ToolLayer : Layer, EventHandler {
     this(in Tool[] tools, in string name) {
         super(name);
-        mTools = tools.dup;
+        _tools = tools.dup;
     }
 
     // Layer overrides:
@@ -22,90 +22,90 @@
     }
 
     override void draw(const Viewport viewport,
-                       in Rectangle pixel_damage, scope Context pixel_cr,
-                       in Rectangle model_damage, scope Context model_cr) const {
+                       in Rectangle pixelDamage, scope Context pixelCr,
+                       in Rectangle modelDamage, scope Context modelCr) const {
         // FIXME this isn't how we will really draw the tools...
-        foreach (const Tool tool; mTools) {
-            tool.draw(viewport, pixel_damage, pixel_cr, model_damage, model_cr);
+        foreach (const Tool tool; _tools) {
+            tool.draw(viewport, pixelDamage, pixelCr, modelDamage, modelCr);
         }
     }
 
     // EventHandler overrides:
 
-    override bool handle_button_press(scope Viewport viewport, in ButtonEvent event) {
+    override bool handleButtonPress(scope 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;
+        if (_grabbedTool is null) {
+            foreach_reverse(ref tool; _tools) {
+                if (tool.handleButtonPress(viewport, event)) {
+                    _grabbedTool = &tool;
+                    _grabbedButton = event.button_name;
                     break;
                 }
             }
         }
         else {
-            mGrabbedTool.handle_button_press(viewport, event);
+            _grabbedTool.handleButtonPress(viewport, event);
         }
 
         return true;
     }
 
-    override bool handle_button_release(scope Viewport viewport, in ButtonEvent event) {
+    override bool handleButtonRelease(scope Viewport viewport, in ButtonEvent event) {
         // writefln("%s", event);
 
-        if (mGrabbedTool !is null) {
-            mGrabbedTool.handle_button_release(viewport, event);
+        if (_grabbedTool !is null) {
+            _grabbedTool.handleButtonRelease(viewport, event);
 
-            if (mGrabbedButton == event.button_name) {
-                mGrabbedTool = null;
+            if (_grabbedButton == event.button_name) {
+                _grabbedTool = null;
             }
         }
 
         return true;
     }
 
-    override bool handle_key_press(scope Viewport viewport, in KeyEvent event) {
+    override bool handleKeyPress(scope Viewport viewport, in KeyEvent event) {
         // writefln("%s", event);
 
         return true;
     }
 
-    override bool handle_key_release(scope Viewport viewport, in KeyEvent event) {
+    override bool handleKeyRelease(scope Viewport viewport, in KeyEvent event) {
         // writefln("%s", event);
 
         return true;
     }
 
-    override bool handle_motion(scope Viewport viewport, in MotionEvent event) {
+    override bool handleMotion(scope Viewport viewport, in MotionEvent event) {
         //writefln("%s", event);
 
-        if (mGrabbedTool is null) {
-            foreach_reverse(ref tool; mTools) {
-                if (tool.handle_motion(viewport, event)) {
+        if (_grabbedTool is null) {
+            foreach_reverse(ref tool; _tools) {
+                if (tool.handleMotion(viewport, event)) {
                     break;
                 }
             }
         }
         else {
-            mGrabbedTool.handle_motion(viewport, event);
+            _grabbedTool.handleMotion(viewport, event);
         }
 
         return true;
     }
 
-    override bool handle_scroll(scope Viewport viewport, in ScrollEvent event) {
+    override bool handleScroll(scope Viewport viewport, in ScrollEvent event) {
         // writefln("%s", event);
 
-        if (mGrabbedTool is null) {
-            foreach_reverse(ref tool; mTools) {
-                if (tool.handle_scroll(viewport, event)) {
+        if (_grabbedTool is null) {
+            foreach_reverse(ref tool; _tools) {
+                if (tool.handleScroll(viewport, event)) {
                     break;
                 }
             }
         }
         else {
-            mGrabbedTool.handle_scroll(viewport, event);
+            _grabbedTool.handleScroll(viewport, event);
         }
 
         return true;
@@ -123,8 +123,8 @@
     */
 
     private {
-        Tool[] mTools;
-        Tool * mGrabbedTool;
-        ButtonName mGrabbedButton;
+        Tool[] _tools;
+        Tool * _grabbedTool;
+        ButtonName _grabbedButton;
     }
 }
--- a/doodle/fig/fig.d	Tue Aug 03 16:57:06 2010 +0930
+++ b/doodle/fig/fig.d	Tue Aug 03 17:37:21 2010 +0930
@@ -30,7 +30,7 @@
 
 class FigEdge : FigElement {
     private {
-        Connection[] mConnections;
+        Connection[] _connections;
     }
 }
 
--- a/doodle/fig/fig_layer.d	Tue Aug 03 16:57:06 2010 +0930
+++ b/doodle/fig/fig_layer.d	Tue Aug 03 17:37:21 2010 +0930
@@ -17,11 +17,11 @@
     }
 
     override void draw(in Viewport viewport,
-                       in Rectangle pixel_damage, scope Context pixel_cr,
-                       in Rectangle model_damage, scope Context model_cr) const {
+                       in Rectangle pixelDamage, scope Context pixelCr,
+                       in Rectangle modelDamage, scope Context modelCr) const {
     }
 
     private {
-        Fig[] mFigs;
+        Fig[] _figs;
     }
 }
--- 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;
     }
 }
--- a/doodle/gtk/conversions.d	Tue Aug 03 16:57:06 2010 +0930
+++ b/doodle/gtk/conversions.d	Tue Aug 03 17:37:21 2010 +0930
@@ -8,7 +8,7 @@
     static import gdk.Event;
 }
 
-ButtonAction gtk2tk_button_action(gdk.Event.EventType event_type) {
+ButtonAction gtk2tkButtonAction(gdk.Event.EventType event_type) {
     switch (event_type) {
     case gdk.Event.EventType.BUTTON_PRESS:
         return ButtonAction.SINGLE_PRESS;
@@ -23,7 +23,7 @@
     }
 }
 
-ButtonName gtk2tk_button_name(gdk.Event.guint button) {
+ButtonName gtk2tkButtonName(gdk.Event.guint button) {
     switch (button) {
     case 1:
         return ButtonName.LEFT;
@@ -40,7 +40,7 @@
     }
 }
 
-Mask gtk2tk_mask(gdk.Event.guint state) {
+Mask gtk2tkMask(gdk.Event.guint state) {
     Modifier[] modifiers;
 
     if (state & gdk.Event.GdkModifierType.SHIFT_MASK)   modifiers ~= Modifier.SHIFT;
@@ -58,7 +58,7 @@
     return Mask(modifiers);
 }
 
-ScrollDirection gtk2tk_direction(gdk.Event.ScrollDirection direction) {
+ScrollDirection gtk2tkDirection(gdk.Event.ScrollDirection direction) {
     switch (direction) {
     case gdk.Event.ScrollDirection.UP:
         return ScrollDirection.UP;
--- a/doodle/gtk/toolbar.d	Tue Aug 03 16:57:06 2010 +0930
+++ b/doodle/gtk/toolbar.d	Tue Aug 03 17:37:21 2010 +0930
@@ -38,7 +38,7 @@
         button2 = new RadioToolButton(group);
         button2.setGroup(button1.getGroup);
         button2.setLabelWidget(image);
-        button2.addOnClicked(&on_clicked);
+        button2.addOnClicked(&onClicked);
         insert(button2);
 
         insert(new SeparatorToolItem);
@@ -52,7 +52,7 @@
 
     private {
 
-        void on_clicked(ToolButton tool_button) {
+        void onClicked(ToolButton tool_button) {
             writefln("Clicked!");
         }
 
--- a/doodle/main/prog/doodler.d	Tue Aug 03 16:57:06 2010 +0930
+++ b/doodle/main/prog/doodler.d	Tue Aug 03 17:37:21 2010 +0930
@@ -36,23 +36,23 @@
     trace("Test trace3");
     auto vbox = new VBox(false, 0);
     trace("Test trace4");
-    auto tool_bar = new ToolBar;
+    auto toolBar = new ToolBar;
     trace("Test trace5");
-    vbox.packStart(tool_bar, false, false, 0);
+    vbox.packStart(toolBar, false, false, 0);
     Tool[] tools;
     tools ~= new PanTool;
     tools ~= new ZoomTool;
     tools ~= new LassoTool;
     trace("Test trace4");
-    auto tool_layer = new ToolLayer(tools, "Tools");
-    auto grid_layer = new GridLayer("Grid");
+    auto toolLayer = new ToolLayer(tools, "Tools");
+    auto gridLayer = new GridLayer("Grid");
     Layer[] layers;
     trace("Test trace5");
     layers ~= new PageLayer("Page");
-    layers ~= grid_layer;
-    layers ~= tool_layer;
+    layers ~= gridLayer;
+    layers ~= toolLayer;
     trace("Test trace6");
-    auto canvas = new Canvas(layers, tool_layer, grid_layer, 120.0);
+    auto canvas = new Canvas(layers, toolLayer, gridLayer, 120.0);
     trace("Test trace7");
     vbox.packStart(canvas, true, true, 0);
     trace("Test trace8");
--- a/doodle/tk/events.d	Tue Aug 03 16:57:06 2010 +0930
+++ b/doodle/tk/events.d	Tue Aug 03 17:37:21 2010 +0930
@@ -7,13 +7,13 @@
 
 abstract class Event {
     this(in Mask mask) {
-        mMask = mask;
+        _mask = mask;
     }
 
-    Mask mask() const { return mMask; }
+    Mask mask() const { return _mask; }
 
     private {
-        Mask mMask;
+        Mask _mask;
     }
 }
 
@@ -25,35 +25,35 @@
 final class KeyEvent : Event {
     this(in string str, in uint value, in Mask mask) {
         super(mask);
-        mStr = str;
-        mValue = value;
+        _str = str;
+        _value = value;
     }
 
-    string str() const { return mStr; }
+    string str() const { return _str; }
 
     override string toString() const {
-        return std.string.format("Key event: %s, %d, %s", mStr, mValue, mMask);
+        return std.string.format("Key event: %s, %d, %s", _str, _value, _mask);
     }
 
     private {
-        string mStr;
-        uint mValue;
+        string _str;
+        uint _value;
     }
 }
 
 abstract class PointerEvent : Event {
-    this(in Point pixel_point, in Point model_point, in Mask mask) {
+    this(in Point pixelPoint, in Point modelPoint, in Mask mask) {
         super(mask);
-        mPixelPoint = pixel_point;
-        mModelPoint = model_point;
+        _pixelPoint = pixelPoint;
+        _modelPoint = modelPoint;
     }
 
-    Point pixel_point() const { return mPixelPoint; }
-    Point model_point() const { return mModelPoint; }
+    Point pixelPoint() const { return _pixelPoint; }
+    Point modelPoint() const { return _modelPoint; }
 
     private {
-        Point mPixelPoint;
-        Point mModelPoint;
+        Point _pixelPoint;
+        Point _modelPoint;
     }
 }
 
@@ -71,59 +71,59 @@
 final class ButtonEvent : PointerEvent {
     this(in ButtonAction button_action,
          in ButtonName button_name,
-         in Point pixel_point,
-         in Point model_point,
+         in Point pixelPoint,
+         in Point modelPoint,
          in Mask mask) {   
-        super(pixel_point, model_point, mask);
-        mButtonAction = button_action;
-        mButtonName = button_name;
+        super(pixelPoint, modelPoint, mask);
+        _buttonAction = button_action;
+        _buttonName = button_name;
     }
 
     override string toString() const {
         return std.string.format("Button event: %s, %s, %s, %s, %s",
-                                 enumToString(mButtonAction), enumToString(mButtonName),
-                                 mPixelPoint, mModelPoint, mMask);
+                                 enumToString(_buttonAction), enumToString(_buttonName),
+                                 _pixelPoint, _modelPoint, _mask);
     }
 
-    ButtonAction button_action() const { return mButtonAction; }
-    ButtonName button_name() const { return mButtonName; }
+    ButtonAction button_action() const { return _buttonAction; }
+    ButtonName button_name() const { return _buttonName; }
 
     private {
-        ButtonAction mButtonAction;
-        ButtonName mButtonName;
+        ButtonAction _buttonAction;
+        ButtonName _buttonName;
     }
 }
 
 final class MotionEvent : PointerEvent {
-    this(in Point pixel_point,
-         in Point model_point,
+    this(in Point pixelPoint,
+         in Point modelPoint,
          in Mask mask) {
-        super(pixel_point, model_point, mask);
+        super(pixelPoint, modelPoint, mask);
     }
 
     override string toString() const {
         return std.string.format("Motion event: %s, %s, %s",
-                                 mPixelPoint, mModelPoint, mMask);
+                                 _pixelPoint, _modelPoint, _mask);
     }
 }
 
 final class ScrollEvent : PointerEvent {
-    this(in ScrollDirection scroll_direction,
-         in Point pixel_point,
-         in Point model_point,
+    this(in ScrollDirection scrollDirection,
+         in Point pixelPoint,
+         in Point modelPoint,
          in Mask mask) {
-        super(pixel_point, model_point, mask);
-        mScrollDirection = scroll_direction;
+        super(pixelPoint, modelPoint, mask);
+        _scrollDirection = scrollDirection;
     }
 
     override string toString() const {
         return std.string.format("Scroll event: %s, %s, %s, %s",
-                                 enumToString(mScrollDirection), mPixelPoint, mModelPoint, mMask);
+                                 enumToString(_scrollDirection), _pixelPoint, _modelPoint, _mask);
     }
 
-    ScrollDirection scroll_direction() const { return mScrollDirection; }
+    ScrollDirection scrollDirection() const { return _scrollDirection; }
 
     private {
-        ScrollDirection mScrollDirection;
+        ScrollDirection _scrollDirection;
     }
 }
--- a/doodle/tk/geometry.d	Tue Aug 03 16:57:06 2010 +0930
+++ b/doodle/tk/geometry.d	Tue Aug 03 17:37:21 2010 +0930
@@ -61,11 +61,11 @@
     }
 }
 
-Point min_extents(in Point a, in Point b) {
+Point minExtents(in Point a, in Point b) {
     return Point(min(a.x, b.x), min(a.y, b.y));
 }
 
-Point max_extents(in Point a, in Point b) {
+Point maxExtents(in Point a, in Point b) {
     return Point(max(a.x, b.x), max(a.y, b.y));
 }
 
@@ -164,12 +164,12 @@
         this(corner1.x, corner1.y, corner.x - corner1.x, corner.y - corner1.y);
     }
 
-    alias position min_corner;
+    alias position minCorner;
     Point position() const { return _position; }
 
     Vector size() const { return _size; }
 
-    Point max_corner() const { return _position + _size; }
+    Point maxCorner() const { return _position + _size; }
 
     bool valid() const { return _size.x > 0.0 && _size.y > 0.0; }
 
@@ -183,8 +183,8 @@
             return DEFAULT;
         }
         else {
-            Point max = min_extents(max_corner(), r.max_corner());
-            Point min = max_extents(min_corner(), r.min_corner());
+            Point max = minExtents(maxCorner(), r.maxCorner());
+            Point min = maxExtents(minCorner(), r.minCorner());
 
             if (max.x < min.x || max.y < min.y) {
                 return DEFAULT;
@@ -204,8 +204,8 @@
             return this;
         }
         else {
-            return Rectangle(min_extents(min_corner(), r.min_corner()),
-                             max_extents(max_corner(), r.max_corner()));
+            return Rectangle(minExtents(minCorner(), r.minCorner()),
+                             maxExtents(maxCorner(), r.maxCorner()));
         }
     }
 
@@ -213,7 +213,7 @@
 
     // FIXME this method is all about pixels. Not sure it belongs in
     // this file, let alone this class.
-    void get_quantised(out int x, out int y, out int w, out int h) const {
+    void getQuantised(out int x, out int y, out int w, out int h) const {
         x = cast(int)floor(_position.x);
         y = cast(int)floor(_position.y);
         w = cast(int)ceil(_position.x + _size.x) - x;
@@ -288,7 +288,7 @@
     // The function returns false if the lines are parallel or nearly so.
     //
     // Influenced by http://ozviz.wasp.uwa.edu.au/~pbourke/geometry/lineline2d/
-    bool compute_intersection(in Point pa1, in Point pa2, out double ua,
+    bool computeIntersection(in Point pa1, in Point pa2, out double ua,
                               in Point pb1, in Point pb2, out double ub) {
         double den = (pb2.y - pb1.y) * (pa2.x - pa1.x) - (pb2.x - pb1.x) * (pa2.y - pa1.y);
 
@@ -360,7 +360,7 @@
     Vector vb = b.gradient;
     double ub;
 
-    if (compute_intersection(pa, pa + va, ua, pb, pb + vb, ub)) {
+    if (computeIntersection(pa, pa + va, ua, pb, pb + vb, ub)) {
         // We could just have easily evaluated for line b...
         p = pa + ua * va;
         // p = pb + ub * vb;
@@ -406,7 +406,7 @@
     Point pb2 = b.end;
     double ub;
 
-    if (compute_intersection(pa1, pa2, ua, pb1, pb2, ub)) {
+    if (computeIntersection(pa1, pa2, ua, pb1, pb2, ub)) {
         if (ua >= 0.0 && ua <= 1.0 &&     // inside of segment a
             ub >= 0.0 && ub <= 1.0) {     // inside of segment b
             // We could just have easily evaluated for line b...
@@ -432,7 +432,7 @@
     Vector vb = b.gradient;
     double ub;
 
-    if (compute_intersection(pa1, pa2, ua, pb, pb + vb, ub)) {
+    if (computeIntersection(pa1, pa2, ua, pb, pb + vb, ub)) {
         if (ua >= 0.0 && ua <= 1.0) {   // inside of segment
             // We could just have easily evaluated for line b...
             p = pa1 + ua * (pa2 - pa1);
--- a/doodle/tk/test/test1.d	Tue Aug 03 16:57:06 2010 +0930
+++ b/doodle/tk/test/test1.d	Tue Aug 03 17:37:21 2010 +0930
@@ -21,8 +21,8 @@
 
     Point p4 = Point(1.0, 10.0);
     Point p5 = Point(10.0, 1.0);
-    assert(min_extents(p4, p5) == Point(1.0, 1.0));     // min extents
-    assert(max_extents(p4, p5) == Point(10.0, 10.0));   // max extents
+    assert(minExtents(p4, p5) == Point(1.0, 1.0));     // min extents
+    assert(maxExtents(p4, p5) == Point(10.0, 10.0));   // max extents
 
     writefln("p1: %s", p1);                     // toString
 }
--- a/doodle/tk/types.d	Tue Aug 03 16:57:06 2010 +0930
+++ b/doodle/tk/types.d	Tue Aug 03 17:37:21 2010 +0930
@@ -44,12 +44,12 @@
         return s;
     }
 
-    bool is_set(in Modifier m) const {
+    bool isSet(in Modifier m) const {
         return _bits & (1 << m);
     }
 
-    bool is_unset(in Modifier m) const {
-        return !is_set(m);
+    bool isUnset(in Modifier m) const {
+        return !isSet(m);
     }
 
     private {