Mercurial > projects > doodle

changeset 84:cdd4fc728d94

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Renamed Drawable to Renderer
author daveb
date Mon, 16 Aug 2010 17:23:09 +0930
parents 06b4504cbcb0
children 98980cee8c5b
files doodle/dia/grid_layer.d doodle/dia/icanvas.d doodle/dia/layer_stack.d doodle/dia/page_layer.d doodle/dia/tool.d doodle/dia/tool_layer.d doodle/fig/diagram_elements.d doodle/fig/diagram_layer.d doodle/fig/select_tool.d doodle/gtk/cairo.d doodle/gtk/cairo_canvas.d doodle/gtk/cairo_renderer.d doodle/gtk/opengl.d doodle/tk/drawable.d doodle/tk/renderer.d
diffstat 15 files changed, 185 insertions(+), 185 deletions(-) [+]
line wrap: on
line diff
--- a/doodle/dia/grid_layer.d	Mon Aug 16 17:16:36 2010 +0930
+++ b/doodle/dia/grid_layer.d	Mon Aug 16 17:23:09 2010 +0930
@@ -30,8 +30,8 @@
         return Rectangle();
     }
 
-    override void draw(in Rectangle screenDamage, scope Drawable screenDrawable,
-                       in Rectangle modelDamage, scope Drawable modelDrawable) const {
+    override void draw(in Rectangle screenDamage, scope Renderer screenRenderer,
+                       in Rectangle modelDamage, scope Renderer modelRenderer) const {
         /+
         assert(_zoomValid);
 
--- a/doodle/dia/icanvas.d	Mon Aug 16 17:16:36 2010 +0930
+++ b/doodle/dia/icanvas.d	Mon Aug 16 17:23:09 2010 +0930
@@ -3,7 +3,7 @@
 public {
     import doodle.tk.geometry;
     import doodle.tk.events;
-    import doodle.tk.drawable;
+    import doodle.tk.renderer;
 }
 
 private {
@@ -67,8 +67,8 @@
 
     Rectangle bounds() const;
 
-    void draw(in Rectangle screenDamage, scope Drawable screenDrawable,
-              in Rectangle modelDamage, scope Drawable modelDrawable) const;
+    void draw(in Rectangle screenDamage, scope Renderer screenRenderer,
+              in Rectangle modelDamage, scope Renderer modelRenderer) const;
 
     private {
         immutable string _name;
--- a/doodle/dia/layer_stack.d	Mon Aug 16 17:16:36 2010 +0930
+++ b/doodle/dia/layer_stack.d	Mon Aug 16 17:23:09 2010 +0930
@@ -17,10 +17,10 @@
         return bounds;
     }
 
-    void draw(in Rectangle screenDamage, scope Drawable screenDrawable,
-              in Rectangle modelDamage, scope Drawable modelDrawable) {
+    void draw(in Rectangle screenDamage, scope Renderer screenRenderer,
+              in Rectangle modelDamage, scope Renderer modelRenderer) {
         foreach(layer; _layers) {
-            layer.draw(screenDamage, screenDrawable, modelDamage, modelDrawable);
+            layer.draw(screenDamage, screenRenderer, modelDamage, modelRenderer);
         }
     }
 
--- a/doodle/dia/page_layer.d	Mon Aug 16 17:16:36 2010 +0930
+++ b/doodle/dia/page_layer.d	Mon Aug 16 17:23:09 2010 +0930
@@ -20,19 +20,19 @@
         return _pageGeometry;
     }
 
-    override void draw(in Rectangle screenDamage, scope Drawable screenDrawable,
-                       in Rectangle modelDamage, scope Drawable modelDrawable) const {
+    override void draw(in Rectangle screenDamage, scope Renderer screenRenderer,
+                       in Rectangle modelDamage, scope Renderer modelRenderer) const {
         // Make the paper white, with a border
 
-        modelDrawable.pushState; {
-            modelDrawable.setColor(Color(0.0, 0.0, 0.0, 1.0));
-            modelDrawable.drawRectangle(_pageGeometry, false);
-        } modelDrawable.popState;
+        modelRenderer.pushState; {
+            modelRenderer.setColor(Color(0.0, 0.0, 0.0, 1.0));
+            modelRenderer.drawRectangle(_pageGeometry, false);
+        } modelRenderer.popState;
 
-        modelDrawable.pushState; {
-            modelDrawable.setColor(Color(1.0, 1.0, 1.0, 1.0));
-            modelDrawable.drawRectangle(_pageGeometry, true);
-        } modelDrawable.popState;
+        modelRenderer.pushState; {
+            modelRenderer.setColor(Color(1.0, 1.0, 1.0, 1.0));
+            modelRenderer.drawRectangle(_pageGeometry, true);
+        } modelRenderer.popState;
     }
 
     // IPage overrides:
--- a/doodle/dia/tool.d	Mon Aug 16 17:16:36 2010 +0930
+++ b/doodle/dia/tool.d	Mon Aug 16 17:23:09 2010 +0930
@@ -24,7 +24,7 @@
     //bool handleFocusIn(scope IViewport viewport, FocusEvent event) { return false; }
     //bool handleFocusOut(scope IViewport viewport, FocusEvent event) { return false; }
 
-    void draw(in Rectangle screenDamage, scope Drawable screenDrawable) const { }
+    void draw(in Rectangle screenDamage, scope Renderer screenRenderer) const { }
 
     private {
         immutable string _name;
--- a/doodle/dia/tool_layer.d	Mon Aug 16 17:16:36 2010 +0930
+++ b/doodle/dia/tool_layer.d	Mon Aug 16 17:23:09 2010 +0930
@@ -39,10 +39,10 @@
         return Rectangle();
     }
 
-    override void draw(in Rectangle screenDamage, scope Drawable screenDrawable,
-                       in Rectangle modelDamage, scope Drawable modelDrawable) const {
+    override void draw(in Rectangle screenDamage, scope Renderer screenRenderer,
+                       in Rectangle modelDamage, scope Renderer modelRenderer) const {
         if (_grabbedTool) {
-            _grabbedTool.draw(screenDamage, screenDrawable);
+            _grabbedTool.draw(screenDamage, screenRenderer);
         }
     }
 
--- a/doodle/fig/diagram_elements.d	Mon Aug 16 17:16:36 2010 +0930
+++ b/doodle/fig/diagram_elements.d	Mon Aug 16 17:23:09 2010 +0930
@@ -2,7 +2,7 @@
 
 private {
     import doodle.tk.geometry;
-    import doodle.tk.drawable;
+    import doodle.tk.renderer;
 }
 
 interface IDiagram {
@@ -12,7 +12,7 @@
 abstract class DiagramElement {
     Rectangle bounds() const;
 
-    void draw(in Rectangle damage, scope Drawable cr) const;
+    void draw(in Rectangle damage, scope Renderer cr) const;
 
     private {
         //GraphElement _container;                // FIXME use an interface to the container
@@ -64,7 +64,7 @@
  */
 
 final class RectanglePrimitive : GraphicPrimitive {
-    override void draw(in Rectangle damage, scope Drawable drawable) const {
+    override void draw(in Rectangle damage, scope Renderer drawable) const {
         drawable.drawRectangle(bounds, false);
     }
 
--- a/doodle/fig/diagram_layer.d	Mon Aug 16 17:16:36 2010 +0930
+++ b/doodle/fig/diagram_layer.d	Mon Aug 16 17:23:09 2010 +0930
@@ -23,11 +23,11 @@
         return Rectangle.DEFAULT;
     }
 
-    override void draw(in Rectangle screenDamage, scope Drawable screenDrawable,
-                       in Rectangle modelDamage, scope Drawable modelDrawable) const {
+    override void draw(in Rectangle screenDamage, scope Renderer screenRenderer,
+                       in Rectangle modelDamage, scope Renderer modelRenderer) const {
         foreach (e; _elements) {
             if ((e.bounds & modelDamage).valid) {
-                e.draw(modelDamage, modelDrawable);
+                e.draw(modelDamage, modelRenderer);
             }
         }
     }
--- a/doodle/fig/select_tool.d	Mon Aug 16 17:16:36 2010 +0930
+++ b/doodle/fig/select_tool.d	Mon Aug 16 17:23:09 2010 +0930
@@ -43,14 +43,14 @@
         return false;
     }
 
-    override void draw(in Rectangle screenDamage, scope Drawable screenDrawable) const {
+    override void draw(in Rectangle screenDamage, scope Renderer screenRenderer) const {
         if (_active) {
-            screenDrawable.pushState; {
-                screenDrawable.setLineStyle(Drawable.LineStyle.DASHED);
-                screenDrawable.setLineWidth(LINE_WIDTH);
-                screenDrawable.setColor(Color(0.0, 0.0, 0.5, 1.0));
-                screenDrawable.drawRectangle(Rectangle(_currentPoint, _anchorPoint), false);
-            } screenDrawable.popState;
+            screenRenderer.pushState; {
+                screenRenderer.setLineStyle(Renderer.LineStyle.DASHED);
+                screenRenderer.setLineWidth(LINE_WIDTH);
+                screenRenderer.setColor(Color(0.0, 0.0, 0.5, 1.0));
+                screenRenderer.drawRectangle(Rectangle(_currentPoint, _anchorPoint), false);
+            } screenRenderer.popState;
         }
     }
 
--- a/doodle/gtk/cairo.d	Mon Aug 16 17:16:36 2010 +0930
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,97 +0,0 @@
-module doodle.gtk.cairo;
-
-public {
-    import doodle.tk.drawable;
-    import cairo.Context;
-}
-
-final class CairoDrawable : Drawable {
-    this(Context cr) {
-        assert(cr);
-        _cr = cr;
-    }
-
-    // Drawing overrides:
-
-    void setLineStyle(LineStyle style) {
-        switch (style) {
-        case LineStyle.SOLID:
-            _cr.setDash([ ], 0.0);
-            break;
-        case LineStyle.DASHED:
-            _cr.setDash([ 4.0, 4.0 ], 0.0);
-            break;
-        case LineStyle.DOTTED:
-            _cr.setDash([ 1.0, 4.0 ], 0.0);
-            break;
-        default:
-            assert(0);
-        }
-    }
-
-    void setLineWidth(in double width) { _cr.setLineWidth(width); }
-
-    void setColor(in Color color) { _cr.setSourceRgba(color.r, color.g, color.b, color.a); }
-
-    void translate(in Point p) { _cr.translate(p.x, p.y); }
-    void scale(in double s) { _cr.scale(s, s); }
-
-    void pushState() { _cr.save; }
-    void popState() { _cr.restore; }
-
-    void drawRectangle(in Rectangle rectangle, bool fill = false) {
-        _cr.rectangle(rectangle.position.x, rectangle.position.y,
-                      rectangle.size.x, rectangle.size.y);
-        if (fill) { _cr.fill; } else { _cr.stroke; }
-    }
-
-    void drawEllipse(in Rectangle rectangle, bool fill = false) {
-        // NYI
-    }
-
-    void drawSegment(in Segment segment) {
-        _cr.moveTo(segment.begin.x, segment.begin.y);
-        _cr.lineTo(segment.end.x, segment.end.y);
-        _cr.stroke;
-    }
-
-    void drawHLine(in double y, in double x0, in double x1) {
-        _cr.moveTo(x0, y);
-        _cr.lineTo(x1, y);
-        _cr.stroke;
-    }
-
-    void drawVLine(in double x, in double y0, in double y1) {
-        _cr.moveTo(x, y0);
-        _cr.lineTo(x, y1);
-    }
-
-    void drawPoly(in Point[] points, bool fill = false) {
-        assert(points.length >= 2);
-        foreach(i, p; points) {
-            if (i == 0) { _cr.moveTo(p.x, p.y); }
-            else { _cr.lineTo(p.x, p.y); }
-        }
-        if (fill) { _cr.fill; } else { _cr.stroke; }
-    }
-
-    void setFontFace(in FontFace face) {
-        // NYI
-    }
-
-    void setFontSize(in double size) {
-        // NYI
-    }
-
-    void drawText(in string text) {
-        // NYI
-    }
-
-    void measureText(in string text, out Rectangle logicalBounds, out Rectangle totalBounds) const {
-        // NYI
-    }
-
-    private {
-        Context _cr;
-    }
-}
--- a/doodle/gtk/cairo_canvas.d	Mon Aug 16 17:16:36 2010 +0930
+++ b/doodle/gtk/cairo_canvas.d	Mon Aug 16 17:23:09 2010 +0930
@@ -9,7 +9,7 @@
     import doodle.core.logging;
     import doodle.tk.screen_model;
     import doodle.dia.layer_stack;
-    import doodle.gtk.cairo;
+    import doodle.gtk.cairo_renderer;
 
     import cairo.Surface;
     import cairo.Context;
@@ -208,7 +208,7 @@
         bool onExpose(GdkEventExpose * event, Widget widget) {
             assert(widget is _drawingArea);
 
-            gdk.Drawable.Drawable dr = _drawingArea.getWindow;
+            Drawable dr = _drawingArea.getWindow;
 
             int width, height;
             dr.getSize(width, height);
@@ -253,8 +253,8 @@
                     screenCr.fill;
                 } screenCr.restore;
 
-                _layerStack.draw(screenDamage, new CairoDrawable(screenCr),
-                                 modelDamage, new CairoDrawable(modelCr));
+                _layerStack.draw(screenDamage, new CairoRenderer(screenCr),
+                                 modelDamage, new CairoRenderer(modelCr));
             } screenCr.restore; modelCr.restore;
 
             return true;
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/doodle/gtk/cairo_renderer.d	Mon Aug 16 17:23:09 2010 +0930
@@ -0,0 +1,97 @@
+module doodle.gtk.cairo_renderer;
+
+public {
+    import doodle.tk.renderer;
+    import cairo.Context;
+}
+
+final class CairoRenderer : Renderer {
+    this(Context cr) {
+        assert(cr);
+        _cr = cr;
+    }
+
+    // Drawing overrides:
+
+    void setLineStyle(LineStyle style) {
+        switch (style) {
+        case LineStyle.SOLID:
+            _cr.setDash([ ], 0.0);
+            break;
+        case LineStyle.DASHED:
+            _cr.setDash([ 4.0, 4.0 ], 0.0);
+            break;
+        case LineStyle.DOTTED:
+            _cr.setDash([ 1.0, 4.0 ], 0.0);
+            break;
+        default:
+            assert(0);
+        }
+    }
+
+    void setLineWidth(in double width) { _cr.setLineWidth(width); }
+
+    void setColor(in Color color) { _cr.setSourceRgba(color.r, color.g, color.b, color.a); }
+
+    void translate(in Point p) { _cr.translate(p.x, p.y); }
+    void scale(in double s) { _cr.scale(s, s); }
+
+    void pushState() { _cr.save; }
+    void popState() { _cr.restore; }
+
+    void drawRectangle(in Rectangle rectangle, bool fill = false) {
+        _cr.rectangle(rectangle.position.x, rectangle.position.y,
+                      rectangle.size.x, rectangle.size.y);
+        if (fill) { _cr.fill; } else { _cr.stroke; }
+    }
+
+    void drawEllipse(in Rectangle rectangle, bool fill = false) {
+        // NYI
+    }
+
+    void drawSegment(in Segment segment) {
+        _cr.moveTo(segment.begin.x, segment.begin.y);
+        _cr.lineTo(segment.end.x, segment.end.y);
+        _cr.stroke;
+    }
+
+    void drawHLine(in double y, in double x0, in double x1) {
+        _cr.moveTo(x0, y);
+        _cr.lineTo(x1, y);
+        _cr.stroke;
+    }
+
+    void drawVLine(in double x, in double y0, in double y1) {
+        _cr.moveTo(x, y0);
+        _cr.lineTo(x, y1);
+    }
+
+    void drawPoly(in Point[] points, bool fill = false) {
+        assert(points.length >= 2);
+        foreach(i, p; points) {
+            if (i == 0) { _cr.moveTo(p.x, p.y); }
+            else { _cr.lineTo(p.x, p.y); }
+        }
+        if (fill) { _cr.fill; } else { _cr.stroke; }
+    }
+
+    void setFontFace(in FontFace face) {
+        // NYI
+    }
+
+    void setFontSize(in double size) {
+        // NYI
+    }
+
+    void drawText(in string text) {
+        // NYI
+    }
+
+    void measureText(in string text, out Rectangle logicalBounds, out Rectangle totalBounds) const {
+        // NYI
+    }
+
+    private {
+        Context _cr;
+    }
+}
--- a/doodle/gtk/opengl.d	Mon Aug 16 17:16:36 2010 +0930
+++ b/doodle/gtk/opengl.d	Mon Aug 16 17:23:09 2010 +0930
@@ -1,11 +1,11 @@
 module doodle.gtk.opengl;
 
 public {
-    import doodle.tk.drawable;
+    import doodle.tk.renderer;
 }
 
 /*
-final class OpenGLDrawing : Drawable {
+final class OpenGLRenderer : Renderer {
 
     // Drawing overrides:
 
--- a/doodle/tk/drawable.d	Mon Aug 16 17:16:36 2010 +0930
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,47 +0,0 @@
-module doodle.tk.drawable;
-
-public {
-    import doodle.tk.geometry;
-    import doodle.tk.color;
-}
-
-interface Drawable {
-    enum LineStyle {
-        SOLID,
-        DASHED,
-        DOTTED
-    }
-
-    enum FontFace {
-        NORMAL
-    }
-
-    // Low-level state manipulation
-
-    void setLineStyle(LineStyle style);
-    void setLineWidth(in double width);
-    void setColor(in Color color);
-
-    void translate(in Point p);
-    void scale(in double s);
-
-    void pushState();           // Copies all of current state
-    void popState();            // Restores all of previous state
-
-    // High-level drawing routines
-
-    void drawRectangle(in Rectangle rectangle, bool fill);
-    void drawEllipse(in Rectangle rectangle, bool fill);
-    void drawSegment(in Segment segment);
-    void drawHLine(in double y, in double x0, in double x1);
-    void drawVLine(in double x, in double y0, in double y1);
-    void drawPoly(in Point[] points, bool fill);
-
-    // Text routines
-
-    void setFontFace(in FontFace face);
-    void setFontSize(in double size);
-    void drawText(in string text);
-
-    void measureText(in string text, out Rectangle logicalBounds, out Rectangle totalBounds) const;
-}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/doodle/tk/renderer.d	Mon Aug 16 17:23:09 2010 +0930
@@ -0,0 +1,47 @@
+module doodle.tk.renderer;
+
+public {
+    import doodle.tk.geometry;
+    import doodle.tk.color;
+}
+
+interface Renderer {
+    enum LineStyle {
+        SOLID,
+        DASHED,
+        DOTTED
+    }
+
+    enum FontFace {
+        NORMAL
+    }
+
+    // Low-level state manipulation
+
+    void setLineStyle(LineStyle style);
+    void setLineWidth(in double width);
+    void setColor(in Color color);
+
+    void translate(in Point p);
+    void scale(in double s);
+
+    void pushState();           // Copies all of current state
+    void popState();            // Restores all of previous state
+
+    // High-level drawing routines
+
+    void drawRectangle(in Rectangle rectangle, bool fill);
+    void drawEllipse(in Rectangle rectangle, bool fill);
+    void drawSegment(in Segment segment);
+    void drawHLine(in double y, in double x0, in double x1);
+    void drawVLine(in double x, in double y0, in double y1);
+    void drawPoly(in Point[] points, bool fill);
+
+    // Text routines
+
+    void setFontFace(in FontFace face);
+    void setFontSize(in double size);
+    void drawText(in string text);
+
+    void measureText(in string text, out Rectangle logicalBounds, out Rectangle totalBounds) const;
+}