Mercurial > projects > doodle

changeset 58:c63719604adb

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Beginnings of creating a rectangle...
author "David Bryant <bagnose@gmail.com>"
date Mon, 09 Aug 2010 21:43:24 +0930
parents 9960c4fbd0dd
children 860e18c87255
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/diagram_elements.d doodle/fig/diagram_layer.d doodle/fig/tools.d doodle/gtk/canvas.d doodle/main/prog/doodler.d doodle/tk/events.d
diffstat 13 files changed, 200 insertions(+), 104 deletions(-) [+]
line wrap: on
line diff
--- a/doodle/core/logging.d	Sun Aug 08 22:01:54 2010 +0930
+++ b/doodle/core/logging.d	Mon Aug 09 21:43:24 2010 +0930
@@ -3,26 +3,50 @@
 private {
     import std.stdio;
     import std.typecons;
+    import std.traits;
 }
 
 public {
-    void trace(string file = __FILE__, int line = __LINE__)(in string message) {
-        log(Severity.TRACE,   std.string.format("%s(%d):   TRACE: %s", right(file, 20), line, message));
+    void trace(string file = __FILE__, int line = __LINE__, S...)(S args) {
+        static assert(S.length > 0);
+        static assert(isSomeString!(S[0]));
+        log(Severity.TRACE,
+            std.string.format("%s(%d): MESSAGE: %s", right(file, 20), line, std.string.format(args)));
     }
-    void info(string file = __FILE__, int line = __LINE__)(in string message) {
-        log(Severity.INFO,    std.string.format("%s(%d):    INFO: %s", right(file, 20), line, message));
+
+    void info(string file = __FILE__, int line = __LINE__, S...)(S args) {
+        static assert(S.length > 0);
+        static assert(isSomeString!(S[0]));
+        log(Severity.INFO,
+            std.string.format("%s(%d): MESSAGE: %s", right(file, 20), line, std.string.format(args)));
     }
-    void message(string file = __FILE__, int line = __LINE__)(in string message) {
-        log(Severity.MESSAGE, std.string.format("%s(%d): MESSAGE: %s", right(file, 20), line, message));
+
+    void message(string file = __FILE__, int line = __LINE__, S...)(S args) {
+        static assert(S.length > 0);
+        static assert(isSomeString!(S[0]));
+        log(Severity.MESSAGE,
+            std.string.format("%s(%d): MESSAGE: %s", right(file, 20), line, std.string.format(args)));
     }
-    void warning(string file = __FILE__, int line = __LINE__)(in string message) {
-        log(Severity.WARNING, std.string.format("%s(%d): WARNING: %s", right(file, 20), line, message));
+
+    void warning(string file = __FILE__, int line = __LINE__, S...)(S args) {
+        static assert(S.length > 0);
+        static assert(isSomeString!(S[0]));
+        log(Severity.WARNING,
+            std.string.format("%s(%d): MESSAGE: %s", right(file, 20), line, std.string.format(args)));
     }
-    void error(string file = __FILE__, int line = __LINE__)(in string message) {
-        log(Severity.ERROR,   std.string.format("%s(%d):   ERROR: %s", right(file, 20), line, message));
+
+    void error(string file = __FILE__, int line = __LINE__, S...)(S args) {
+        static assert(S.length > 0);
+        static assert(isSomeString!(S[0]));
+        log(Severity.ERROR,
+            std.string.format("%s(%d): MESSAGE: %s", right(file, 20), line, std.string.format(args)));
     }
-    void fatal(string file = __FILE__, int line = __LINE__)(in string message) {
-        log(Severity.FATAL,   std.string.format("%s(%d):   FATAL: %s", right(file, 20), line, message));
+
+    void fatal(string file = __FILE__, int line = __LINE__, S...)(S args) {
+        static assert(S.length > 0);
+        static assert(isSomeString!(S[0]));
+        log(Severity.FATAL,
+            std.string.format("%s(%d): MESSAGE: %s", right(file, 20), line, std.string.format(args)));
         assert(0);
     }
 }
@@ -52,9 +76,7 @@
     }
 
     void log(in Severity severity, in string message) {
-        write(severityString(severity));
-        write(message);
-        writeln(modifierString(Modifier.RESET));
+        writeln(severityString(severity), message, modifierString(Modifier.RESET));
     }
 
     enum Modifier {
--- a/doodle/dia/grid_layer.d	Sun Aug 08 22:01:54 2010 +0930
+++ b/doodle/dia/grid_layer.d	Mon Aug 09 21:43:24 2010 +0930
@@ -18,9 +18,9 @@
 }
 
 class GridLayer : Layer, IGrid {
-    static const double MIN_SPACING = 5.0;      // pixels
+    immutable double MIN_SPACING = 5.0;      // pixels
 
-    this(in string name) {
+    this(in string name = "Grid") {
         super(name);
         _zoomValid = false;
     }
--- a/doodle/dia/icanvas.d	Sun Aug 08 22:01:54 2010 +0930
+++ b/doodle/dia/icanvas.d	Mon Aug 09 21:43:24 2010 +0930
@@ -62,10 +62,10 @@
 
 abstract class Layer {
     this(in string name) {
-        mName = name;
+        _name = name;
     }
 
-    string name() const { return mName; }
+    string name() const { return _name; }
 
     Rectangle bounds() const;
 
@@ -74,6 +74,6 @@
               in Rectangle modelDamage, scope Context modelCr) const;
 
     private {
-        invariant string mName;
+        immutable string _name;
     }
 }
--- a/doodle/dia/page_layer.d	Sun Aug 08 22:01:54 2010 +0930
+++ b/doodle/dia/page_layer.d	Mon Aug 09 21:43:24 2010 +0930
@@ -9,7 +9,7 @@
 }
 
 class PageLayer : Layer, IPage {
-    this(in string name) {
+    this(in string name = "Page") {
         super(name);
         _pageGeometry = Rectangle(Point.DEFAULT, Vector(210.0, 297.0));
         //_pageGeometry = Rectangle(Point.DEFAULT, Vector(100.0, 100.0));
--- a/doodle/dia/standard_tools.d	Sun Aug 08 22:01:54 2010 +0930
+++ b/doodle/dia/standard_tools.d	Mon Aug 09 21:43:24 2010 +0930
@@ -11,8 +11,12 @@
 }
 
 final class PanTool : Tool {
+    this() {
+        super("Pan");
+    }
+
     override bool handleButtonPress(scope IViewport viewport, in ButtonEvent event) {
-        if (event.button_name == ButtonName.MIDDLE) {
+        if (event.buttonName == ButtonName.MIDDLE) {
             mLastPosition = event.pixelPoint;
             return true;
         }
@@ -62,11 +66,15 @@
 
     private {
         Point mLastPosition;
-        static invariant double AMOUNT = 60.0;
+        static immutable double AMOUNT = 60.0;
     }
 }
 
 final class ZoomTool : Tool {
+    this() {
+        super("Zoom");
+    }
+
     override bool handleScroll(scope IViewport viewport, in ScrollEvent event) {
         if (event.mask.isSet(Modifier.CONTROL)) {
             if (event.scrollDirection == ScrollDirection.DOWN) {
@@ -87,13 +95,17 @@
     }
 
     private {
-        static invariant double ZOOM = sqrt(2.0);
+        static immutable double ZOOM = sqrt(2.0);
     }
 }
 
 final class SelectTool : Tool {
+    this() {
+        super("Select");
+    }
+
     override bool handleButtonPress(scope IViewport viewport, in ButtonEvent event) {
-        if (event.button_name == ButtonName.LEFT) {
+        if (event.buttonName == ButtonName.LEFT) {
             _active = true;
             _anchorPoint = _currentPoint = event.pixelPoint;
             viewport.setCursor(Cursor.HAND);
@@ -105,7 +117,7 @@
     }
 
     override bool handleButtonRelease(scope IViewport viewport, in ButtonEvent event) {
-        if (event.button_name == ButtonName.LEFT && _active) {
+        if (event.buttonName == ButtonName.LEFT && _active) {
             _active = false;
             viewport.damagePixel(feather(Rectangle(_anchorPoint, _currentPoint), LINE_WIDTH / 2.0));
             viewport.setCursor(Cursor.DEFAULT);
@@ -152,6 +164,6 @@
         bool _active;
         Point _currentPoint;
         Point _anchorPoint;      // Pixel
-        static invariant double LINE_WIDTH = 1.0;
+        static immutable double LINE_WIDTH = 1.0;
     }
 }
--- a/doodle/dia/tool.d	Sun Aug 08 22:01:54 2010 +0930
+++ b/doodle/dia/tool.d	Mon Aug 09 21:43:24 2010 +0930
@@ -6,31 +6,12 @@
     import doodle.tk.events;
 }
 
-/*
-interface IToolStack {
-    void push(Tool tool);
-    void pop();
-    void replace(Tool tool);
-}
-*/
-
 abstract class Tool {
-    /*
-    enum Response {
-    START, CONTINUE, FINISH
+    this (in string name) {
+        _name = name;
+    }
 
-    }
-    */
-
-    /*
-    abstract bool isSticky();
-    abstract bool isReplaceable();
-    */
-
-    /*
-    abstract void start(IToolStack tool_stack);
-    abstract void stop(IToolStack tool_stack);
-    */
+    string name() const { return _name; }
 
     bool handleButtonPress(scope IViewport viewport, in ButtonEvent event) { return false; }
     bool handleButtonRelease(scope IViewport viewport, in ButtonEvent event) { return false; }
@@ -45,4 +26,8 @@
 
     void draw(in IViewport viewport,
               in Rectangle pixelDamage, scope Context pixelCr) const { }
+
+    private {
+        immutable string _name;
+    }
 }
--- a/doodle/dia/tool_layer.d	Sun Aug 08 22:01:54 2010 +0930
+++ b/doodle/dia/tool_layer.d	Mon Aug 09 21:43:24 2010 +0930
@@ -5,17 +5,33 @@
 }
 
 private {
-    import std.stdio;
     import doodle.cairo.routines;
+    import doodle.core.logging;
+}
+
+// This interface is used by the palette
+interface IToolStack {
+    void use(Tool tool);
+}
+
+interface IToolStackObserver {
+    void toolChanged(int index);
 }
 
-interface IToolStack {
-}
-
-class ToolLayer : Layer, IEventHandler, IToolStack {
-    this(in Tool[] tools, in string name) {
+final class ToolLayer : Layer, IEventHandler, IToolStack {
+    this(in Tool[] tools, IToolStackObserver observer, in string name = "Tool") {
         super(name);
         _tools = tools.dup;
+        _observer = observer;
+    }
+
+    // IToolStack overrides:
+
+    void use(Tool tool) {
+        assert(_grabbedTool is null);
+        message("using new tool: %s", tool.name);
+        _tools ~= tool;
+        //_observer.toolChanged(_tools.length - 1);
     }
 
     // Layer overrides:
@@ -34,14 +50,14 @@
 
     // EventHandler overrides:
 
-    override bool handleButtonPress(scope IViewport viewport, in ButtonEvent event) {
+    bool handleButtonPress(scope IViewport viewport, in ButtonEvent event) {
         // writefln("%s", event);
 
         if (_grabbedTool is null) {
             foreach_reverse(ref tool; _tools) {
                 if (tool.handleButtonPress(viewport, event)) {
                     _grabbedTool = &tool;
-                    _grabbedButton = event.button_name;
+                    _grabbedButton = event.buttonName;
                     break;
                 }
             }
@@ -53,13 +69,13 @@
         return true;
     }
 
-    override bool handleButtonRelease(scope IViewport viewport, in ButtonEvent event) {
+    bool handleButtonRelease(scope IViewport viewport, in ButtonEvent event) {
         // writefln("%s", event);
 
         if (_grabbedTool !is null) {
             _grabbedTool.handleButtonRelease(viewport, event);
 
-            if (_grabbedButton == event.button_name) {
+            if (_grabbedButton == event.buttonName) {
                 _grabbedTool = null;
             }
         }
@@ -67,19 +83,19 @@
         return true;
     }
 
-    override bool handleKeyPress(scope IViewport viewport, in KeyEvent event) {
+    bool handleKeyPress(scope IViewport viewport, in KeyEvent event) {
         // writefln("%s", event);
 
         return true;
     }
 
-    override bool handleKeyRelease(scope IViewport viewport, in KeyEvent event) {
+    bool handleKeyRelease(scope IViewport viewport, in KeyEvent event) {
         // writefln("%s", event);
 
         return true;
     }
 
-    override bool handleMotion(scope IViewport viewport, in MotionEvent event) {
+    bool handleMotion(scope IViewport viewport, in MotionEvent event) {
         //writefln("%s", event);
 
         if (_grabbedTool is null) {
@@ -96,7 +112,7 @@
         return true;
     }
 
-    override bool handleScroll(scope IViewport viewport, in ScrollEvent event) {
+    bool handleScroll(scope IViewport viewport, in ScrollEvent event) {
         // writefln("%s", event);
 
         if (_grabbedTool is null) {
@@ -113,19 +129,10 @@
         return true;
     }
 
-    /*
-    override void push(Tool tool) {
-    }
-
-    override void pop() {
-    }
-
-    override void replace(Tool tool) {
-    }
-    */
-
     private {
         Tool[] _tools;
+        IToolStackObserver _observer;
+
         Tool * _grabbedTool;
         ButtonName _grabbedButton;
     }
--- a/doodle/fig/diagram_elements.d	Sun Aug 08 22:01:54 2010 +0930
+++ b/doodle/fig/diagram_elements.d	Mon Aug 09 21:43:24 2010 +0930
@@ -5,16 +5,21 @@
     import doodle.cairo.routines;
 }
 
+interface IDiagram {
+    void add(DiagramElement element);
+}
+
 abstract class DiagramElement {
     Rectangle bounds() const;
 
     void draw(in Rectangle damage, scope Context cr) const;
 
     private {
-        GraphElement _container;
+        //GraphElement _container;                // FIXME use an interface to the container
     }
 }
 
+/*
 abstract class SemanticModelBridge {
 };
 
@@ -26,35 +31,46 @@
     }
 }
 
-final class GraphConnector {
+class GraphConnector {
 }
 
-final class GraphNode : GraphElement {
+class GraphNode : GraphElement {
 }
 
-final class GraphEdge : GraphElement {
+class GraphEdge : GraphElement {
     private {
         GraphConnector[2] _anchors;
     }
 }
+*/
 
 abstract class LeafElement : DiagramElement {
 }
 
-final class TextElement : LeafElement {
+/*
+class TextElement : LeafElement {
 }
+*/
 
 abstract class GraphicPrimitive : LeafElement {
 }
 
-final class PolylinePrimitive : GraphicPrimitive {
+/*
+class PolylinePrimitive : GraphicPrimitive {
     private {
         Point[] _waypoints;
     }
 }
+*/
 
-final class RectanglePrimitive : GraphicPrimitive {
+class RectanglePrimitive : GraphicPrimitive {
     override void draw(in Rectangle damage, scope Context cr) const {
         rectangle(cr, bounds);
     }
+
+    override Rectangle bounds() const { return _bounds; }
+
+    private {
+        Rectangle _bounds;
+    }
 }
--- a/doodle/fig/diagram_layer.d	Sun Aug 08 22:01:54 2010 +0930
+++ b/doodle/fig/diagram_layer.d	Mon Aug 09 21:43:24 2010 +0930
@@ -6,11 +6,13 @@
     import std.array;
 }
 
-class DiagramLayer : Layer {
-    this(in string name) {
+class DiagramLayer : Layer, IDiagram {
+    this(in string name = "Diagram") {
         super(name);
     }
 
+    // IDiagram overrides
+
     void add(DiagramElement element) {
         _elements ~= element;
     }
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/doodle/fig/tools.d	Mon Aug 09 21:43:24 2010 +0930
@@ -0,0 +1,36 @@
+module doodle.fig.tools;
+
+private {
+    import doodle.dia.tool;
+    import doodle.fig.diagram_layer;
+}
+
+final class CreateRectangleTool : Tool {
+    this(IDiagram diagram) {
+        super("Create Rectangle");
+        _diagram = diagram;
+    }
+
+    // Tool overrides:
+
+    override bool handleButtonPress(scope IViewport viewport, in ButtonEvent event) {
+        if (event.buttonName == ButtonName.LEFT) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+
+    override bool handleButtonRelease(scope IViewport viewport, in ButtonEvent event) {
+        return true;
+    }
+
+    override bool handleMotion(scope IViewport viewport, in MotionEvent event) {
+        return true;
+    }
+
+    private {
+        IDiagram _diagram;
+    }
+}
--- a/doodle/gtk/canvas.d	Sun Aug 08 22:01:54 2010 +0930
+++ b/doodle/gtk/canvas.d	Mon Aug 09 21:43:24 2010 +0930
@@ -453,10 +453,10 @@
         }
 
         void updateRulers() {
-            invariant Vector modelSize = pixelToModel(_viewSize);
+            immutable Vector modelSize = pixelToModel(_viewSize);
 
-            invariant Point viewLeftBottom = _viewCentre - modelSize / 2.0;
-            invariant Point viewRightTop = _viewCentre + modelSize / 2.0;
+            immutable Point viewLeftBottom = _viewCentre - modelSize / 2.0;
+            immutable Point viewRightTop = _viewCentre + modelSize / 2.0;
 
             // Define these just to obtain the position
             // below and we can preserve it
@@ -476,10 +476,10 @@
         }
 
         void updateAdjustments() {
-            invariant Vector modelSize = pixelToModel(_viewSize);
+            immutable Vector modelSize = pixelToModel(_viewSize);
 
-            invariant Point viewLeftBottom = _viewCentre - modelSize / 2.0;
-            invariant Point viewRightTop = _viewCentre + modelSize / 2.0;
+            immutable Point viewLeftBottom = _viewCentre - modelSize / 2.0;
+            immutable Point viewRightTop = _viewCentre + modelSize / 2.0;
 
             // Adjust the canvas size if necessary
             _canvasBounds = Rectangle(minExtents(_canvasBounds.minCorner, viewLeftBottom),
--- a/doodle/main/prog/doodler.d	Sun Aug 08 22:01:54 2010 +0930
+++ b/doodle/main/prog/doodler.d	Mon Aug 09 21:43:24 2010 +0930
@@ -3,10 +3,13 @@
     import doodle.core.logging;
     import doodle.core.backtrace;
 
+    import doodle.dia.standard_tools;
+    import doodle.dia.page_layer;
+    import doodle.dia.grid_layer;
+    import doodle.fig.diagram_layer;
     import doodle.dia.tool_layer;
-    import doodle.dia.standard_tools;
-    import doodle.dia.grid_layer;
-    import doodle.dia.page_layer;
+
+    import doodle.fig.tools;
 
     import doodle.gtk.canvas;
     import doodle.gtk.palette;
@@ -18,33 +21,37 @@
     import std.stdio;
 }
 
-class TopLevel {
+final class TopLevel : private IToolStackObserver {
     this(string[] args) {
         Main.init(args);
         auto window = new MainWindow("Doodle");
         auto vbox = new VBox(false, 0);
 
         auto palette = new Palette;
+        _palette = palette;
         IPalette.Item[] items = [
         { "select.svg",    "Select",    "Select and modify elements", &paletteCallback },
         { "rectangle.svg", "Rectangle", "Create rectangle",           &paletteCallback },
         { "ellipse.svg",   "Ellipse",   "Create ellipse",             &paletteCallback },
         { "polyline.svg",  "Polyline",  "Create polyline",            &paletteCallback }
         ];
-        palette.configure(items);
+        _palette.configure(items);
         vbox.packStart(palette, false, false, 0);
 
         Tool[] tools;
         tools ~= new PanTool;
         tools ~= new ZoomTool;
         tools ~= new SelectTool;
-        auto toolLayer = new ToolLayer(tools, "Tools");
+        auto toolLayer = new ToolLayer(tools, this);
         _toolStack = toolLayer;
 
-        auto gridLayer = new GridLayer("Grid");
+        auto diagramLayer = new DiagramLayer;
+        _diagram = diagramLayer;
+
+        auto gridLayer = new GridLayer;
 
         Layer[] layers;
-        layers ~= new PageLayer("Page");
+        layers ~= new PageLayer;
         layers ~= gridLayer;
         layers ~= toolLayer;
         auto canvas = new Canvas(layers, toolLayer, gridLayer, 120.0);
@@ -56,8 +63,15 @@
         Main.run();
     }
 
+    void toolChanged(int index) {      // FIXME dmd bug? have to make this public
+        message("Tool changed %s", index);
+        _palette.activate(index);
+    }
+
     private {
         IToolStack _toolStack;
+        IPalette _palette;
+        IDiagram _diagram;
 
         void paletteCallback(int index) {
             switch (index) {
@@ -66,6 +80,7 @@
                 break;
             case 1:
                 // Rectangle
+                _toolStack.use(new CreateRectangleTool(_diagram));
                 break;
             case 2:
                 // Ellipse
@@ -77,6 +92,7 @@
                 assert(0);
             }
         }
+
     }
 }
 
--- a/doodle/tk/events.d	Sun Aug 08 22:01:54 2010 +0930
+++ b/doodle/tk/events.d	Mon Aug 09 21:43:24 2010 +0930
@@ -69,14 +69,14 @@
 */
 
 final class ButtonEvent : PointerEvent {
-    this(in ButtonAction button_action,
-         in ButtonName button_name,
+    this(in ButtonAction buttonAction,
+         in ButtonName buttonName,
          in Point pixelPoint,
          in Point modelPoint,
          in Mask mask) {   
         super(pixelPoint, modelPoint, mask);
-        _buttonAction = button_action;
-        _buttonName = button_name;
+        _buttonAction = buttonAction;
+        _buttonName = buttonName;
     }
 
     override string toString() const {
@@ -85,8 +85,8 @@
                                  _pixelPoint, _modelPoint, _mask);
     }
 
-    ButtonAction button_action() const { return _buttonAction; }
-    ButtonName button_name() const { return _buttonName; }
+    ButtonAction buttonAction() const { return _buttonAction; }
+    ButtonName buttonName() const { return _buttonName; }
 
     private {
         ButtonAction _buttonAction;