projects/doodle: doodle/gtk/cairo

comparison doodle/gtk/cairo_canvas.d @ 136:752676232e4b

Port to GtkD-2.0 (gtk+3)

author	David Bryant <bagnose@gmail.com>
date	Wed, 26 Sep 2012 17:36:31 +0930
parents	bc5baa585b32
children

comparison

equal deleted inserted replaced

-:be50d20643a1
+:752676232e4b
 import cairo.Context;
 import gtk.Widget;
 import gtk.Toolbar;
 import gtk.Table;
-import gtk.HRuler;
+import gtk.Label;
-import gtk.VRuler;
+alias gtk.Label.Label HRuler;
+alias gtk.Label.Label VRuler;
 import gtk.Range;
 import gtk.HScrollbar;
 import gtk.VScrollbar;
 import gtk.DrawingArea;
 import gtk.Adjustment;
-import gdk.Drawable;
 import gtkc.gtk;
 import gtkc.gtktypes;
 //import gtkc.gdktypes;
 import std.math;
 import std.stdio;
+import core.thread;
 }
+// Bring doodle.tk.geometry.Rectangle into local namespace so we
+// get it instead of gdk.Rectangle.Rectangle
+alias doodle.tk.geometry.Rectangle Rectangle;
 final class CairoCanvas : Table, IViewport {
 static this() {
 _cursors = [
 Cursor.DEFAULT   : CursorType.ARROW,
 _layerStack = new LayerStack(layers);
 // Create our child widgets and register callbacks
-_hRuler = new HRuler;
+_hRuler = new HRuler("horizontal");
 attach(_hRuler,
 1, 2,
 0, 1,
 AttachOptions.FILL | AttachOptions.EXPAND, AttachOptions.SHRINK,
 0, 0);
-_hRuler.setMetric(MetricType.PIXELS);
+//_hRuler.setMetric(MetricType.PIXELS);
-_vRuler = new VRuler;
+_vRuler = new VRuler("vertical");
 attach(_vRuler,
 0, 1,
 1, 2,
 AttachOptions.SHRINK, AttachOptions.FILL | AttachOptions.EXPAND,
 0, 0);
-_vRuler.setMetric(MetricType.PIXELS);
+//_vRuler.setMetric(MetricType.PIXELS);
 _drawingArea = new DrawingArea;
 _drawingArea.addOnRealize(&onRealize);
 _drawingArea.addOnConfigure(&onConfigure);
-_drawingArea.addOnExpose(&onExpose);
+_drawingArea.addOnDraw(&onDraw);
 _drawingArea.addOnButtonPress(&onButtonPress);
 _drawingArea.addOnButtonRelease(&onButtonRelease);
 _drawingArea.addOnKeyPress(&onKeyPressEvent);
 _drawingArea.addOnKeyRelease(&onKeyReleaseEvent);
 _drawingArea.addOnMotionNotify(&onMotionNotify);
 _drawingArea.addOnGrabFocus(&onGrabFocus);
 _drawingArea.addOnGrabNotify(&onGrabNotify);
 // addOnPopupMenu
 // addOnQueryTooltip
 // addOnSelection*
-_drawingArea.setEvents(EventMask.EXPOSURE_MASK |
+_drawingArea.setEvents(EventMask.POINTER_MOTION_MASK |
-EventMask.POINTER_MOTION_MASK |
 EventMask.POINTER_MOTION_HINT_MASK |
 EventMask.BUTTON_MOTION_MASK |
 EventMask.BUTTON_PRESS_MASK |
 EventMask.BUTTON_RELEASE_MASK |
 EventMask.KEY_PRESS_MASK |
 void setCursor(in Cursor cursor) {
 _drawingArea.setCursor(new gdk.Cursor.Cursor(_cursors[cursor]));
 }
 void damageModel(in Rectangle area) {
-_damageScreen = _damageScreen | _screenModel.modelToScreen(area);
+_tmpDamageScreen = _tmpDamageScreen | _screenModel.modelToScreen(area);
 }
 void damageScreen(in Rectangle area) {
-_damageScreen = _damageScreen | area;
+_tmpDamageScreen = _tmpDamageScreen | area;
 }
 }
 private {
 updateAdjustments();
 updateRulers();
 }
-bool onConfigure(GdkEventConfigure * event, Widget widget) {
+bool onConfigure(gdk.Event.Event event, Widget widget) {
 assert(widget is _drawingArea);
-auto viewBoundsScreen = Rectangle(Point(0.0, 0.0), Vector(cast(double)event.width, cast(double)event.height));
+//_surface = ImageSurface.create(CairoFormat.ARGB32, event.configure().width, event.configure().height);
+auto viewBoundsScreen = Rectangle(Point(0.0, 0.0), Vector(cast(double)event.configure().width, cast(double)event.configure().height));
 if (_screenModel is null) {
 Rectangle layerBounds = _layerStack.bounds;
 Rectangle paddedLayerBounds = growCentre(layerBounds, 2 * layerBounds.size);
 _screenModel = new ScreenModel(0.25 * _pixelsPerMillimetre, paddedLayerBounds, viewBoundsScreen);
 }
 return true;
 }
-bool onExpose(GdkEventExpose * event, Widget widget) {
+bool onDraw(Context context, Widget widget) {
 assert(widget is _drawingArea);
-auto dr = _drawingArea.getWindow();
+double x0, y0, x1, y1;
-scope modelCr = new Context(dr);            // Causing a memory leak!
+context.clipExtents(x0, y0, x1, y1);
-scope screenCr = new Context(dr);           // Causing a memory leak!
 Rectangle screenDamage =
-event is null ? _screenModel.viewBoundsScreen :
+Rectangle(_screenModel.viewBoundsScreen.position +
-Rectangle(_screenModel.viewBoundsScreen.position + Vector(cast(double)event.area.x, _screenModel.viewBoundsScreen.h - cast(double)(event.area.y + event.area.height)),
+Vector(x0, _screenModel.viewBoundsScreen.h - y1),
-Vector(cast(double)event.area.width, cast(double)event.area.height));
+Vector(x1 - x0, y1 - y0));
+assert(screenDamage.valid);
+writefln("External screen damage: %s", screenDamage);
+writefln("Internal screen damage: %s", _internalDamageScreen);
+assert(screenDamage.contains(_internalDamageScreen));
 Rectangle modelDamage = _screenModel.screenToModel(screenDamage);
+scope Context modelCr  = Context.create(context.getTarget());
+scope Context screenCr = Context.create(context.getTarget());
 modelCr.save(); screenCr.save(); {
 {
 // Setup model context and clip
 modelCr.translate(0.0, _screenModel.viewBoundsScreen.h);
 screenCr.rectangle(screenDamage.x0, screenDamage.y0, screenDamage.w, screenDamage.h);
 screenCr.fill();
 } screenCr.restore();
 _layerStack.draw(screenDamage, new CairoRenderer(screenCr),
-modelDamage, new CairoRenderer(modelCr),
+modelDamage,  new CairoRenderer(modelCr),
 _screenModel);
-} screenCr.restore(); modelCr.restore();
+} screenCr.restore(); screenCr.restore();
-return true;
+_internalDamageScreen = Rectangle();
-}
+return true;
-bool onButtonPress(GdkEventButton * event, Widget widget) {
+}
-assert(widget is _drawingArea);
-_eventHandler.handleButtonPress(this, makeButtonEvent(event, _screenModel));
+bool onButtonPress(gdk.Event.Event event, Widget widget) {
-fixDamage();
+assert(widget is _drawingArea);
-return true;
+_eventHandler.handleButtonPress(this, makeButtonEvent(event.button(), _screenModel));
-}
+reportDamage();
+return true;
-bool onButtonRelease(GdkEventButton * event, Widget widget) {
+}
-assert(widget is _drawingArea);
-_eventHandler.handleButtonRelease(this, makeButtonEvent(event, _screenModel));
+bool onButtonRelease(gdk.Event.Event event, Widget widget) {
-fixDamage();
+assert(widget is _drawingArea);
-return true;
+_eventHandler.handleButtonRelease(this, makeButtonEvent(event.button(), _screenModel));
-}
+reportDamage();
+return true;
-bool onKeyPressEvent(GdkEventKey * event, Widget widget) {
+}
-assert(widget is _drawingArea);
-_eventHandler.handleKeyPress(this, makeKeyEvent(event, _screenModel));
+bool onKeyPressEvent(gdk.Event.Event event, Widget widget) {
-fixDamage();
+assert(widget is _drawingArea);
-return true;
+_eventHandler.handleKeyPress(this, makeKeyEvent(event.key(), _screenModel));
-}
+reportDamage();
+return true;
-bool onKeyReleaseEvent(GdkEventKey * event, Widget widget) {
+}
-assert(widget is _drawingArea);
-_eventHandler.handleKeyRelease(this, makeKeyEvent(event, _screenModel));
+bool onKeyReleaseEvent(gdk.Event.Event event, Widget widget) {
-fixDamage();
+assert(widget is _drawingArea);
-return true;
+_eventHandler.handleKeyRelease(this, makeKeyEvent(event.key(), _screenModel));
-}
+reportDamage();
+return true;
-bool onMotionNotify(GdkEventMotion * event, Widget widget) {
+}
-assert(widget is _drawingArea);
+bool onMotionNotify(gdk.Event.Event event, Widget widget) {
+assert(widget is _drawingArea);
+if (event.motion().isHint) {
+int x, y;
+GdkModifierType mask;
+_drawingArea.getWindow().getPointer(x, y, mask);
+_eventHandler.handleMotion(this, makeMotionEventHint(x, y, mask, _screenModel));
+}
+else {
+_eventHandler.handleMotion(this, makeMotionEvent(event.motion(), _screenModel));
+}
+reportDamage();
 // Pass the events on to the rulers so that they update
-gtk_widget_event(_hRuler.getWidgetStruct(), cast(GdkEvent *)event);
+_hRuler.event(event);
-gtk_widget_event(_vRuler.getWidgetStruct(), cast(GdkEvent *)event);
+_vRuler.event(event);
-_eventHandler.handleMotion(this, makeMotionEvent(event, _screenModel));
+// Simulate delay in case we were slow to handle the event.
-fixDamage();
+// This is really only relevant if we were to do the drawing from inside
-return true;
+// the handler. ???
-}
+Thread.sleep(dur!("msecs")(50));
-bool onScroll(GdkEventScroll * event, Widget widget) {
+return true;
-assert(widget is _drawingArea);
+}
-_eventHandler.handleScroll(this, makeScrollEvent(event, _screenModel));
-fixDamage();
+bool onScroll(gdk.Event.Event event, Widget widget) {
-return true;
+assert(widget is _drawingArea);
-}
+_eventHandler.handleScroll(this, makeScrollEvent(event.scroll(), _screenModel));
+reportDamage();
-bool onEnterNotify(GdkEventCrossing * event, Widget widget) {
+return true;
-assert(widget is _drawingArea);
+}
-_eventHandler.handleEnter(this, makeCrossingEvent(event, _screenModel));
-fixDamage();
+bool onEnterNotify(gdk.Event.Event event, Widget widget) {
-return true;
+assert(widget is _drawingArea);
-}
+_eventHandler.handleEnter(this, makeCrossingEvent(event.crossing(), _screenModel));
+reportDamage();
-bool onLeaveNotify(GdkEventCrossing * event, Widget widget) {
+return true;
-assert(widget is _drawingArea);
+}
-_eventHandler.handleLeave(this, makeCrossingEvent(event, _screenModel));
-fixDamage();
+bool onLeaveNotify(gdk.Event.Event event, Widget widget) {
-return true;
+assert(widget is _drawingArea);
-}
+_eventHandler.handleLeave(this, makeCrossingEvent(event.crossing(), _screenModel));
+reportDamage();
-bool onFocusIn(GdkEventFocus * event, Widget widget) {
+return true;
+}
+bool onFocusIn(gdk.Event.Event event, Widget widget) {
 trace("onFocusIn");
 return true;
 }
-bool onFocusOut(GdkEventFocus * event, Widget widget) {
+bool onFocusOut(gdk.Event.Event event, Widget widget) {
 trace("onFocusOut");
 return true;
 }
 void onMoveFocus(GtkDirectionType direction, Widget widget) {
 // Define these just to obtain the position
 // below so we can preserve it
 double lower, upper, position, maxSize;
+/+
 _hRuler.getRange(lower, upper, position, maxSize);
 _hRuler.setRange(viewLeftBottom.x,
 viewRightTop.x,
 position,
 _screenModel.zoom * 50.0);
 _vRuler.getRange(lower, upper, position, maxSize);
 _vRuler.setRange(viewRightTop.y,
 viewLeftBottom.y,
 position,
 _screenModel.zoom * 50.0);
++/
 }
 void updateAdjustments() {
 immutable Point viewLeftBottom = _screenModel.screenToModel(Point(0.0, 0.0));
 immutable Point viewRightTop = _screenModel.screenToModel(_screenModel.viewBoundsScreen.corner1);
 _screenModel.canvasBoundsModel.h / 16.0,
 _screenModel.canvasBoundsModel.h / 4.0,
 _screenModel.viewBoundsModel.h);
 }
-void fixDamage() {
+void reportDamage() {
-if (_damageScreen.valid) {
+if (_tmpDamageScreen.valid) {
 int x, y, w, h;
-_damageScreen.getQuantised(x, y, w, h);
+_tmpDamageScreen.getQuantised(x, y, w, h);
 _drawingArea.queueDrawArea(x, cast(int)_screenModel.viewBoundsScreen.h - (y + h), w, h);
-_damageScreen = Rectangle();
+_internalDamageScreen = _internalDamageScreen | _tmpDamageScreen;
+_tmpDamageScreen = Rectangle();
 }
+assert(!_tmpDamageScreen.valid);
 }
 void onRealize(Widget widget) {
 assert(widget is _drawingArea);
 _drawingArea.grabFocus();
 Adjustment    _hAdjustment;
 HScrollbar    _hScrollbar;
 Adjustment    _vAdjustment;
 VScrollbar    _vScrollbar;
-Rectangle     _damageScreen;
+Rectangle     _tmpDamageScreen;             // accumulated from damageModel and damageScreen calls
+Rectangle     _internalDamageScreen;        // aggregated from _tmpDamageScreen in reportDamage calls
 ScreenModel   _screenModel;
 static immutable CursorType[Cursor] _cursors;
 }
 }

Mercurial > projects > doodle

comparison doodle/gtk/cairo_canvas.d @ 136:752676232e4b