# HG changeset patch # User daveb # Date 1280822841 -34200 # Node ID 1b4c9ba58673bb717e32e7afe4dda270a8b75c51 # Parent 14f1c051c35b53a7ed38e424883257fd53a89e59 Stylistic overhaul. diff -r 14f1c051c35b -r 1b4c9ba58673 doodle/core/logging.d --- 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; diff -r 14f1c051c35b -r 1b4c9ba58673 doodle/dia/grid_layer.d --- 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 } } diff -r 14f1c051c35b -r 1b4c9ba58673 doodle/dia/icanvas.d --- 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; diff -r 14f1c051c35b -r 1b4c9ba58673 doodle/dia/page_layer.d --- 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; } } diff -r 14f1c051c35b -r 1b4c9ba58673 doodle/dia/standard_tools.d --- 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; } } diff -r 14f1c051c35b -r 1b4c9ba58673 doodle/dia/tool.d --- 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 { } } diff -r 14f1c051c35b -r 1b4c9ba58673 doodle/dia/tool_layer.d --- 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; } } diff -r 14f1c051c35b -r 1b4c9ba58673 doodle/fig/fig.d --- 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; } } diff -r 14f1c051c35b -r 1b4c9ba58673 doodle/fig/fig_layer.d --- 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; } } diff -r 14f1c051c35b -r 1b4c9ba58673 doodle/gtk/canvas.d --- 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; } } diff -r 14f1c051c35b -r 1b4c9ba58673 doodle/gtk/conversions.d --- 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; diff -r 14f1c051c35b -r 1b4c9ba58673 doodle/gtk/toolbar.d --- 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!"); } diff -r 14f1c051c35b -r 1b4c9ba58673 doodle/main/prog/doodler.d --- 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"); diff -r 14f1c051c35b -r 1b4c9ba58673 doodle/tk/events.d --- 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; } } diff -r 14f1c051c35b -r 1b4c9ba58673 doodle/tk/geometry.d --- 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); diff -r 14f1c051c35b -r 1b4c9ba58673 doodle/tk/test/test1.d --- 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 } diff -r 14f1c051c35b -r 1b4c9ba58673 doodle/tk/types.d --- 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 {