Mercurial > projects > doodle

comparison doodle/gtk/canvas.d @ 48:1b4c9ba58673

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Stylistic overhaul.
author daveb
date Tue, 03 Aug 2010 17:37:21 +0930
parents f2e4e1d29b98
children 30ecedfe2ce2
comparison
equal deleted inserted replaced
47:14f1c051c35b 48:1b4c9ba58673
34 34
35 // x and y run right and up respectively 35 // x and y run right and up respectively
36 // 36 //
37 // Model units are millimetres. 37 // Model units are millimetres.
38 // 38 //
39 // mZoom -> pixels-per-model-unit 39 // _zoom -> pixels-per-model-unit
40 // mViewSize -> size of view window in pixels 40 // _viewSize -> size of view window in pixels
41 // mViewCentre -> location in model corresponding to centre of view 41 // _viewCentre -> location in model corresponding to centre of view
42 // mCanvasBounds -> size of the virtual canvas in model coordinates 42 // _canvasBounds -> size of the virtual canvas in model coordinates
43 // 43 //
44 // User operations: 44 // User operations:
45 // pan (middle click and drag) 45 // pan (middle click and drag)
46 // zoom about a point (hold control and move scroll wheel) 46 // zoom about a point (hold control and move scroll wheel)
47 // resize the widget 47 // resize the widget
48 48
49 class Canvas : Table, Viewport { 49 class Canvas : Table, Viewport {
50 this(in Layer[] layers, EventHandler event_handler, Grid grid, in double ppi) { 50 this(in Layer[] layers, EventHandler eventHandler, Grid grid, in double ppi) {
51 super(3, 3, 0); 51 super(3, 3, 0);
52 52
53 mDamage = Rectangle.DEFAULT; 53 _damage = Rectangle.DEFAULT;
54 54
55 mLayers = layers.dup; 55 _layers = layers.dup;
56 mEventHandler = event_handler; 56 _eventHandler = eventHandler;
57 mGrid = grid; 57 _grid = grid;
58 mPPI = ppi; 58 _ppi = ppi;
59 59
60 /* 60 /*
61 writefln("Layer bounds: %s", layer_bounds); 61 writefln("Layer bounds: %s", layerBounds);
62 writefln("Canvas bounds: %s", mCanvasBounds); 62 writefln("Canvas bounds: %s", _canvasBounds);
63 writefln("View centre: %s", mViewCentre); 63 writefln("View centre: %s", _viewCentre);
64 */ 64 */
65 65
66 // Create our child widgets and register callbacks 66 // Create our child widgets and register callbacks
67 67
68 info("B1"); 68 info("B1");
69 mHRuler = new HRuler; 69 _hRuler = new HRuler;
70 attach(mHRuler, 70 attach(_hRuler,
71 1, 2, 71 1, 2,
72 0, 1, 72 0, 1,
73 AttachOptions.FILL | AttachOptions.EXPAND, AttachOptions.SHRINK, 73 AttachOptions.FILL | AttachOptions.EXPAND, AttachOptions.SHRINK,
74 0, 0); 74 0, 0);
75 mHRuler.setMetric(MetricType.PIXELS); 75 _hRuler.setMetric(MetricType.PIXELS);
76 76
77 info("B2"); 77 info("B2");
78 mVRuler = new VRuler; 78 _vRuler = new VRuler;
79 attach(mVRuler, 79 attach(_vRuler,
80 0, 1, 80 0, 1,
81 1, 2, 81 1, 2,
82 AttachOptions.SHRINK, AttachOptions.FILL | AttachOptions.EXPAND, 82 AttachOptions.SHRINK, AttachOptions.FILL | AttachOptions.EXPAND,
83 0, 0); 83 0, 0);
84 info("B3"); 84 info("B3");
85 mVRuler.setMetric(MetricType.PIXELS); 85 _vRuler.setMetric(MetricType.PIXELS);
86 info("J"); 86 info("J");
87 87
88 mDrawingArea = new DrawingArea; 88 _drawingArea = new DrawingArea;
89 mDrawingArea.addOnRealize(&on_realize); 89 _drawingArea.addOnRealize(&onRealize);
90 mDrawingArea.addOnConfigure(&on_configure); 90 _drawingArea.addOnConfigure(&onConfigure);
91 mDrawingArea.addOnExpose(&on_expose); 91 _drawingArea.addOnExpose(&onExpose);
92 mDrawingArea.addOnButtonPress(&on_button_press); 92 _drawingArea.addOnButtonPress(&onButtonPress);
93 mDrawingArea.addOnButtonRelease(&on_button_release); 93 _drawingArea.addOnButtonRelease(&onButtonRelease);
94 mDrawingArea.addOnKeyPress(&on_key_event); 94 _drawingArea.addOnKeyPress(&onKeyEvent);
95 mDrawingArea.addOnKeyRelease(&on_key_event); 95 _drawingArea.addOnKeyRelease(&onKeyEvent);
96 mDrawingArea.addOnMotionNotify(&on_motion_notify); 96 _drawingArea.addOnMotionNotify(&onMotionNotify);
97 mDrawingArea.addOnScroll(&on_scroll); 97 _drawingArea.addOnScroll(&onScroll);
98 mDrawingArea.addOnEnterNotify(&on_enter_notify); 98 _drawingArea.addOnEnterNotify(&onEnterNotify);
99 mDrawingArea.addOnLeaveNotify(&on_leave_notify); 99 _drawingArea.addOnLeaveNotify(&onLeaveNotify);
100 mDrawingArea.setEvents(EventMask.EXPOSURE_MASK | 100 _drawingArea.setEvents(EventMask.EXPOSURE_MASK |
101 EventMask.POINTER_MOTION_MASK | 101 EventMask.POINTER_MOTION_MASK |
102 EventMask.POINTER_MOTION_HINT_MASK | 102 EventMask.POINTER_MOTION_HINT_MASK |
103 EventMask.BUTTON_MOTION_MASK | 103 EventMask.BUTTON_MOTION_MASK |
104 EventMask.BUTTON_PRESS_MASK | 104 EventMask.BUTTON_PRESS_MASK |
105 EventMask.BUTTON_RELEASE_MASK | 105 EventMask.BUTTON_RELEASE_MASK |
109 EventMask.LEAVE_NOTIFY_MASK | 109 EventMask.LEAVE_NOTIFY_MASK |
110 EventMask.FOCUS_CHANGE_MASK | 110 EventMask.FOCUS_CHANGE_MASK |
111 EventMask.SCROLL_MASK); 111 EventMask.SCROLL_MASK);
112 info("M"); 112 info("M");
113 113
114 attach(mDrawingArea, 114 attach(_drawingArea,
115 1, 2, 115 1, 2,
116 1, 2, 116 1, 2,
117 AttachOptions.FILL | AttachOptions.EXPAND, AttachOptions.FILL | AttachOptions.EXPAND, 117 AttachOptions.FILL | AttachOptions.EXPAND, AttachOptions.FILL | AttachOptions.EXPAND,
118 0, 0); 118 0, 0);
119 119
120 // value, lower, upper, step-inc, page-inc, page-size 120 // value, lower, upper, step-inc, page-inc, page-size
121 // Give the adjustments dummy values until we receive a configure 121 // Give the adjustments dummy values until we receive a configure
122 mHAdjustment = new Adjustment(0.0, 0.0, 1.0, 0.2, 0.5, 0.5); 122 _hAdjustment = new Adjustment(0.0, 0.0, 1.0, 0.2, 0.5, 0.5);
123 mHAdjustment.addOnValueChanged(&onValueChanged); 123 _hAdjustment.addOnValueChanged(&onValueChanged);
124 mHScrollbar = new HScrollbar(mHAdjustment); 124 _hScrollbar = new HScrollbar(_hAdjustment);
125 mHScrollbar.setInverted(false); 125 _hScrollbar.setInverted(false);
126 attach(mHScrollbar, 126 attach(_hScrollbar,
127 1, 2, 127 1, 2,
128 2, 3, 128 2, 3,
129 AttachOptions.FILL | AttachOptions.EXPAND, AttachOptions.SHRINK, 129 AttachOptions.FILL | AttachOptions.EXPAND, AttachOptions.SHRINK,
130 0, 0); 130 0, 0);
131 info("Q"); 131 info("Q");
132 132
133 mVAdjustment = new Adjustment(0.0, 0.0, 1.0, 0.2, 0.5, 0.5); 133 _vAdjustment = new Adjustment(0.0, 0.0, 1.0, 0.2, 0.5, 0.5);
134 mVAdjustment.addOnValueChanged(&onValueChanged); 134 _vAdjustment.addOnValueChanged(&onValueChanged);
135 mVScrollbar = new VScrollbar(mVAdjustment); 135 _vScrollbar = new VScrollbar(_vAdjustment);
136 mVScrollbar.setInverted(true); 136 _vScrollbar.setInverted(true);
137 attach(mVScrollbar, 137 attach(_vScrollbar,
138 2, 3, 138 2, 3,
139 1, 2, 139 1, 2,
140 AttachOptions.SHRINK, 140 AttachOptions.SHRINK,
141 AttachOptions.FILL | AttachOptions.EXPAND, 141 AttachOptions.FILL | AttachOptions.EXPAND,
142 0, 0); 142 0, 0);
143 } 143 }
144 144
145 override void zoom_relative(in Point pixel_datum, in double factor) { 145 override void zoomRelative(in Point pixelDatum, in double factor) {
146 // Work out pixel distance from current centre to datum, 146 // Work out pixel distance from current centre to datum,
147 // Do the zoom, then work out the new centre that keeps the 147 // Do the zoom, then work out the new centre that keeps the
148 // pixel distance the same 148 // pixel distance the same
149 149
150 Point old_model_datum = pixel_to_model(pixel_datum); 150 Point oldModelDatum = pixelToModel(pixelDatum);
151 Vector pixel_distance = model_to_pixel(old_model_datum - mViewCentre); 151 Vector pixelDistance = modelToPixel(oldModelDatum - _viewCentre);
152 mZoom = clamp_zoom(factor * mZoom); 152 _zoom = clampZoom(factor * _zoom);
153 mViewCentre = old_model_datum - pixel_to_model(pixel_distance); 153 _viewCentre = oldModelDatum - pixelToModel(pixelDistance);
154 154
155 update_adjustments; 155 updateAdjustments;
156 update_rulers; 156 updateRulers;
157 mGrid.zoom_changed(mZoom); 157 _grid.zoomChanged(_zoom);
158 queueDraw; 158 queueDraw;
159 } 159 }
160 160
161 override void pan_relative(in Vector pixel_displacement) { 161 override void panRelative(in Vector pixelDisplacement) {
162 mViewCentre = mViewCentre + pixel_to_model(pixel_displacement); 162 _viewCentre = _viewCentre + pixelToModel(pixelDisplacement);
163 163
164 update_adjustments; 164 updateAdjustments;
165 update_rulers; 165 updateRulers;
166 queueDraw; 166 queueDraw;
167 } 167 }
168 168
169 override void set_cursor(in Cursor cursor) { 169 override void setCursor(in Cursor cursor) {
170 CursorType cursor_type; 170 CursorType cursor_type;
171 171
172 switch (cursor) { 172 switch (cursor) {
173 case Cursor.DEFAULT: 173 case Cursor.DEFAULT:
174 cursor_type = CursorType.ARROW; 174 cursor_type = CursorType.ARROW;
181 break; 181 break;
182 default: 182 default:
183 assert(0); 183 assert(0);
184 } 184 }
185 185
186 mDrawingArea.setCursor(new gdk.Cursor.Cursor(cursor_type)); 186 _drawingArea.setCursor(new gdk.Cursor.Cursor(cursor_type));
187 } 187 }
188 188
189 override void damage_model(in Rectangle area) { 189 override void damageModel(in Rectangle area) {
190 mDamage = mDamage | model_to_pixel(area); 190 _damage = _damage | modelToPixel(area);
191 } 191 }
192 192
193 override void damage_pixel(in Rectangle area) { 193 override void damagePixel(in Rectangle area) {
194 mDamage = mDamage | area; 194 _damage = _damage | area;
195 } 195 }
196 196
197 private { 197 private {
198 198
199 void update_bounds() { 199 void update_bounds() {
200 } 200 }
201 201
202 202
203 bool on_configure(GdkEventConfigure * event, Widget widget) { 203 bool onConfigure(GdkEventConfigure * event, Widget widget) {
204 assert(widget is mDrawingArea); 204 assert(widget is _drawingArea);
205 205
206 mViewSize = Vector(cast(double)event.width, cast(double)event.height); 206 _viewSize = Vector(cast(double)event.width, cast(double)event.height);
207 207
208 Rectangle layer_bounds = Rectangle.DEFAULT; 208 Rectangle layerBounds = Rectangle.DEFAULT;
209 209
210 foreach (ref layer; mLayers) { 210 foreach (ref layer; _layers) {
211 layer_bounds = layer_bounds | layer.bounds; 211 layerBounds = layerBounds | layer.bounds;
212 } 212 }
213 213
214 assert(layer_bounds.valid); 214 assert(layerBounds.valid);
215 215
216 Rectangle padded_layer_bounds = expand(move(layer_bounds, - layer_bounds.size), 2.0 * layer_bounds.size); 216 Rectangle paddedLayerBounds = expand(move(layerBounds, - layerBounds.size), 2.0 * layerBounds.size);
217 217
218 if (!mHadConfigure) { 218 if (!_hadConfigure) {
219 info("1"); 219 info("1");
220 const double MM_PER_INCH = 25.4; 220 const double MM_PER_INCH = 25.4;
221 mZoom = 0.25 * mPPI / MM_PER_INCH; 221 _zoom = 0.25 * _ppi / MM_PER_INCH;
222 222
223 mCanvasBounds = padded_layer_bounds; 223 _canvasBounds = paddedLayerBounds;
224 mViewCentre = mCanvasBounds.centre; 224 _viewCentre = _canvasBounds.centre;
225 225
226 mGrid.zoom_changed(mZoom); 226 _grid.zoomChanged(_zoom);
227 227
228 mHadConfigure = true; 228 _hadConfigure = true;
229 } 229 }
230 else { 230 else {
231 // Use configure events as an opportunity 231 // Use configure events as an opportunity
232 // to consolidate the canvas-bounds 232 // to consolidate the canvas-bounds
233 // XXX nasty code. 233 // XXX nasty code.
234 Vector z = mViewSize / mZoom; 234 Vector z = _viewSize / _zoom;
235 Rectangle r = Rectangle(mViewCentre - z / 2.0, z); 235 Rectangle r = Rectangle(_viewCentre - z / 2.0, z);
236 mCanvasBounds = r | padded_layer_bounds; 236 _canvasBounds = r | paddedLayerBounds;
237 } 237 }
238 238
239 update_adjustments; 239 updateAdjustments;
240 update_rulers; 240 updateRulers;
241 241
242 //writefln("Canvas bounds: %s", mCanvasBounds); 242 //writefln("Canvas bounds: %s", _canvasBounds);
243 //writefln("View centre: %s", mViewCentre); 243 //writefln("View centre: %s", _viewCentre);
244 244
245 return true; 245 return true;
246 } 246 }
247 247
248 bool on_expose(GdkEventExpose * event, Widget widget) { 248 bool onExpose(GdkEventExpose * event, Widget widget) {
249 assert(widget is mDrawingArea); 249 assert(widget is _drawingArea);
250 250
251 Drawable dr = mDrawingArea.getWindow; 251 Drawable dr = _drawingArea.getWindow;
252 252
253 int width, height; 253 int width, height;
254 dr.getSize(width, height); 254 dr.getSize(width, height);
255 //writefln("Got expose %dx%d\n", width, height); 255 //writefln("Got expose %dx%d\n", width, height);
256 256
257 scope model_cr = new Context(dr); 257 scope modelCr = new Context(dr);
258 scope pixel_cr = new Context(dr); 258 scope pixelCr = new Context(dr);
259 259
260 Rectangle pixel_damage = 260 Rectangle pixel_damage =
261 event is null ? 261 event is null ?
262 Rectangle(Point(0.0, 0.0), mViewSize) : 262 Rectangle(Point(0.0, 0.0), _viewSize) :
263 Rectangle(Point(cast(double)event.area.x, mViewSize.y - cast(double)(event.area.y + event.area.height)), 263 Rectangle(Point(cast(double)event.area.x, _viewSize.y - cast(double)(event.area.y + event.area.height)),
264 Vector(cast(double)event.area.width, cast(double)event.area.height)); 264 Vector(cast(double)event.area.width, cast(double)event.area.height));
265 265
266 Rectangle model_damage = pixel_to_model(pixel_damage); 266 Rectangle model_damage = pixelToModel(pixel_damage);
267 267
268 //writefln("Pixel damage: %s, model damage: %s", pixel_damage, model_damage); 268 //writefln("Pixel damage: %s, model damage: %s", pixel_damage, model_damage);
269 269
270 model_cr.save; pixel_cr.save; { 270 modelCr.save; pixelCr.save; {
271 // Setup model context and clip 271 // Setup model context and clip
272 272
273 GtkAdjustment * h_gtkAdjustment = mHAdjustment.getAdjustmentStruct; 273 GtkAdjustment * h_gtkAdjustment = _hAdjustment.getAdjustmentStruct;
274 GtkAdjustment * v_gtkAdjustment = mVAdjustment.getAdjustmentStruct; 274 GtkAdjustment * v_gtkAdjustment = _vAdjustment.getAdjustmentStruct;
275 275
276 model_cr.scale(mZoom, -mZoom); 276 modelCr.scale(_zoom, -_zoom);
277 model_cr.translate(-gtk_adjustment_get_value(h_gtkAdjustment), 277 modelCr.translate(-gtk_adjustment_get_value(h_gtkAdjustment),
278 -gtk_adjustment_get_value(v_gtkAdjustment) - gtk_adjustment_get_page_size(v_gtkAdjustment)); 278 -gtk_adjustment_get_value(v_gtkAdjustment) - gtk_adjustment_get_page_size(v_gtkAdjustment));
279 279
280 rectangle(model_cr, model_damage); 280 rectangle(modelCr, model_damage);
281 model_cr.clip; 281 modelCr.clip;
282 282
283 // Setup pixel context and clip 283 // Setup pixel context and clip
284 284
285 pixel_cr.translate(0.0, mViewSize.y); 285 pixelCr.translate(0.0, _viewSize.y);
286 pixel_cr.scale(1.0, -1.0); 286 pixelCr.scale(1.0, -1.0);
287 287
288 rectangle(pixel_cr, pixel_damage); 288 rectangle(pixelCr, pixel_damage);
289 pixel_cr.clip; 289 pixelCr.clip;
290 290
291 // Fill the background 291 // Fill the background
292 292
293 pixel_cr.save; { 293 pixelCr.save; {
294 // Make the window light grey 294 // Make the window light grey
295 pixel_cr.setSourceRgba(0.9, 0.9, 0.9, 1.0); 295 pixelCr.setSourceRgba(0.9, 0.9, 0.9, 1.0);
296 rectangle(pixel_cr, pixel_damage); 296 rectangle(pixelCr, pixel_damage);
297 pixel_cr.fill; 297 pixelCr.fill;
298 } pixel_cr.restore; 298 } pixelCr.restore;
299 299
300 // Draw each layer 300 // Draw each layer
301 301
302 foreach(ref layer; mLayers) { 302 foreach(ref layer; _layers) {
303 model_cr.save; pixel_cr.save; { 303 modelCr.save; pixelCr.save; {
304 layer.draw(this, pixel_damage, pixel_cr, model_damage, model_cr); 304 layer.draw(this, pixel_damage, pixelCr, model_damage, modelCr);
305 } pixel_cr.restore; model_cr.restore; 305 } pixelCr.restore; modelCr.restore;
306 } 306 }
307 } pixel_cr.restore; model_cr.restore; 307 } pixelCr.restore; modelCr.restore;
308 308
309 return true; 309 return true;
310 } 310 }
311 311
312 bool on_button_press(GdkEventButton * event, Widget widget) { 312 bool onButtonPress(GdkEventButton * event, Widget widget) {
313 assert(widget is mDrawingArea); 313 assert(widget is _drawingArea);
314 //writefln("Got button event\n"); 314 //writefln("Got button event\n");
315 315
316 Point pixel_point = Point(event.x + 0.5, mViewSize.y - (event.y + 0.5)); 316 Point pixelPoint = Point(event.x + 0.5, _viewSize.y - (event.y + 0.5));
317 Point model_point = pixel_to_model(pixel_point); 317 Point modelPoint = pixelToModel(pixelPoint);
318 318
319 auto button_event = new ButtonEvent(gtk2tk_button_action(event.type), 319 auto buttonEvent = new ButtonEvent(gtk2tkButtonAction(event.type),
320 gtk2tk_button_name(event.button), 320 gtk2tkButtonName(event.button),
321 pixel_point, 321 pixelPoint,
322 model_point, 322 modelPoint,
323 gtk2tk_mask(event.state)); 323 gtk2tkMask(event.state));
324 324
325 mEventHandler.handle_button_press(this, button_event); 325 _eventHandler.handleButtonPress(this, buttonEvent);
326 326
327 fix_damage; 327 fixDamage;
328 328
329 return true; 329 return true;
330 } 330 }
331 331
332 bool on_button_release(GdkEventButton * event, Widget widget) { 332 bool onButtonRelease(GdkEventButton * event, Widget widget) {
333 assert(widget is mDrawingArea); 333 assert(widget is _drawingArea);
334 //writefln("Got button event\n"); 334 //writefln("Got button event\n");
335 335
336 Point pixel_point = Point(event.x + 0.5, mViewSize.y - (event.y + 0.5)); 336 Point pixelPoint = Point(event.x + 0.5, _viewSize.y - (event.y + 0.5));
337 Point model_point = pixel_to_model(pixel_point); 337 Point modelPoint = pixelToModel(pixelPoint);
338 338
339 auto button_event = new ButtonEvent(gtk2tk_button_action(event.type), 339 auto buttonEvent = new ButtonEvent(gtk2tkButtonAction(event.type),
340 gtk2tk_button_name(event.button), 340 gtk2tkButtonName(event.button),
341 pixel_point, 341 pixelPoint,
342 model_point, 342 modelPoint,
343 gtk2tk_mask(event.state)); 343 gtk2tkMask(event.state));
344 344
345 mEventHandler.handle_button_release(this, button_event); 345 _eventHandler.handleButtonRelease(this, buttonEvent);
346 346
347 fix_damage; 347 fixDamage;
348 348
349 return true; 349 return true;
350 } 350 }
351 351
352 bool on_key_event(GdkEventKey * event, Widget widget) { 352 bool onKeyEvent(GdkEventKey * event, Widget widget) {
353 assert(widget is mDrawingArea); 353 assert(widget is _drawingArea);
354 //writefln("Got key event\n"); 354 //writefln("Got key event\n");
355 355
356 //auto key_event = new KeyEvent("", 356 //auto key_event = new KeyEvent("",
357 // mEventHandle.handle_key(key_event); 357 // mEventHandle.handle_key(key_event);
358 358
359 fix_damage; 359 fixDamage;
360 360
361 return true; 361 return true;
362 } 362 }
363 363
364 bool on_motion_notify(GdkEventMotion * event, Widget widget) { 364 bool onMotionNotify(GdkEventMotion * event, Widget widget) {
365 assert(widget is mDrawingArea); 365 assert(widget is _drawingArea);
366 //writefln("Got motion notify\n"); 366 //writefln("Got motion notify\n");
367 gtk_widget_event(mHRuler.getWidgetStruct(), cast(GdkEvent *)event); 367 gtk_widget_event(_hRuler.getWidgetStruct(), cast(GdkEvent *)event);
368 gtk_widget_event(mVRuler.getWidgetStruct(), cast(GdkEvent *)event); 368 gtk_widget_event(_vRuler.getWidgetStruct(), cast(GdkEvent *)event);
369 369
370 Point pixel_point = Point(event.x + 0.5, mViewSize.y - (event.y + 0.5)); 370 Point pixelPoint = Point(event.x + 0.5, _viewSize.y - (event.y + 0.5));
371 Point model_point = pixel_to_model(pixel_point); 371 Point modelPoint = pixelToModel(pixelPoint);
372 372
373 auto motion_event = new MotionEvent(pixel_point, 373 auto motion_event = new MotionEvent(pixelPoint,
374 model_point, 374 modelPoint,
375 gtk2tk_mask(event.state)); 375 gtk2tkMask(event.state));
376 376
377 mEventHandler.handle_motion(this, motion_event); 377 _eventHandler.handleMotion(this, motion_event);
378 378
379 fix_damage; 379 fixDamage;
380 380
381 return true; 381 return true;
382 } 382 }
383 383
384 bool on_scroll(GdkEventScroll * event, Widget widget) { 384 bool onScroll(GdkEventScroll * event, Widget widget) {
385 assert(widget is mDrawingArea); 385 assert(widget is _drawingArea);
386 //writefln("Got scroll\n"); 386 //writefln("Got scroll\n");
387 387
388 Point pixel_point = Point(event.x + 0.5, mViewSize.y - (event.y + 0.5)); 388 Point pixelPoint = Point(event.x + 0.5, _viewSize.y - (event.y + 0.5));
389 Point model_point = pixel_to_model(pixel_point); 389 Point modelPoint = pixelToModel(pixelPoint);
390 390
391 auto scroll_event = new ScrollEvent(gtk2tk_direction(event.direction), 391 auto scroll_event = new ScrollEvent(gtk2tkDirection(event.direction),
392 pixel_point, 392 pixelPoint,
393 model_point, 393 modelPoint,
394 gtk2tk_mask(event.state)); 394 gtk2tkMask(event.state));
395 395
396 mEventHandler.handle_scroll(this, scroll_event); 396 _eventHandler.handleScroll(this, scroll_event);
397 397
398 fix_damage; 398 fixDamage;
399 399
400 return true; 400 return true;
401 } 401 }
402 402
403 /* 403 /*
404 public enum GdkCrossingMode { 404 public enum GdkCrossingMode {
405 NORMAL, 405 NORMAL,
406 GRAB, 406 GRAB,
407 UNGRAB, 407 UNGRAB,
408 GTK_GRAB, 408 GTK_GRAB,
409 GTK_UNGRAB, 409 GTK_UNGRAB,
410 STATE_CHANGED 410 STATE_CHANGED
411 } 411 }
412 412
413 public struct GdkEventCrossing { 413 public struct GdkEventCrossing {
414 GdkEventType type; 414 GdkEventType type;
415 GdkWindow *window; 415 GdkWindow *window;
416 byte sendEvent; 416 byte sendEvent;
417 GdkWindow *subwindow; 417 GdkWindow *subwindow;
418 uint time; 418 uint time;
419 double x; 419 double x;
420 double y; 420 double y;
421 double xRoot; 421 double xRoot;
422 double yRoot; 422 double yRoot;
423 GdkCrossingMode mode; 423 GdkCrossingMode mode;
424 GdkNotifyType detail; 424 GdkNotifyType detail;
425 int focus; 425 int focus;
426 uint state; 426 uint state;
427 } 427 }
428 */ 428 */
429 429
430 bool on_enter_notify(GdkEventCrossing * event, Widget widget) { 430 bool onEnterNotify(GdkEventCrossing * event, Widget widget) {
431 assert(widget is mDrawingArea); 431 assert(widget is _drawingArea);
432 //writefln("Enter %d %d %d", cast(int)event.mode, event.focus, event.state); 432 //writefln("Enter %d %d %d", cast(int)event.mode, event.focus, event.state);
433 // TODO 433 // TODO
434 return true; 434 return true;
435 } 435 }
436 436
437 bool on_leave_notify(GdkEventCrossing * event, Widget widget) { 437 bool onLeaveNotify(GdkEventCrossing * event, Widget widget) {
438 assert(widget is mDrawingArea); 438 assert(widget is _drawingArea);
439 //writefln("Leave %d %d %d", cast(int)event.mode, event.focus, event.state); 439 //writefln("Leave %d %d %d", cast(int)event.mode, event.focus, event.state);
440 // TODO 440 // TODO
441 return true; 441 return true;
442 } 442 }
443 443
444 void onValueChanged(Adjustment adjustment) { 444 void onValueChanged(Adjustment adjustment) {
445 GtkAdjustment * h_gtkAdjustment = mHAdjustment.getAdjustmentStruct; 445 GtkAdjustment * h_gtkAdjustment = _hAdjustment.getAdjustmentStruct;
446 GtkAdjustment * v_gtkAdjustment = mVAdjustment.getAdjustmentStruct; 446 GtkAdjustment * v_gtkAdjustment = _vAdjustment.getAdjustmentStruct;
447 447
448 Point view_left_top = Point(gtk_adjustment_get_value(h_gtkAdjustment), 448 Point viewLeftTop = Point(gtk_adjustment_get_value(h_gtkAdjustment),
449 gtk_adjustment_get_value(v_gtkAdjustment)); 449 gtk_adjustment_get_value(v_gtkAdjustment));
450 450
451 Vector model_size = pixel_to_model(mViewSize); 451 Vector modelSize = pixelToModel(_viewSize);
452 452
453 //writefln("%s", view_left_bottom); 453 //writefln("%s", viewLeftBottom);
454 mViewCentre = view_left_top + model_size / 2.0; 454 _viewCentre = viewLeftTop + modelSize / 2.0;
455 //writefln("onValueChanged mViewCentre: %s", mViewCentre); 455 //writefln("onValueChanged _viewCentre: %s", _viewCentre);
456 456
457 update_rulers; 457 updateRulers;
458 458
459 queueDraw; 459 queueDraw;
460 } 460 }
461 461
462 void update_rulers() { 462 void updateRulers() {
463 invariant Vector model_size = pixel_to_model(mViewSize); 463 invariant Vector modelSize = pixelToModel(_viewSize);
464 464
465 invariant Point view_left_bottom = mViewCentre - model_size / 2.0; 465 invariant Point viewLeftBottom = _viewCentre - modelSize / 2.0;
466 invariant Point view_right_top = mViewCentre + model_size / 2.0; 466 invariant Point viewRightTop = _viewCentre + modelSize / 2.0;
467 467
468 // Define these just to obtain the position 468 // Define these just to obtain the position
469 // below and we can preserve it 469 // below and we can preserve it
470 double lower, upper, position, max_size; 470 double lower, upper, position, maxSize;
471 471
472 mHRuler.getRange(lower, upper, position, max_size); 472 _hRuler.getRange(lower, upper, position, maxSize);
473 mHRuler.setRange(view_left_bottom.x, 473 _hRuler.setRange(viewLeftBottom.x,
474 view_right_top.x, 474 viewRightTop.x,
475 position, 475 position,
476 mZoom * 50.0); 476 _zoom * 50.0);
477 477
478 mVRuler.getRange(lower, upper, position, max_size); 478 _vRuler.getRange(lower, upper, position, maxSize);
479 mVRuler.setRange(view_right_top.y, 479 _vRuler.setRange(viewRightTop.y,
480 view_left_bottom.y, 480 viewLeftBottom.y,
481 position, 481 position,
482 mZoom * 50.0); 482 _zoom * 50.0);
483 } 483 }
484 484
485 void update_adjustments() { 485 void updateAdjustments() {
486 invariant Vector model_size = pixel_to_model(mViewSize); 486 invariant Vector modelSize = pixelToModel(_viewSize);
487 487
488 invariant Point view_left_bottom = mViewCentre - model_size / 2.0; 488 invariant Point viewLeftBottom = _viewCentre - modelSize / 2.0;
489 invariant Point view_right_top = mViewCentre + model_size / 2.0; 489 invariant Point viewRightTop = _viewCentre + modelSize / 2.0;
490 490
491 // Adjust the canvas size if necessary 491 // Adjust the canvas size if necessary
492 mCanvasBounds = Rectangle(min_extents(mCanvasBounds.min_corner, view_left_bottom), 492 _canvasBounds = Rectangle(minExtents(_canvasBounds.minCorner, viewLeftBottom),
493 max_extents(mCanvasBounds.max_corner, view_right_top)); 493 maxExtents(_canvasBounds.maxCorner, viewRightTop));
494 494
495 // Update the adjustments 495 // Update the adjustments
496 496
497 GtkAdjustment * h_gtkAdjustment = mHAdjustment.getAdjustmentStruct; 497 GtkAdjustment * h_gtkAdjustment = _hAdjustment.getAdjustmentStruct;
498 GtkAdjustment * v_gtkAdjustment = mVAdjustment.getAdjustmentStruct; 498 GtkAdjustment * v_gtkAdjustment = _vAdjustment.getAdjustmentStruct;
499 499
500 gtk_adjustment_set_lower(h_gtkAdjustment, mCanvasBounds.min_corner.x); 500 gtk_adjustment_set_lower(h_gtkAdjustment, _canvasBounds.minCorner.x);
501 gtk_adjustment_set_upper(h_gtkAdjustment, mCanvasBounds.max_corner.x); 501 gtk_adjustment_set_upper(h_gtkAdjustment, _canvasBounds.maxCorner.x);
502 gtk_adjustment_set_value(h_gtkAdjustment, view_left_bottom.x); 502 gtk_adjustment_set_value(h_gtkAdjustment, viewLeftBottom.x);
503 gtk_adjustment_set_step_increment(h_gtkAdjustment, mCanvasBounds.size.x / 16.0); 503 gtk_adjustment_set_step_increment(h_gtkAdjustment, _canvasBounds.size.x / 16.0);
504 gtk_adjustment_set_page_increment(h_gtkAdjustment, mCanvasBounds.size.x / 4.0); 504 gtk_adjustment_set_page_increment(h_gtkAdjustment, _canvasBounds.size.x / 4.0);
505 gtk_adjustment_set_page_size(h_gtkAdjustment, model_size.x); 505 gtk_adjustment_set_page_size(h_gtkAdjustment, modelSize.x);
506 506
507 gtk_adjustment_set_lower(v_gtkAdjustment, mCanvasBounds.min_corner.y); 507 gtk_adjustment_set_lower(v_gtkAdjustment, _canvasBounds.minCorner.y);
508 gtk_adjustment_set_upper(v_gtkAdjustment, mCanvasBounds.max_corner.y); 508 gtk_adjustment_set_upper(v_gtkAdjustment, _canvasBounds.maxCorner.y);
509 gtk_adjustment_set_value(v_gtkAdjustment, view_left_bottom.y); 509 gtk_adjustment_set_value(v_gtkAdjustment, viewLeftBottom.y);
510 gtk_adjustment_set_step_increment(v_gtkAdjustment, mCanvasBounds.size.y / 16.0); 510 gtk_adjustment_set_step_increment(v_gtkAdjustment, _canvasBounds.size.y / 16.0);
511 gtk_adjustment_set_page_increment(v_gtkAdjustment, mCanvasBounds.size.y / 4.0); 511 gtk_adjustment_set_page_increment(v_gtkAdjustment, _canvasBounds.size.y / 4.0);
512 gtk_adjustment_set_page_size(v_gtkAdjustment, model_size.y); 512 gtk_adjustment_set_page_size(v_gtkAdjustment, modelSize.y);
513 513
514 mHAdjustment.changed; 514 _hAdjustment.changed;
515 mHAdjustment.valueChanged; 515 _hAdjustment.valueChanged;
516 mVAdjustment.changed; 516 _vAdjustment.changed;
517 mVAdjustment.valueChanged; 517 _vAdjustment.valueChanged;
518 } 518 }
519 519
520 void fix_damage() { 520 void fixDamage() {
521 if (mDamage.valid) { 521 if (_damage.valid) {
522 //writefln("Damage: %s", mDamage); 522 //writefln("Damage: %s", _damage);
523 int x, y, w, h; 523 int x, y, w, h;
524 mDamage.get_quantised(x, y, w, h); 524 _damage.getQuantised(x, y, w, h);
525 mDrawingArea.queueDrawArea(x, cast(int)mViewSize.y - (y + h), w, h); 525 _drawingArea.queueDrawArea(x, cast(int)_viewSize.y - (y + h), w, h);
526 mDamage = Rectangle.DEFAULT; 526 _damage = Rectangle.DEFAULT;
527 } 527 }
528 else { 528 else {
529 //writefln("No damage"); 529 //writefln("No damage");
530 } 530 }
531 } 531 }
532 532
533 double clamp_zoom(in double zoom) { return clamp(zoom, 0.2, 10.0); } 533 double clampZoom(in double zoom) { return clamp(zoom, 0.2, 10.0); }
534 534
535 Point model_to_pixel(in Point model) const { 535 Point modelToPixel(in Point model) const {
536 return Point.DEFAULT + mViewSize / 2.0 + mZoom * (model - mViewCentre); 536 return Point.DEFAULT + _viewSize / 2.0 + _zoom * (model - _viewCentre);
537 } 537 }
538 538
539 Point pixel_to_model(in Point pixel) const { 539 Point pixelToModel(in Point pixel) const {
540 return mViewCentre + (pixel - mViewSize / 2.0 - Point.DEFAULT) / mZoom; 540 return _viewCentre + (pixel - _viewSize / 2.0 - Point.DEFAULT) / _zoom;
541 } 541 }
542 542
543 Vector model_to_pixel(in Vector model) const { 543 Vector modelToPixel(in Vector model) const {
544 return mZoom * model; 544 return _zoom * model;
545 } 545 }
546 546
547 Vector pixel_to_model(in Vector pixel) const { 547 Vector pixelToModel(in Vector pixel) const {
548 return pixel / mZoom; 548 return pixel / _zoom;
549 } 549 }
550 550
551 Rectangle model_to_pixel(in Rectangle model) const { 551 Rectangle modelToPixel(in Rectangle model) const {
552 return Rectangle(model_to_pixel(model.position), model_to_pixel(model.size)); 552 return Rectangle(modelToPixel(model.position), modelToPixel(model.size));
553 } 553 }
554 554
555 Rectangle pixel_to_model(in Rectangle model) const { 555 Rectangle pixelToModel(in Rectangle model) const {
556 return Rectangle(pixel_to_model(model.position), pixel_to_model(model.size)); 556 return Rectangle(pixelToModel(model.position), pixelToModel(model.size));
557 } 557 }
558 558
559 void on_realize(Widget widget) { 559 void onRealize(Widget widget) {
560 assert(widget is mDrawingArea); 560 assert(widget is _drawingArea);
561 //writefln("Got realize\n"); 561 //writefln("Got realize\n");
562 } 562 }
563 563
564 bool mHadConfigure; 564 bool _hadConfigure;
565 Rectangle mDamage; // pixels 565 Rectangle _damage; // pixels
566 566
567 // Model units are in millimetres 567 // Model units are in millimetres
568 // Screen units are in pixels 568 // Screen units are in pixels
569 double mZoom; // pixels-per-model-unit 569 double _zoom; // pixels-per-model-unit
570 Vector mViewSize; // pixel: size of view window in pixels 570 Vector _viewSize; // pixel: size of view window in pixels
571 Point mViewCentre; // model: where in the model is the centre of our view 571 Point _viewCentre; // model: where in the model is the centre of our view
572 Rectangle mCanvasBounds; // model: 572 Rectangle _canvasBounds; // model:
573 573
574 // Child widgets: 574 // Child widgets:
575 HRuler mHRuler; 575 HRuler _hRuler;
576 VRuler mVRuler; 576 VRuler _vRuler;
577 DrawingArea mDrawingArea; 577 DrawingArea _drawingArea;
578 Adjustment mHAdjustment; 578 Adjustment _hAdjustment;
579 HScrollbar mHScrollbar; 579 HScrollbar _hScrollbar;
580 Adjustment mVAdjustment; 580 Adjustment _vAdjustment;
581 VScrollbar mVScrollbar; 581 VScrollbar _vScrollbar;
582 582
583 Layer[] mLayers; 583 Layer[] _layers;
584 EventHandler mEventHandler; 584 EventHandler _eventHandler;
585 Grid mGrid; 585 Grid _grid;
586 double mPPI; 586 double _ppi;
587 } 587 }
588 } 588 }