Mercurial > projects > doodle

changeset 81:d92b9f04b1e8

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Bed time
author "David Bryant <bagnose@gmail.com>"
date Mon, 16 Aug 2010 00:04:27 +0930
parents b759414d2b72
children 0314b2e03f9b
files doodle/dia/grid_layer.d doodle/dia/page_layer.d doodle/dia/tool_layer.d doodle/fig/select_tool.d doodle/gtk/cairo.d doodle/gtk/canvas.d doodle/gtk/events.d doodle/tk/cairo.d doodle/tk/events.d doodle/tk/pixel_model.d doodle/tk/screen_model.d
diffstat 11 files changed, 89 insertions(+), 146 deletions(-) [+]
line wrap: on
line diff
--- a/doodle/dia/grid_layer.d	Sun Aug 15 23:43:04 2010 +0930
+++ b/doodle/dia/grid_layer.d	Mon Aug 16 00:04:27 2010 +0930
@@ -5,9 +5,7 @@
 }
 
 private {
-    import doodle.tk.cairo;
     import std.math;
-    import std.stdio;
 }
 
 private {
--- a/doodle/dia/page_layer.d	Sun Aug 15 23:43:04 2010 +0930
+++ b/doodle/dia/page_layer.d	Mon Aug 16 00:04:27 2010 +0930
@@ -5,7 +5,6 @@
 }
 
 private {
-    import doodle.tk.cairo;
 }
 
 class PageLayer : Layer, IPage {
--- a/doodle/dia/tool_layer.d	Sun Aug 15 23:43:04 2010 +0930
+++ b/doodle/dia/tool_layer.d	Mon Aug 16 00:04:27 2010 +0930
@@ -5,7 +5,6 @@
 }
 
 private {
-    import doodle.tk.cairo;
     import doodle.core.logging;
 }
 
--- a/doodle/fig/select_tool.d	Sun Aug 15 23:43:04 2010 +0930
+++ b/doodle/fig/select_tool.d	Mon Aug 16 00:04:27 2010 +0930
@@ -4,10 +4,6 @@
     import doodle.dia.tool;
 }
 
-private {
-    import doodle.tk.cairo;
-}
-
 final class SelectTool : Tool {
     this() {
         super("Select");
@@ -49,37 +45,19 @@
 
     override void draw(in Rectangle screenDamage, scope Drawable screenDrawable) const {
         if (_active) {
-            /*
-               screenCr.save; {
-               screenCr.setSourceRgba(0.0, 0.0, 0.8, 0.3);
-               rectangle(screenCr, Rectangle(_currentPoint, _anchorPoint));
-               screenCr.fill();
-               } screenCr.restore();
-             */
-
             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;
-
-            /*
-            screenCr.save(); {
-                double[] dashes = [ 4.0, 4.0 ];
-                screenCr.setDash(dashes, 0.0);
-                screenCr.setSourceRgba(0.0, 0.0, 0.5, 1.0);
-                screenCr.setLineWidth(LINE_WIDTH);
-                rectangle(screenCr, Rectangle(_currentPoint, _anchorPoint));
-                screenCr.stroke;
-            } screenCr.restore;
-            */
         }
     }
 
     private {
         bool _active;
         Point _currentPoint;
-        Point _anchorPoint;      // Pixel
+        Point _anchorPoint;
         static immutable double LINE_WIDTH = 1.0;
     }
 }
--- a/doodle/gtk/cairo.d	Sun Aug 15 23:43:04 2010 +0930
+++ b/doodle/gtk/cairo.d	Mon Aug 16 00:04:27 2010 +0930
@@ -16,13 +16,13 @@
     void setLineStyle(LineStyle style) {
         switch (style) {
         case LineStyle.SOLID:
-            _cr.setDash([ 4.0, 4.0 ], 0.0);
+            _cr.setDash([ ], 0.0);
             break;
         case LineStyle.DASHED:
             _cr.setDash([ 4.0, 4.0 ], 0.0);
             break;
         case LineStyle.DOTTED:
-            _cr.setDash([ 4.0, 4.0 ], 0.0);
+            _cr.setDash([ 1.0, 4.0 ], 0.0);
             break;
         default:
             assert(0);
@@ -39,13 +39,13 @@
     void pushState() { _cr.save; }
     void popState() { _cr.restore; }
 
-    void drawRectangle(in Rectangle rectangle, bool fill) {
+    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) {
+    void drawEllipse(in Rectangle rectangle, bool fill = false) {
         // NYI
     }
 
@@ -66,7 +66,7 @@
         _cr.lineTo(x, y1);
     }
 
-    void drawPoly(in Point[] points, bool fill) {
+    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); }
--- a/doodle/gtk/canvas.d	Sun Aug 15 23:43:04 2010 +0930
+++ b/doodle/gtk/canvas.d	Mon Aug 16 00:04:27 2010 +0930
@@ -3,17 +3,17 @@
 public {
     import doodle.dia.icanvas;
     import doodle.gtk.events;
-    import doodle.gtk.cairo;
 }
 
 private {
     import doodle.core.logging;
-    import doodle.tk.pixel_model;
-    import doodle.tk.cairo;
+    import doodle.tk.screen_model;
     import doodle.dia.layer_stack;
     import doodle.gtk.conversions;
+    import doodle.gtk.cairo;
 
     import cairo.Surface;
+    import cairo.Context;
 
     import gtk.Widget;
     import gtk.Toolbar;
@@ -70,13 +70,13 @@
         _drawingArea.addOnRealize(&onRealize);
         _drawingArea.addOnConfigure(&onConfigure);
         _drawingArea.addOnExpose(&onExpose);
-        _drawingArea.addOnButtonPress(&onButtonPress);              // FIXME merge delegate with next
+        _drawingArea.addOnButtonPress(&onButtonPress);
         _drawingArea.addOnButtonRelease(&onButtonRelease);
-        _drawingArea.addOnKeyPress(&onKeyPressEvent);               // FIXME merge delegate with next
+        _drawingArea.addOnKeyPress(&onKeyPressEvent);
         _drawingArea.addOnKeyRelease(&onKeyReleaseEvent);
         _drawingArea.addOnMotionNotify(&onMotionNotify);
         _drawingArea.addOnScroll(&onScroll);
-        _drawingArea.addOnEnterNotify(&onEnterNotify);              // FIXME merge delegate with next
+        _drawingArea.addOnEnterNotify(&onEnterNotify);
         _drawingArea.addOnLeaveNotify(&onLeaveNotify);
 
         _drawingArea.addOnFocusIn(&onFocusIn);
@@ -234,7 +234,7 @@
                     immutable Point viewLeftBottom = _screenModel.screenToModel(Point(0.0, 0.0));
                     modelCr.translate(-viewLeftBottom.x, -viewLeftBottom.y);
 
-                    rectangle(modelCr, modelDamage);
+                    modelCr.rectangle(modelDamage.x0, modelDamage.y0, modelDamage.w, modelDamage.h);
                     modelCr.clip;
                 }
 
@@ -243,14 +243,14 @@
                     screenCr.translate(0.0, _screenModel.viewBoundsScreen.h);
                     screenCr.scale(1.0, -1.0);
 
-                    rectangle(screenCr, screenDamage);
+                    screenCr.rectangle(screenDamage.x0, screenDamage.y0, screenDamage.w, screenDamage.h);
                     screenCr.clip;
                 }
 
                 screenCr.save; {
                     // Fill the background with light grey
                     screenCr.setSourceRgba(0.9, 0.9, 0.9, 1.0);
-                    rectangle(screenCr, screenDamage);
+                    screenCr.rectangle(screenDamage.x0, screenDamage.y0, screenDamage.w, screenDamage.h);
                     screenCr.fill;
                 } screenCr.restore;
 
@@ -368,7 +368,7 @@
             immutable Point viewRightTop = _screenModel.screenToModel(_screenModel.viewBoundsScreen.corner1);
 
             // Define these just to obtain the position
-            // below and we can preserve it
+            // below so we can preserve it
             double lower, upper, position, maxSize;
 
             _hRuler.getRange(lower, upper, position, maxSize);
@@ -437,8 +437,6 @@
         double        _pixelsPerMillimetre;
         LayerStack    _layerStack;
 
-        immutable CursorType[Cursor] _cursors;
-
         // Child widgets:
         HRuler        _hRuler;
         VRuler        _vRuler;
@@ -450,5 +448,7 @@
 
         Rectangle     _damageScreen;
         ScreenModel   _screenModel;
+
+        immutable CursorType[Cursor] _cursors;
     }
 }
--- a/doodle/gtk/events.d	Sun Aug 15 23:43:04 2010 +0930
+++ b/doodle/gtk/events.d	Mon Aug 16 00:04:27 2010 +0930
@@ -6,7 +6,6 @@
 
 private {
     import doodle.gtk.conversions;
-
     import core.stdc.string : strlen;
 }
 
--- a/doodle/tk/cairo.d	Sun Aug 15 23:43:04 2010 +0930
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,30 +0,0 @@
-module doodle.tk.cairo;
-
-// THIS module is deprecated
-
-public {
-    import doodle.tk.geometry;
-    import cairo.Context;
-}
-
-void rectangle(scope Context cr, in Rectangle rectangle) {
-    cr.rectangle(rectangle.position.x, rectangle.position.y,
-                 rectangle.size.x, rectangle.size.y);
-}
-
-void line(scope Context cr, in double x0, in double y0, in double x1, in double y1) {
-    cr.moveTo(x0, y0);
-    cr.lineTo(x1, y1);
-}
-
-// Horizontal line
-void hline(scope Context cr, in double y, double x0, double x1) {
-    cr.moveTo(x0, y);
-    cr.lineTo(x1, y);
-}
-
-// Vertical line
-void vline(scope Context cr, in double x, double y0, double y1) {
-    cr.moveTo(x, y0);
-    cr.lineTo(x, y1);
-}
--- a/doodle/tk/events.d	Sun Aug 15 23:43:04 2010 +0930
+++ b/doodle/tk/events.d	Mon Aug 16 00:04:27 2010 +0930
@@ -2,7 +2,7 @@
 
 public {
     import doodle.tk.geometry;
-    import doodle.tk.pixel_model;
+    import doodle.tk.screen_model;
     import gtkc.gdktypes;
 }
 
--- a/doodle/tk/pixel_model.d	Sun Aug 15 23:43:04 2010 +0930
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,69 +0,0 @@
-module doodle.tk.screen_model;
-
-public {
-    import doodle.tk.geometry;
-}
-
-private {
-    import doodle.core.misc;
-}
-
-// This class manages the relationship between screen space and model space.
-// Screen is defined as the current window/viewport into the model
-// It provides convenient high-level operations.
-//
-// x and y run right and up respectively for screen and model space
-
-class ScreenModel {
-    this(in double zoom, in Rectangle canvasBoundsModel, in Rectangle viewBoundsScreen) {
-        _zoom = zoom;
-        _viewBoundsScreen = viewBoundsScreen;
-        _canvasBoundsModel = canvasBoundsModel;
-
-        // Choose the centre of the canvas as the centre of the view
-        _viewCentreModel = _canvasBoundsModel.centre;
-    }
-
-    void consolidateCanvasBounds(in Rectangle requiredCanvasBounds) { _canvasBoundsModel = screenToModel(_viewBoundsScreen) | requiredCanvasBounds; }
-    void canvasAccommodate(in Rectangle bounds) { _canvasBoundsModel = _canvasBoundsModel | bounds; }
-
-    void zoomRelative(in double factor, in Point screenDatum) {
-        // Work out screen distance from current centre to datum,
-        // Do the zoom, then work out the new centre that keeps the
-        // screen distance the same
-
-        Point oldModelDatum = screenToModel(screenDatum);
-        Vector screenDistance = modelToScreen(oldModelDatum - _viewCentreModel);
-        _zoom = clampZoom(zoom * factor);
-        _viewCentreModel = oldModelDatum - screenToModel(screenDistance);
-    }
-
-    void panRelativeScreen(in Vector screenDisplacement) { _viewCentreModel = _viewCentreModel + screenToModel(screenDisplacement); }
-    void panRelativeModel(in Vector modelDisplacement) { _viewCentreModel = _viewCentreModel + modelDisplacement; }
-
-    // For userZoom 1.0 -> 100% means the presentation on the screen is one-to-one with real-life
-    double userZoom(in double pixelsPerMillimetre) const { return _zoom / pixelsPerMillimetre; }
-    double zoom() const { return _zoom; }
-    Rectangle viewBoundsScreen() const { return _viewBoundsScreen; }
-    Rectangle viewBoundsModel() const { return screenToModel(_viewBoundsScreen); }
-    Rectangle canvasBoundsModel() const { return _canvasBoundsModel; }
-    Rectangle canvasBoundsScreen() const { return modelToScreen(_canvasBoundsModel); }
-
-    Point modelToScreen(in Point model) const { return _viewBoundsScreen.centre + _zoom * (model - _viewCentreModel); }
-    Point screenToModel(in Point screen) const { return _viewCentreModel + (screen - _viewBoundsScreen.centre) / _zoom; }
-    Vector modelToScreen(in Vector model) const { return _zoom * model; }
-    Vector screenToModel(in Vector screen) const { return screen / _zoom; }
-    Rectangle modelToScreen(in Rectangle model) const { return Rectangle(modelToScreen(model.position), modelToScreen(model.size)); }
-    Rectangle screenToModel(in Rectangle model) const { return Rectangle(screenToModel(model.position), screenToModel(model.size)); }
-
-    private {
-        static double clampZoom(in double zoom) { return clamp(zoom, 1e-1, 1e2); }
-
-        // Screen units are pixels
-        // Model units are millimetres
-        double    _zoom;                // pixels-per-millimetre
-        Rectangle _viewBoundsScreen;    // bounds of the viewport in screen space
-        Point     _viewCentreModel;     // where in the model is the centre of our screen
-        Rectangle _canvasBoundsModel;   // the bounds of the canvas in model space
-    }
-}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/doodle/tk/screen_model.d	Mon Aug 16 00:04:27 2010 +0930
@@ -0,0 +1,69 @@
+module doodle.tk.screen_model;
+
+public {
+    import doodle.tk.geometry;
+}
+
+private {
+    import doodle.core.misc;
+}
+
+// This class manages the relationship between screen space and model space.
+// Screen is defined as the current window/viewport into the model
+// It provides convenient high-level operations.
+//
+// x and y run right and up respectively for screen and model space
+
+class ScreenModel {
+    this(in double zoom, in Rectangle canvasBoundsModel, in Rectangle viewBoundsScreen) {
+        _zoom = zoom;
+        _viewBoundsScreen = viewBoundsScreen;
+        _canvasBoundsModel = canvasBoundsModel;
+
+        // Choose the centre of the canvas as the centre of the view
+        _viewCentreModel = _canvasBoundsModel.centre;
+    }
+
+    void consolidateCanvasBounds(in Rectangle requiredCanvasBounds) { _canvasBoundsModel = screenToModel(_viewBoundsScreen) | requiredCanvasBounds; }
+    void canvasAccommodate(in Rectangle bounds) { _canvasBoundsModel = _canvasBoundsModel | bounds; }
+
+    void zoomRelative(in double factor, in Point screenDatum) {
+        // Work out screen distance from current centre to datum,
+        // Do the zoom, then work out the new centre that keeps the
+        // screen distance the same
+
+        Point oldModelDatum = screenToModel(screenDatum);
+        Vector screenDistance = modelToScreen(oldModelDatum - _viewCentreModel);
+        _zoom = clampZoom(zoom * factor);
+        _viewCentreModel = oldModelDatum - screenToModel(screenDistance);
+    }
+
+    void panRelativeScreen(in Vector screenDisplacement) { _viewCentreModel = _viewCentreModel + screenToModel(screenDisplacement); }
+    void panRelativeModel(in Vector modelDisplacement) { _viewCentreModel = _viewCentreModel + modelDisplacement; }
+
+    // For userZoom 1.0 -> 100% means the presentation on the screen is one-to-one with real-life
+    double userZoom(in double pixelsPerMillimetre) const { return _zoom / pixelsPerMillimetre; }
+    double zoom() const { return _zoom; }
+    Rectangle viewBoundsScreen() const { return _viewBoundsScreen; }
+    Rectangle viewBoundsModel() const { return screenToModel(_viewBoundsScreen); }
+    Rectangle canvasBoundsModel() const { return _canvasBoundsModel; }
+    Rectangle canvasBoundsScreen() const { return modelToScreen(_canvasBoundsModel); }
+
+    Point modelToScreen(in Point model) const { return _viewBoundsScreen.centre + _zoom * (model - _viewCentreModel); }
+    Point screenToModel(in Point screen) const { return _viewCentreModel + (screen - _viewBoundsScreen.centre) / _zoom; }
+    Vector modelToScreen(in Vector model) const { return _zoom * model; }
+    Vector screenToModel(in Vector screen) const { return screen / _zoom; }
+    Rectangle modelToScreen(in Rectangle model) const { return Rectangle(modelToScreen(model.position), modelToScreen(model.size)); }
+    Rectangle screenToModel(in Rectangle model) const { return Rectangle(screenToModel(model.position), screenToModel(model.size)); }
+
+    private {
+        static double clampZoom(in double zoom) { return clamp(zoom, 1e-1, 1e2); }
+
+        // Screen units are pixels
+        // Model units are millimetres
+        double    _zoom;                // pixels-per-millimetre
+        Rectangle _viewBoundsScreen;    // bounds of the viewport in screen space
+        Point     _viewCentreModel;     // where in the model is the centre of our screen
+        Rectangle _canvasBoundsModel;   // the bounds of the canvas in model space
+    }
+}