reflexion 0.1.23 → 0.1.26

Sign up to get free protection for your applications and to get access to all the features.
Files changed (71) hide show
  1. checksums.yaml +4 -4
  2. data/.doc/ext/reflex/capture_event.cpp +6 -5
  3. data/.doc/ext/reflex/contact_event.cpp +14 -12
  4. data/.doc/ext/reflex/draw_event.cpp +10 -8
  5. data/.doc/ext/reflex/event.cpp +2 -10
  6. data/.doc/ext/reflex/focus_event.cpp +14 -13
  7. data/.doc/ext/reflex/frame_event.cpp +17 -17
  8. data/.doc/ext/reflex/key_event.cpp +20 -19
  9. data/.doc/ext/reflex/pointer_event.cpp +1 -1
  10. data/.doc/ext/reflex/scroll_event.cpp +14 -17
  11. data/.doc/ext/reflex/timer.cpp +9 -1
  12. data/.doc/ext/reflex/timer_event.cpp +4 -13
  13. data/.doc/ext/reflex/update_event.cpp +6 -5
  14. data/.doc/ext/reflex/wheel_event.cpp +39 -22
  15. data/VERSION +1 -1
  16. data/ext/reflex/capture_event.cpp +6 -5
  17. data/ext/reflex/contact_event.cpp +16 -14
  18. data/ext/reflex/draw_event.cpp +9 -7
  19. data/ext/reflex/event.cpp +2 -11
  20. data/ext/reflex/focus_event.cpp +14 -13
  21. data/ext/reflex/frame_event.cpp +16 -16
  22. data/ext/reflex/key_event.cpp +20 -19
  23. data/ext/reflex/pointer_event.cpp +1 -1
  24. data/ext/reflex/scroll_event.cpp +15 -18
  25. data/ext/reflex/timer.cpp +15 -6
  26. data/ext/reflex/timer_event.cpp +9 -19
  27. data/ext/reflex/update_event.cpp +6 -5
  28. data/ext/reflex/wheel_event.cpp +40 -21
  29. data/include/reflex/event.h +224 -115
  30. data/include/reflex/shape.h +2 -2
  31. data/include/reflex/window.h +1 -1
  32. data/lib/reflex/contact_event.rb +7 -7
  33. data/lib/reflex/focus_event.rb +8 -8
  34. data/lib/reflex/key_event.rb +8 -8
  35. data/lib/reflex/pointer.rb +3 -3
  36. data/lib/reflex/pointer_event.rb +2 -2
  37. data/lib/reflex/timer_event.rb +2 -1
  38. data/lib/reflex/wheel_event.rb +1 -9
  39. data/lib/reflex/window.rb +1 -1
  40. data/reflex.gemspec +4 -4
  41. data/src/event.cpp +630 -76
  42. data/src/event.h +15 -0
  43. data/src/image_view.cpp +2 -2
  44. data/src/ios/app_delegate.h +0 -6
  45. data/src/ios/app_delegate.mm +1 -0
  46. data/src/ios/application.mm +6 -0
  47. data/src/ios/view_controller.mm +15 -9
  48. data/src/ios/window.mm +2 -4
  49. data/src/osx/event.h +1 -1
  50. data/src/osx/event.mm +9 -9
  51. data/src/osx/native_window.mm +23 -5
  52. data/src/shape.cpp +11 -13
  53. data/src/shape.h +1 -1
  54. data/src/view.cpp +137 -89
  55. data/src/view.h +5 -6
  56. data/src/window.cpp +28 -26
  57. data/src/world.cpp +6 -4
  58. data/test/test_capture_event.rb +16 -0
  59. data/test/test_contact_event.rb +40 -0
  60. data/test/test_draw_event.rb +35 -0
  61. data/test/test_event.rb +20 -6
  62. data/test/test_focus_event.rb +34 -0
  63. data/test/test_frame_event.rb +38 -0
  64. data/test/test_key_event.rb +33 -0
  65. data/test/test_pointer.rb +14 -14
  66. data/test/test_pointer_event.rb +1 -1
  67. data/test/test_scroll_event.rb +39 -0
  68. data/test/test_timer_event.rb +38 -0
  69. data/test/test_update_event.rb +29 -0
  70. data/test/test_wheel_event.rb +40 -0
  71. metadata +29 -11
data/src/event.cpp CHANGED
@@ -12,93 +12,360 @@ namespace Reflex
12
12
  {
13
13
 
14
14
 
15
+ struct Event::Data
16
+ {
17
+
18
+ bool blocked;
19
+
20
+ double time;
21
+
22
+ Xot::PSharedImpl<Data> parent;
23
+
24
+ Data (bool blocked = false, double time = Xot::time())
25
+ : blocked(blocked), time(time), parent(NULL)
26
+ {
27
+ }
28
+
29
+ void block ()
30
+ {
31
+ blocked = true;
32
+ if (parent) parent->block();
33
+ }
34
+
35
+ };// Event::Data
36
+
37
+
15
38
  Event::Event ()
16
- : blocked(false), time_(Xot::time())
39
+ {
40
+ }
41
+
42
+ Event::Event (const Event* src)
43
+ : self(new Data(*src->self))
44
+ {
45
+ self->parent = src->self;
46
+ }
47
+
48
+ Event::~Event ()
17
49
  {
18
50
  }
19
51
 
20
52
  void
21
53
  Event::block ()
22
54
  {
23
- blocked = true;
55
+ self->block();
24
56
  }
25
57
 
26
58
  bool
27
59
  Event::is_blocked () const
28
60
  {
29
- return blocked;
61
+ return self->blocked;
30
62
  }
31
63
 
32
64
  double
33
65
  Event::time () const
34
66
  {
35
- return time_;
67
+ return self->time;
36
68
  }
37
69
 
38
70
 
71
+ struct UpdateEvent::Data
72
+ {
73
+
74
+ double now;
75
+
76
+ float dt;
77
+
78
+ Data (double now = 0, float dt = 0)
79
+ : now(now), dt(dt)
80
+ {
81
+ }
82
+
83
+ };// UpdateEvent::Data
84
+
85
+
86
+ UpdateEvent::UpdateEvent ()
87
+ {
88
+ }
89
+
39
90
  UpdateEvent::UpdateEvent (double now, float dt)
40
- : now(now), dt(dt)
91
+ : self(new Data(now, dt))
92
+ {
93
+ }
94
+
95
+ UpdateEvent::UpdateEvent (const UpdateEvent* src)
96
+ : Event(src), self(new Data(*src->self))
97
+ {
98
+ }
99
+
100
+ UpdateEvent
101
+ UpdateEvent::dup () const
102
+ {
103
+ return UpdateEvent(this);
104
+ }
105
+
106
+ double
107
+ UpdateEvent::now () const
108
+ {
109
+ return self->now;
110
+ }
111
+
112
+ float
113
+ UpdateEvent::dt () const
41
114
  {
115
+ return self->dt;
42
116
  }
43
117
 
44
118
 
119
+ struct DrawEvent::Data
120
+ {
121
+
122
+ View* view;
123
+
124
+ Painter* painter;
125
+
126
+ Bounds bounds;
127
+
128
+ float dt, fps;
129
+
130
+ Data (float dt = 0, float fps = 0)
131
+ : view(NULL), painter(NULL), dt(dt), fps(fps)
132
+ {
133
+ }
134
+
135
+ };// DrawEvent::Data
136
+
137
+
138
+ void
139
+ DrawEvent_set_view (DrawEvent* pthis, View* view)
140
+ {
141
+ if (!pthis)
142
+ argument_error(__FILE__, __LINE__);
143
+
144
+ pthis->self->view = view;
145
+ }
146
+
147
+ void
148
+ DrawEvent_set_painter (DrawEvent* pthis, Painter* painter)
149
+ {
150
+ if (!pthis)
151
+ argument_error(__FILE__, __LINE__);
152
+
153
+ pthis->self->painter = painter;
154
+ }
155
+
156
+ void
157
+ DrawEvent_set_bounds (DrawEvent* pthis, const Bounds& bounds)
158
+ {
159
+ if (!pthis)
160
+ argument_error(__FILE__, __LINE__);
161
+
162
+ pthis->self->bounds = bounds;
163
+ }
164
+
165
+
166
+ DrawEvent::DrawEvent ()
167
+ {
168
+ }
169
+
45
170
  DrawEvent::DrawEvent (float dt, float fps)
46
- : view(NULL), painter(NULL), dt(dt), fps(fps)
171
+ : self(new Data(dt, fps))
172
+ {
173
+ }
174
+
175
+ DrawEvent::DrawEvent (const DrawEvent* src)
176
+ : Event(src), self(new Data(*src->self))
177
+ {
178
+ }
179
+
180
+ DrawEvent
181
+ DrawEvent::dup () const
182
+ {
183
+ return DrawEvent(this);
184
+ }
185
+
186
+ Painter*
187
+ DrawEvent::painter ()
188
+ {
189
+ return self->painter;
190
+ }
191
+
192
+ const Painter*
193
+ DrawEvent::painter () const
194
+ {
195
+ return const_cast<DrawEvent*>(this)->painter();
196
+ }
197
+
198
+ const Bounds&
199
+ DrawEvent::bounds () const
200
+ {
201
+ return self->bounds;
202
+ }
203
+
204
+ float
205
+ DrawEvent::dt () const
47
206
  {
207
+ return self->dt;
48
208
  }
49
209
 
210
+ float
211
+ DrawEvent::fps () const
212
+ {
213
+ return self->fps;
214
+ }
215
+
216
+
217
+ struct FrameEvent::Data
218
+ {
219
+
220
+ Bounds frame;
221
+
222
+ coord dx, dy, dw, dh;
223
+
224
+ float angle, dangle;
225
+
226
+ Data (
227
+ const Bounds& frame = 0,
228
+ coord dx = 0, coord dy = 0, coord dw = 0, coord dh = 0,
229
+ float angle = 0, float dangle = 0)
230
+ : frame(frame), dx(dx), dy(dy), dw(dw), dh(dh), angle(angle), dangle(dangle)
231
+ {
232
+ }
233
+
234
+ };// FrameEvent::Data
235
+
236
+
237
+ FrameEvent::FrameEvent ()
238
+ {
239
+ }
50
240
 
51
241
  FrameEvent::FrameEvent (
52
242
  const Bounds& frame, coord dx, coord dy, coord dwidth, coord dheight,
53
243
  float angle, float dangle)
54
- : frame(frame), dx(dx), dy(dy), dwidth(dwidth), dheight(dheight),
55
- angle(angle), dangle(dangle)
244
+ : self(new Data(frame, dx, dy, dwidth, dheight, angle, dangle))
56
245
  {
57
246
  }
58
247
 
59
248
  FrameEvent::FrameEvent (
60
249
  const Bounds& frame, const Bounds& prev_frame,
61
250
  float angle, float prev_angle)
62
- : frame(frame),
63
- dx( frame.x - prev_frame.x), dy( frame.y - prev_frame.y),
64
- dwidth(frame.w - prev_frame.w), dheight(frame.h - prev_frame.h),
65
- angle(angle), dangle(angle - prev_angle)
251
+ : self(new Data(
252
+ frame,
253
+ frame.x - prev_frame.x, frame.y - prev_frame.y,
254
+ frame.w - prev_frame.w, frame.h - prev_frame.h,
255
+ angle, angle - prev_angle))
256
+ {
257
+ }
258
+
259
+ FrameEvent::FrameEvent (const FrameEvent* src)
260
+ : Event(src), self(new Data(*src->self))
261
+ {
262
+ }
263
+
264
+ FrameEvent
265
+ FrameEvent::dup () const
66
266
  {
267
+ return FrameEvent(this);
268
+ }
269
+
270
+ const Bounds&
271
+ FrameEvent::frame () const
272
+ {
273
+ return self->frame;
274
+ }
275
+
276
+ coord
277
+ FrameEvent::dx () const
278
+ {
279
+ return self->dx;
280
+ }
281
+
282
+ coord
283
+ FrameEvent::dy () const
284
+ {
285
+ return self->dy;
286
+ }
287
+
288
+ coord
289
+ FrameEvent::dwidth () const
290
+ {
291
+ return self->dw;
292
+ }
293
+
294
+ coord
295
+ FrameEvent::dheight () const
296
+ {
297
+ return self->dh;
298
+ }
299
+
300
+ float
301
+ FrameEvent::angle () const
302
+ {
303
+ return self->angle;
304
+ }
305
+
306
+ float
307
+ FrameEvent::dangle () const
308
+ {
309
+ return self->dangle;
67
310
  }
68
311
 
69
312
  bool
70
313
  FrameEvent::is_move () const
71
314
  {
72
- return dx != 0 || dy != 0;
315
+ return self->dx != 0 || self->dy != 0;
73
316
  }
74
317
 
75
318
  bool
76
319
  FrameEvent::is_resize () const
77
320
  {
78
- return dwidth != 0 || dheight != 0;
321
+ return self->dw != 0 || self->dh != 0;
79
322
  }
80
323
 
81
324
  bool
82
325
  FrameEvent::is_rotate () const
83
326
  {
84
- return dangle != 0;
327
+ return self->dangle != 0;
85
328
  }
86
329
 
87
330
 
331
+ struct ScrollEvent::Data
332
+ {
333
+
334
+ Point scroll, dscroll;
335
+
336
+ Data (const Point& scroll, const Point& dscroll)
337
+ : scroll(scroll), dscroll(dscroll)
338
+ {
339
+ }
340
+
341
+ };// ScrollEvent::Data
342
+
343
+
88
344
  ScrollEvent::ScrollEvent ()
89
- : x(0), y(0), z(0), dx(0), dy(0), dz(0)
345
+ : self(new Data(0, 0))
90
346
  {
91
347
  }
92
348
 
93
349
  ScrollEvent::ScrollEvent (coord x, coord y, coord z, coord dx, coord dy, coord dz)
94
- : x(x), y(y), z(z), dx(dx), dy(dy), dz(dz)
350
+ : self(new Data(Point(x, y, z), Point(dx, dy, dz)))
351
+ {
352
+ }
353
+
354
+ ScrollEvent::ScrollEvent (const ScrollEvent* src)
355
+ : Event(src), self(new Data(*src->self))
356
+ {
357
+ }
358
+
359
+ ScrollEvent
360
+ ScrollEvent::dup () const
95
361
  {
362
+ return ScrollEvent(this);
96
363
  }
97
364
 
98
365
  Point&
99
366
  ScrollEvent::scroll ()
100
367
  {
101
- return *(Point*) &scroll_;
368
+ return self->scroll;
102
369
  }
103
370
 
104
371
  const Point&
@@ -108,38 +375,163 @@ namespace Reflex
108
375
  }
109
376
 
110
377
  Point&
111
- ScrollEvent::delta ()
378
+ ScrollEvent::dscroll ()
112
379
  {
113
- return *(Point*) &delta_;
380
+ return self->dscroll;
114
381
  }
115
382
 
116
383
  const Point&
117
- ScrollEvent::delta () const
384
+ ScrollEvent::dscroll () const
118
385
  {
119
- return const_cast<ScrollEvent*>(this)->delta();
386
+ return const_cast<ScrollEvent*>(this)->dscroll();
120
387
  }
121
388
 
122
389
 
390
+ struct FocusEvent::Data
391
+ {
392
+
393
+ Action action;
394
+
395
+ View *current, *last;
396
+
397
+ Data (Action action = ACTION_NONE, View* current = NULL, View* last = NULL)
398
+ : action(action), current(current), last(last)
399
+ {
400
+ }
401
+
402
+ };// FocusEvent::Data
403
+
404
+
123
405
  FocusEvent::FocusEvent ()
124
406
  {
125
407
  }
126
408
 
127
- FocusEvent::FocusEvent (Type type, View* current, View* last)
128
- : type(type), current(current), last(last)
409
+ FocusEvent::FocusEvent (Action action, View* current, View* last)
410
+ : self(new Data(action, current, last))
129
411
  {
130
412
  }
131
413
 
414
+ FocusEvent::FocusEvent (const FocusEvent* src)
415
+ : Event(src), self(new Data(*src->self))
416
+ {
417
+ }
418
+
419
+ FocusEvent
420
+ FocusEvent::dup () const
421
+ {
422
+ return FocusEvent(this);
423
+ }
424
+
425
+ FocusEvent::Action
426
+ FocusEvent::action () const
427
+ {
428
+ return self->action;
429
+ }
430
+
431
+ View*
432
+ FocusEvent::current () const
433
+ {
434
+ return self->current;
435
+ }
436
+
437
+ View*
438
+ FocusEvent::last () const
439
+ {
440
+ return self->last;
441
+ }
442
+
443
+
444
+ struct KeyEvent::Data
445
+ {
446
+
447
+ Action action;
448
+
449
+ String chars;
450
+
451
+ int code;
452
+
453
+ uint modifiers;
454
+
455
+ int repeat;
456
+
457
+ bool captured;
458
+
459
+ Data (
460
+ Action action = ACTION_NONE, const char* chars = NULL, int code = KEY_NONE,
461
+ uint modifiers = MOD_NONE, int repeat = 0, bool captured = false)
462
+ : action(action), chars(chars ? chars : ""), code(code),
463
+ modifiers(modifiers), repeat(repeat), captured(captured)
464
+ {
465
+ }
466
+
467
+ };// KeyEvent::Data
468
+
469
+
470
+ void
471
+ KeyEvent_set_captured (KeyEvent* pthis, bool captured)
472
+ {
473
+ if (!pthis)
474
+ argument_error(__FILE__, __LINE__);
475
+
476
+ pthis->self->captured = captured;
477
+ }
478
+
132
479
 
133
480
  KeyEvent::KeyEvent ()
134
- : type(NONE), code(KEY_NONE), modifiers(MOD_NONE), repeat(0), captured(false)
135
481
  {
136
482
  }
137
483
 
138
484
  KeyEvent::KeyEvent (
139
- Type type, const char* chars, int code, uint modifiers, int repeat)
140
- : type(type), chars(chars ? chars : ""), code(code), modifiers(modifiers),
141
- repeat(repeat), captured(false)
485
+ Action action, const char* chars, int code, uint modifiers, int repeat)
486
+ : self(new Data(action, chars, code, modifiers, repeat))
487
+ {
488
+ }
489
+
490
+ KeyEvent::KeyEvent (const KeyEvent* src)
491
+ : Event(src), self(new Data(*src->self))
492
+ {
493
+ }
494
+
495
+ KeyEvent
496
+ KeyEvent::dup () const
497
+ {
498
+ return KeyEvent(this);
499
+ }
500
+
501
+ KeyEvent::Action
502
+ KeyEvent::action () const
142
503
  {
504
+ return self->action;
505
+ }
506
+
507
+ const char*
508
+ KeyEvent::chars () const
509
+ {
510
+ return self->chars;
511
+ }
512
+
513
+ int
514
+ KeyEvent::code () const
515
+ {
516
+ return self->code;
517
+ }
518
+
519
+ uint
520
+ KeyEvent::modifiers () const
521
+ {
522
+ return self->modifiers;
523
+ }
524
+
525
+ int
526
+ KeyEvent::repeat () const
527
+ {
528
+ return self->repeat;
529
+ }
530
+
531
+ bool
532
+ KeyEvent::is_captured () const
533
+ {
534
+ return self->captured;
143
535
  }
144
536
 
145
537
 
@@ -210,6 +602,15 @@ namespace Reflex
210
602
  fun(pointer);
211
603
  }
212
604
 
605
+ void
606
+ PointerEvent_set_captured (PointerEvent* pthis, bool captured)
607
+ {
608
+ if (!pthis)
609
+ argument_error(__FILE__, __LINE__);
610
+
611
+ pthis->self->captured = captured;
612
+ }
613
+
213
614
  static void
214
615
  filter_and_offset_pointer_positions (PointerEvent* event, const Bounds& frame)
215
616
  {
@@ -283,41 +684,25 @@ namespace Reflex
283
684
  }
284
685
 
285
686
 
286
- PointerEvent::PointerEvent (bool captured)
287
- : self(new Data(captured))
288
- {
289
- }
290
-
291
- PointerEvent::PointerEvent (const Pointer& pointer, bool captured)
292
- : self(new Data(captured))
687
+ PointerEvent::PointerEvent ()
293
688
  {
294
- self->pointers.emplace_back(pointer);
295
689
  }
296
690
 
297
- PointerEvent::PointerEvent (const Pointer* pointers, size_t size, bool captured)
298
- : self(new Data(captured))
691
+ PointerEvent::PointerEvent (const Pointer* pointers, size_t size)
299
692
  {
300
693
  for (size_t i = 0; i < size; ++i)
301
694
  self->pointers.emplace_back(pointers[i]);
302
695
  }
303
696
 
304
- PointerEvent::PointerEvent (const This& obj)
305
- : self(new Data(*obj.self))
306
- {
307
- }
308
-
309
- PointerEvent&
310
- PointerEvent::operator = (const This& obj)
697
+ PointerEvent::PointerEvent (const PointerEvent* src)
698
+ : Event(src), self(new Data(*src->self))
311
699
  {
312
- if (&obj == this) return *this;
313
-
314
- Event::operator=(obj);
315
- *self = *obj.self;
316
- return *this;
317
700
  }
318
701
 
319
- PointerEvent::~PointerEvent ()
702
+ PointerEvent
703
+ PointerEvent::dup () const
320
704
  {
705
+ return PointerEvent(this);
321
706
  }
322
707
 
323
708
  size_t
@@ -348,21 +733,58 @@ namespace Reflex
348
733
  }
349
734
 
350
735
 
736
+ struct WheelEvent::Data
737
+ {
738
+
739
+ Point position, dposition;
740
+
741
+ uint modifiers;
742
+
743
+ Data (
744
+ const Point& position = 0, const Point& dposition = 0,
745
+ uint modifiers = 0)
746
+ : position(position), dposition(dposition), modifiers(modifiers)
747
+ {
748
+ }
749
+
750
+ };// WheelEvent::Data
751
+
752
+
753
+ void
754
+ WheelEvent_set_position (WheelEvent* pthis, const Point& position)
755
+ {
756
+ if (!pthis)
757
+ argument_error(__FILE__, __LINE__);
758
+
759
+ pthis->self->position = position;
760
+ }
761
+
762
+
351
763
  WheelEvent::WheelEvent ()
352
- : dx(0), dy(0), dz(0), x(0), y(0), z(0), modifiers(0)
353
764
  {
354
765
  }
355
766
 
356
767
  WheelEvent::WheelEvent (
357
- coord dx, coord dy, coord dz, coord x, coord y, coord z, uint modifiers)
358
- : dx(dx), dy(dy), dz(dz), x(x), y(y), z(z), modifiers(modifiers)
768
+ coord x, coord y, coord z, coord dx, coord dy, coord dz, uint modifiers)
769
+ : self(new Data(Point(x, y, z), Point(dx, dy, dz), modifiers))
359
770
  {
360
771
  }
361
772
 
773
+ WheelEvent::WheelEvent (const WheelEvent* src)
774
+ : Event(src), self(new Data(*src->self))
775
+ {
776
+ }
777
+
778
+ WheelEvent
779
+ WheelEvent::dup () const
780
+ {
781
+ return WheelEvent(this);
782
+ }
783
+
362
784
  Point&
363
785
  WheelEvent::position ()
364
786
  {
365
- return *(Point*) &position_;
787
+ return self->position;
366
788
  }
367
789
 
368
790
  const Point&
@@ -372,79 +794,211 @@ namespace Reflex
372
794
  }
373
795
 
374
796
  Point&
375
- WheelEvent::delta ()
797
+ WheelEvent::dposition ()
376
798
  {
377
- return *(Point*) &delta_;
799
+ return self->dposition;
378
800
  }
379
801
 
380
802
  const Point&
381
- WheelEvent::delta () const
803
+ WheelEvent::dposition () const
382
804
  {
383
- return const_cast<WheelEvent*>(this)->delta();
805
+ return const_cast<WheelEvent*>(this)->dposition();
384
806
  }
385
807
 
808
+ uint
809
+ WheelEvent::modifiers () const
810
+ {
811
+ return self->modifiers;
812
+ }
813
+
814
+
815
+ struct CaptureEvent::Data
816
+ {
817
+
818
+ uint begin, end;
819
+
820
+ Data (uint begin = 0, uint end = 0)
821
+ : begin(begin), end(end)
822
+ {
823
+ }
824
+
825
+ };// CaptureEvent::Data
826
+
386
827
 
387
828
  CaptureEvent::CaptureEvent ()
388
- : begin(0), end(0)
389
829
  {
390
830
  }
391
831
 
392
832
  CaptureEvent::CaptureEvent (uint begin, uint end)
393
- : begin(begin), end(end)
833
+ : self(new Data(begin, end))
834
+ {
835
+ }
836
+
837
+ CaptureEvent::CaptureEvent (const CaptureEvent* src)
838
+ : Event(src), self(new Data(*src->self))
839
+ {
840
+ }
841
+
842
+ CaptureEvent
843
+ CaptureEvent::dup () const
844
+ {
845
+ return CaptureEvent(this);
846
+ }
847
+
848
+ uint
849
+ CaptureEvent::begin () const
394
850
  {
851
+ return self->begin;
395
852
  }
396
853
 
854
+ uint
855
+ CaptureEvent::end () const
856
+ {
857
+ return self->end;
858
+ }
859
+
860
+
861
+ struct TimerEvent::Data
862
+ {
863
+
864
+ Timer::Ref timer;
865
+
866
+ Data (Timer* timer = NULL)
867
+ : timer(timer)
868
+ {
869
+ }
870
+
871
+ };// TimerEvent::Data
872
+
873
+
874
+ TimerEvent::TimerEvent ()
875
+ {
876
+ }
397
877
 
398
878
  TimerEvent::TimerEvent (Timer* timer)
399
- : timer(timer)
879
+ : self(new Data(timer))
880
+ {
881
+ }
882
+
883
+ TimerEvent::TimerEvent (const TimerEvent* src)
884
+ : Event(src), self(new Data(*src->self))
885
+ {
886
+ }
887
+
888
+ TimerEvent
889
+ TimerEvent::dup () const
890
+ {
891
+ return TimerEvent(this);
892
+ }
893
+
894
+ Timer*
895
+ TimerEvent::timer ()
400
896
  {
897
+ return self->timer;
898
+ }
899
+
900
+ const Timer*
901
+ TimerEvent::timer () const
902
+ {
903
+ return const_cast<TimerEvent*>(this)->timer();
401
904
  }
402
905
 
403
906
  View*
404
907
  TimerEvent::owner () const
405
908
  {
406
- return timer ? timer->owner() : NULL;
909
+ return self->timer ? self->timer->owner() : NULL;
407
910
  }
408
911
 
409
912
  int
410
913
  TimerEvent::id () const
411
914
  {
412
- return timer ? timer->id() : Timer::ID_INVALID;
915
+ return self->timer ? self->timer->id() : Timer::ID_INVALID;
413
916
  }
414
917
 
415
918
  float
416
919
  TimerEvent::interval () const
417
920
  {
418
- return timer ? timer->interval() : -1;
419
- }
420
-
421
- void
422
- TimerEvent::set_count (int count)
423
- {
424
- if (timer) timer->set_count(count);
921
+ return self->timer ? self->timer->interval() : -1;
425
922
  }
426
923
 
427
924
  int
428
925
  TimerEvent::count () const
429
926
  {
430
- return timer ? timer->count() : 0;
927
+ return self->timer ? self->timer->count() : 0;
431
928
  }
432
929
 
433
930
  bool
434
931
  TimerEvent::is_finished () const
435
932
  {
436
- return timer ? timer->is_finished() : true;
933
+ return self->timer ? self->timer->is_finished() : true;
437
934
  }
438
935
 
439
936
 
937
+ struct ContactEvent::Data
938
+ {
939
+
940
+ Action action;
941
+
942
+ Shape* shape;
943
+
944
+ View* view;
945
+
946
+ Data (Action action = ACTION_NONE, Shape* shape = NULL, View* view = NULL)
947
+ : action(action), shape(shape), view(view)
948
+ {
949
+ }
950
+
951
+ };// ContactEvent::Data
952
+
953
+
440
954
  ContactEvent::ContactEvent ()
441
- : type(NONE), shape(NULL), view(NULL)
442
955
  {
443
956
  }
444
957
 
445
- ContactEvent::ContactEvent (Type type, Shape* shape)
446
- : type(type), shape(shape), view(shape ? shape->owner() : NULL)
958
+ ContactEvent::ContactEvent (Action action, Shape* shape)
959
+ : self(new Data(action, shape, shape ? shape->owner() : NULL))
960
+ {
961
+ }
962
+
963
+ ContactEvent::ContactEvent (const ContactEvent* src)
964
+ : Event(src), self(new Data(*src->self))
965
+ {
966
+ }
967
+
968
+ ContactEvent
969
+ ContactEvent::dup () const
970
+ {
971
+ return ContactEvent(this);
972
+ }
973
+
974
+ ContactEvent::Action
975
+ ContactEvent::action () const
976
+ {
977
+ return self->action;
978
+ }
979
+
980
+ Shape*
981
+ ContactEvent::shape ()
982
+ {
983
+ return self->shape;
984
+ }
985
+
986
+ const Shape*
987
+ ContactEvent::shape () const
988
+ {
989
+ return const_cast<ContactEvent*>(this)->shape();
990
+ }
991
+
992
+ View*
993
+ ContactEvent::view ()
994
+ {
995
+ return self->view;
996
+ }
997
+
998
+ const View*
999
+ ContactEvent::view () const
447
1000
  {
1001
+ return const_cast<ContactEvent*>(this)->view();
448
1002
  }
449
1003
 
450
1004