reflexion 0.1.23 → 0.1.24

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (65) 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/lib/reflex/contact_event.rb +7 -7
  32. data/lib/reflex/focus_event.rb +8 -8
  33. data/lib/reflex/key_event.rb +8 -8
  34. data/lib/reflex/pointer.rb +3 -3
  35. data/lib/reflex/timer_event.rb +2 -1
  36. data/lib/reflex/wheel_event.rb +1 -9
  37. data/lib/reflex/window.rb +1 -1
  38. data/reflex.gemspec +4 -4
  39. data/src/event.cpp +630 -76
  40. data/src/event.h +15 -0
  41. data/src/image_view.cpp +2 -2
  42. data/src/ios/view_controller.mm +1 -1
  43. data/src/osx/event.h +1 -1
  44. data/src/osx/event.mm +9 -9
  45. data/src/osx/native_window.mm +1 -1
  46. data/src/shape.cpp +11 -13
  47. data/src/shape.h +1 -1
  48. data/src/view.cpp +137 -89
  49. data/src/view.h +5 -6
  50. data/src/window.cpp +44 -38
  51. data/src/world.cpp +6 -4
  52. data/test/test_capture_event.rb +16 -0
  53. data/test/test_contact_event.rb +40 -0
  54. data/test/test_draw_event.rb +35 -0
  55. data/test/test_event.rb +20 -6
  56. data/test/test_focus_event.rb +34 -0
  57. data/test/test_frame_event.rb +38 -0
  58. data/test/test_key_event.rb +33 -0
  59. data/test/test_pointer.rb +14 -14
  60. data/test/test_pointer_event.rb +1 -1
  61. data/test/test_scroll_event.rb +39 -0
  62. data/test/test_timer_event.rb +38 -0
  63. data/test/test_update_event.rb +29 -0
  64. data/test/test_wheel_event.rb +40 -0
  65. metadata +29 -11
data/src/event.h CHANGED
@@ -12,6 +12,16 @@ namespace Reflex
12
12
  {
13
13
 
14
14
 
15
+ void DrawEvent_set_view (DrawEvent* pthis, View* view);
16
+
17
+ void DrawEvent_set_painter (DrawEvent* pthis, Painter* painter);
18
+
19
+ void DrawEvent_set_bounds (DrawEvent* pthis, const Bounds& bounds);
20
+
21
+
22
+ void KeyEvent_set_captured (KeyEvent* pthis, bool captured);
23
+
24
+
15
25
  void PointerEvent_add_pointer (PointerEvent* pthis, const Pointer& pointer);
16
26
 
17
27
  void PointerEvent_erase_pointer (PointerEvent* pthis, Pointer::ID id);
@@ -21,11 +31,16 @@ namespace Reflex
21
31
  void PointerEvent_each_pointer (
22
32
  const PointerEvent* pthis, std::function<void(const Pointer&)> fun);
23
33
 
34
+ void PointerEvent_set_captured (PointerEvent* pthis, bool captured);
35
+
24
36
  void PointerEvent_update_for_child_view (PointerEvent* pthis, const View* view);
25
37
 
26
38
  void PointerEvent_update_for_capturing_view (PointerEvent* pthis, const View* view);
27
39
 
28
40
 
41
+ void WheelEvent_set_position (WheelEvent* pthis, const Point& position);
42
+
43
+
29
44
  }// Reflex
30
45
 
31
46
 
data/src/image_view.cpp CHANGED
@@ -53,8 +53,8 @@ namespace Reflex
53
53
  {
54
54
  if (!self->image) return;
55
55
 
56
- assert(e && e->painter);
57
- Painter* p = e->painter;
56
+ assert(e && e->painter());
57
+ Painter* p = e->painter();
58
58
 
59
59
  Color f = p->fill(), s = p->stroke();
60
60
  p->set_fill(1);
@@ -376,7 +376,7 @@ ReflexViewController_get_show_fun ()
376
376
 
377
377
  if (dpos != 0 || dsize != 0)
378
378
  {
379
- Reflex::FrameEvent e(b, dpos.x, dpos.y, dsize.x, dsize.y);
379
+ Reflex::FrameEvent e(b, dpos.x, dpos.y, dsize.x, dsize.y, 0, 0);
380
380
  if (dpos != 0) win->on_move(&e);
381
381
  if (dsize != 0)
382
382
  {
data/src/osx/event.h CHANGED
@@ -15,7 +15,7 @@ namespace Reflex
15
15
  struct NativeKeyEvent : public KeyEvent
16
16
  {
17
17
 
18
- NativeKeyEvent (NSEvent* event, Type type);
18
+ NativeKeyEvent (NSEvent* event, Action action);
19
19
 
20
20
  };// NativeKeyEvent
21
21
 
data/src/osx/event.mm CHANGED
@@ -169,11 +169,11 @@ namespace Reflex
169
169
  return 0;
170
170
  }
171
171
 
172
- static KeyEvent::Type
173
- get_flag_key_event_type(const NSEvent* e)
172
+ static KeyEvent::Action
173
+ get_flag_key_event_action (const NSEvent* e)
174
174
  {
175
175
  uint mask = get_modifier_flag_mask(e);
176
- if (mask == 0) return Reflex::KeyEvent::NONE;
176
+ if (mask == 0) return Reflex::KeyEvent::ACTION_NONE;
177
177
 
178
178
  return [e modifierFlags] & mask
179
179
  ? Reflex::KeyEvent::DOWN
@@ -251,18 +251,18 @@ namespace Reflex
251
251
  }
252
252
 
253
253
 
254
- NativeKeyEvent::NativeKeyEvent (NSEvent* e, Type type)
254
+ NativeKeyEvent::NativeKeyEvent (NSEvent* e, Action action)
255
255
  : KeyEvent(
256
- type, get_chars(e), get_code([e keyCode]), get_modifiers(e),
257
- [e isARepeat] ? 1 : 0)
256
+ action, get_chars(e), get_code([e keyCode]),
257
+ get_modifiers(e), [e isARepeat] ? 1 : 0)
258
258
  {
259
259
  }
260
260
 
261
261
 
262
262
  NativeFlagKeyEvent::NativeFlagKeyEvent (NSEvent* e)
263
263
  : KeyEvent(
264
- get_flag_key_event_type(e), "", get_code([e keyCode]), get_modifiers(e),
265
- 0)
264
+ get_flag_key_event_action(e), "", get_code([e keyCode]),
265
+ get_modifiers(e), 0)
266
266
  {
267
267
  }
268
268
 
@@ -295,7 +295,7 @@ namespace Reflex
295
295
  NativeWheelEvent::NativeWheelEvent (NSEvent* e, NSView* view)
296
296
  : WheelEvent(0, 0, 0, [e deltaX], [e deltaY], [e deltaZ], get_modifiers(e))
297
297
  {
298
- position_ = get_pointer_position(e, view);
298
+ WheelEvent_set_position(this, get_pointer_position(e, view));
299
299
  }
300
300
 
301
301
 
@@ -269,7 +269,7 @@ count_mouse_buttons (const Reflex::PointerEvent& e)
269
269
 
270
270
  if (dpos != 0 || dsize != 0)
271
271
  {
272
- Reflex::FrameEvent e(b, dpos.x, dpos.y, dsize.x, dsize.y);
272
+ Reflex::FrameEvent e(b, dpos.x, dpos.y, dsize.x, dsize.y, 0, 0);
273
273
  if (dpos != 0) win->on_move(&e);
274
274
  if (dsize != 0)
275
275
  {
data/src/shape.cpp CHANGED
@@ -432,25 +432,23 @@ namespace Reflex
432
432
  }
433
433
 
434
434
  void
435
- Shape_call_contact_event (Shape* shape, const ContactEvent& event)
435
+ Shape_call_contact_event (Shape* shape, ContactEvent* event)
436
436
  {
437
- if (!shape)
437
+ if (!shape || !event)
438
438
  argument_error(__FILE__, __LINE__);
439
439
 
440
- ContactEvent e = event;
441
- shape->on_contact(&e);
440
+ shape->on_contact(event);
442
441
 
443
- switch (e.type)
442
+ switch (event->action())
444
443
  {
445
- case ContactEvent::BEGIN: shape->on_contact_begin(&e); break;
446
- case ContactEvent::END: shape->on_contact_end(&e); break;
447
- case ContactEvent::NONE: break;
444
+ case ContactEvent::BEGIN: shape->on_contact_begin(event); break;
445
+ case ContactEvent::END: shape->on_contact_end(event); break;
446
+ default: break;
448
447
  }
449
448
 
450
- if (e.is_blocked())
451
- return;
449
+ if (event->is_blocked()) return;
452
450
 
453
- View_call_contact_event(shape->owner(), e);
451
+ View_call_contact_event(shape->owner(), event);
454
452
  }
455
453
 
456
454
 
@@ -587,9 +585,9 @@ namespace Reflex
587
585
  void
588
586
  Shape::on_draw (DrawEvent* e)
589
587
  {
590
- assert(e && e->painter);
588
+ assert(e && e->painter());
591
589
 
592
- e->painter->polygon(self->polygon);
590
+ e->painter()->polygon(self->polygon);
593
591
  }
594
592
 
595
593
  void
data/src/shape.h CHANGED
@@ -52,7 +52,7 @@ namespace Reflex
52
52
 
53
53
  void Shape_update (Shape* shape, bool force = false);
54
54
 
55
- void Shape_call_contact_event (Shape* shape, const ContactEvent& event);
55
+ void Shape_call_contact_event (Shape* shape, ContactEvent* event);
56
56
 
57
57
 
58
58
  }// Reflex
data/src/view.cpp CHANGED
@@ -948,7 +948,7 @@ namespace Reflex
948
948
 
949
949
  View::Data* self = view->self.get();
950
950
 
951
- fire_timers(view, event.now);
951
+ fire_timers(view, event.now());
952
952
 
953
953
  View::ChildList* pchildren = self->pchildren.get();
954
954
  if (pchildren)
@@ -958,9 +958,9 @@ namespace Reflex
958
958
  }
959
959
 
960
960
  update_view_shapes(view);
961
- update_child_world(view, event.dt);
961
+ update_child_world(view, event.dt());
962
962
 
963
- UpdateEvent e = event;
963
+ UpdateEvent e = event.dup();
964
964
  view->on_update(&e);
965
965
 
966
966
  update_views_for_selectors(view);
@@ -1024,7 +1024,10 @@ namespace Reflex
1024
1024
  static void
1025
1025
  draw_default_shape (View* view, DrawEvent* event)
1026
1026
  {
1027
- assert(view && event && event->painter);
1027
+ assert(view && event);
1028
+
1029
+ Painter* painter = event->painter();
1030
+ assert(painter);
1028
1031
 
1029
1032
  const Style& style = View_get_style(view);
1030
1033
  const Color& back_fill = style.background_fill();
@@ -1033,26 +1036,26 @@ namespace Reflex
1033
1036
  Shape* shape = view->shape(false);
1034
1037
  if (shape)
1035
1038
  {
1036
- setup_painter(event->painter, back_fill, back_stroke);
1039
+ setup_painter(painter, back_fill, back_stroke);
1037
1040
  shape->on_draw(event);
1038
1041
  }
1039
1042
  else if (back_fill || back_stroke)
1040
1043
  {
1041
- setup_painter(event->painter, back_fill, back_stroke);
1042
- event->painter->rect(event->bounds);
1044
+ setup_painter(painter, back_fill, back_stroke);
1045
+ painter->rect(event->bounds());
1043
1046
  }
1044
1047
  }
1045
1048
 
1046
1049
  static void
1047
1050
  draw_content (View* view, DrawEvent* event)
1048
1051
  {
1049
- assert(view && event && event->painter);
1052
+ assert(view && event && event->painter());
1050
1053
 
1051
1054
  draw_default_shape(view, event);
1052
1055
 
1053
1056
  const Style& style = View_get_style(view);
1054
1057
  setup_painter(
1055
- event->painter, style.foreground_fill(), style.foreground_stroke());
1058
+ event->painter(), style.foreground_fill(), style.foreground_stroke());
1056
1059
 
1057
1060
  View::ShapeList* pshapes = view->self->pshapes.get();
1058
1061
  if (pshapes && !pshapes->empty())
@@ -1068,10 +1071,10 @@ namespace Reflex
1068
1071
  draw_view (
1069
1072
  View* view, DrawEvent* event, const Point& offset, const Bounds& clip)
1070
1073
  {
1071
- assert(view && event && event->painter);
1074
+ assert(view && event && event->painter());
1072
1075
  View::Data* self = view->self.get();
1073
1076
 
1074
- Painter* p = event->painter;
1077
+ Painter* p = event->painter();
1075
1078
  p->push_state();
1076
1079
 
1077
1080
  if (self->has_flag(View::FLAG_CLIP) && !self->pbody)
@@ -1088,8 +1091,8 @@ namespace Reflex
1088
1091
  {
1089
1092
  for (auto& pchild : *pchildren)
1090
1093
  {
1091
- if (event->bounds & pchild->self->frame)
1092
- View_draw_tree(pchild.get(), *event, offset, clip);
1094
+ if (event->bounds() & pchild->self->frame)
1095
+ View_draw_tree(pchild.get(), event, offset, clip);
1093
1096
  }
1094
1097
  }
1095
1098
 
@@ -1105,23 +1108,24 @@ namespace Reflex
1105
1108
  static void
1106
1109
  draw_view_to_cache (View* view, DrawEvent* event)
1107
1110
  {
1108
- assert(view && event && event->painter && view->self->pcache_image);
1111
+ assert(view && event && event->painter() && view->self->pcache_image);
1109
1112
 
1110
- Painter* view_painter = event->painter;
1113
+ Painter* view_painter = event->painter();
1111
1114
  Painter cache_painter = view->self->pcache_image->painter();
1112
- event->painter = &cache_painter;
1115
+
1116
+ DrawEvent_set_painter(event, &cache_painter);
1113
1117
 
1114
1118
  cache_painter.begin();
1115
- draw_view(view, event, 0, event->bounds);
1119
+ draw_view(view, event, 0, event->bounds());
1116
1120
  cache_painter.end();
1117
1121
 
1118
- event->painter = view_painter;
1122
+ DrawEvent_set_painter(event, view_painter);
1119
1123
  }
1120
1124
 
1121
1125
  static bool
1122
1126
  draw_view_with_cache (View* view, DrawEvent* event, bool redraw)
1123
1127
  {
1124
- assert(view && event && event->painter);
1128
+ assert(view && event && event->painter());
1125
1129
  View::Data* self = view->self.get();
1126
1130
 
1127
1131
  if (!use_cache(view))
@@ -1130,7 +1134,7 @@ namespace Reflex
1130
1134
  return false;
1131
1135
  }
1132
1136
 
1133
- Painter* painter = event->painter;
1137
+ Painter* painter = event->painter();
1134
1138
 
1135
1139
  if (reset_cache_image(view, *painter) || redraw)
1136
1140
  {
@@ -1148,7 +1152,7 @@ namespace Reflex
1148
1152
  if (self->pfilter && *self->pfilter)
1149
1153
  self->pfilter->apply(painter, *self->pcache_image);
1150
1154
  else
1151
- painter->image(*self->pcache_image, event->bounds);
1155
+ painter->image(*self->pcache_image, event->bounds());
1152
1156
 
1153
1157
  painter->pop_state();
1154
1158
 
@@ -1157,7 +1161,7 @@ namespace Reflex
1157
1161
 
1158
1162
  void
1159
1163
  View_draw_tree (
1160
- View* view, const DrawEvent& event, const Point& offset, const Bounds& clip)
1164
+ View* view, DrawEvent* event, const Point& offset, const Bounds& clip)
1161
1165
  {
1162
1166
  if (!view)
1163
1167
  argument_error(__FILE__, __LINE__);
@@ -1166,26 +1170,24 @@ namespace Reflex
1166
1170
 
1167
1171
  bool redraw = self->check_and_remove_flag(View::Data::REDRAW);
1168
1172
 
1169
- if (event.is_blocked() || view->hidden())
1173
+ if (view->hidden() || event->is_blocked())
1170
1174
  return;
1171
1175
 
1172
1176
  if (self->frame.width <= 0 || self->frame.height <= 0)
1173
1177
  return;
1174
1178
 
1175
- Point pos = self->frame.position();
1176
- Bounds clip2 = self->frame.dup().move_by(offset) & clip;
1177
- DrawEvent e = event;
1178
- e.view = view;
1179
- e.bounds = self->frame;
1180
- e.bounds.move_to(0, 0, e.bounds.z);
1179
+ Bounds bounds = self->frame;
1180
+ Point pos = bounds.position();
1181
+ Bounds clip2 = bounds.dup().move_by(offset) & clip;
1181
1182
 
1183
+ bounds.move_to(0, 0, bounds.z);
1182
1184
  if (self->pscroll)
1183
1185
  {
1184
- pos .move_by( *self->pscroll);
1185
- e.bounds.move_by(-*self->pscroll);
1186
+ bounds.move_by(-*self->pscroll);
1187
+ pos .move_by( *self->pscroll);
1186
1188
  }
1187
1189
 
1188
- Painter* p = event.painter;
1190
+ Painter* p = event->painter();
1189
1191
  p->push_matrix();
1190
1192
  p->translate(pos);
1191
1193
 
@@ -1197,9 +1199,15 @@ namespace Reflex
1197
1199
  if (zoom != 1 && zoom > 0)
1198
1200
  p->scale(zoom, zoom);
1199
1201
 
1200
- pos += offset;
1202
+ DrawEvent e = event->dup();
1203
+ DrawEvent_set_view(&e, view);
1204
+ DrawEvent_set_bounds(&e, bounds);
1205
+
1201
1206
  if (!draw_view_with_cache(view, &e, redraw))
1207
+ {
1208
+ pos += offset;
1202
1209
  draw_view(view, &e, pos, clip2);
1210
+ }
1203
1211
 
1204
1212
  p->pop_matrix();
1205
1213
  }
@@ -1227,127 +1235,167 @@ namespace Reflex
1227
1235
  view->self->add_flag(View::Data::UPDATE_SHAPES);
1228
1236
  }
1229
1237
 
1230
- template <typename FUN, typename EVENT>
1238
+ void
1239
+ View_call_key_event (View* view, KeyEvent* event)
1240
+ {
1241
+ if (!view || !event)
1242
+ argument_error(__FILE__, __LINE__);
1243
+
1244
+ if (view->hidden()) return;
1245
+
1246
+ KeyEvent e = event->dup();
1247
+ view->on_key(&e);
1248
+
1249
+ switch (e.action())
1250
+ {
1251
+ case KeyEvent::DOWN: view->on_key_down(&e); break;
1252
+ case KeyEvent::UP: view->on_key_up(&e); break;
1253
+ default: break;
1254
+ }
1255
+ }
1256
+
1231
1257
  static void
1232
- call_children (View* parent, const EVENT& event, FUN fun)
1258
+ call_children (View* parent, std::function<bool(View*)> fun)
1233
1259
  {
1234
1260
  assert(parent);
1235
1261
 
1236
1262
  auto* pchildren = parent->self->pchildren.get();
1237
1263
  if (!pchildren) return;
1238
1264
 
1239
- for (auto& pchild : *pchildren)
1240
- fun(pchild.get(), event);
1265
+ auto end = pchildren->rend();
1266
+ for (auto it = pchildren->rbegin(); it != end; ++it)
1267
+ {
1268
+ if (!fun(it->get()))
1269
+ break;
1270
+ }
1241
1271
  }
1242
1272
 
1243
- void
1244
- View_call_key_event (View* view, const KeyEvent& event)
1273
+ static void
1274
+ call_pointer_events_for_each_child (View* parent, PointerEvent* event)
1245
1275
  {
1246
- if (!view)
1247
- argument_error(__FILE__, __LINE__);
1276
+ assert(parent && event);
1248
1277
 
1249
- KeyEvent e = event;
1250
- view->on_key(&e);
1278
+ call_children(parent, [&](View* child) {
1279
+ PointerEvent e = event->dup();
1280
+ PointerEvent_update_for_child_view(&e, child);
1281
+ View_call_pointer_event(child, &e);
1282
+ return !e.is_blocked();
1283
+ });
1284
+ }
1285
+
1286
+ static void
1287
+ call_pointer_events (View* view, PointerEvent* event)
1288
+ {
1289
+ assert(view && event);
1290
+
1291
+ view->on_pointer(event);
1251
1292
 
1252
- switch (e.type)
1293
+ switch ((*event)[0].action())
1253
1294
  {
1254
- case KeyEvent::DOWN: view->on_key_down(&e); break;
1255
- case KeyEvent::UP: view->on_key_up(&e); break;
1256
- case KeyEvent::NONE: break;
1295
+ case Pointer::DOWN: view->on_pointer_down(event); break;
1296
+ case Pointer::UP: view->on_pointer_up(event); break;
1297
+ case Pointer::MOVE: view->on_pointer_move(event); break;
1298
+ case Pointer::CANCEL: view->on_pointer_cancel(event); break;
1299
+ default: break;
1257
1300
  }
1258
1301
  }
1259
1302
 
1260
1303
  static void
1261
- update_captures (View* view, PointerEvent* event)
1304
+ register_captures (View* view, const PointerEvent& event)
1262
1305
  {
1306
+ assert(view);
1307
+
1263
1308
  Window* win = view->window();
1264
1309
  if (!win)
1265
1310
  invalid_state_error(__FILE__, __LINE__);
1266
1311
 
1267
- PointerEvent_each_pointer(event, [&](const auto& pointer)
1312
+ PointerEvent_each_pointer(&event, [&](const auto& pointer)
1268
1313
  {
1269
- auto action = pointer.action();
1270
- if (action == Pointer::DOWN)
1271
- {
1314
+ if (pointer.action() == Pointer::DOWN)
1272
1315
  Window_register_capture(win, view, pointer.id());
1273
- }
1274
- else if (action == Pointer::UP || action == Pointer::CANCEL)
1275
- {
1276
- Window_unregister_capture(win, view, pointer.id());
1277
- }
1278
1316
  });
1279
1317
  }
1280
1318
 
1281
1319
  static void
1282
- call_pointer_event_for_each_child (View* parent, const PointerEvent& event)
1320
+ unregister_captures (View* view, const PointerEvent& event)
1283
1321
  {
1284
- call_children(parent, event, [](View* child, const PointerEvent& e) {
1285
- PointerEvent e2 = e;
1286
- PointerEvent_update_for_child_view(&e2, child);
1287
- View_call_pointer_event(child, e2);
1322
+ assert(view);
1323
+
1324
+ Window* win = view->window();
1325
+ if (!win)
1326
+ invalid_state_error(__FILE__, __LINE__);
1327
+
1328
+ PointerEvent_each_pointer(&event, [&](const auto& pointer)
1329
+ {
1330
+ auto action = pointer.action();
1331
+ if (action == Pointer::UP || action == Pointer::CANCEL)
1332
+ Window_unregister_capture(win, view, pointer.id());
1288
1333
  });
1289
1334
  }
1290
1335
 
1291
1336
  void
1292
- View_call_pointer_event (View* view, const PointerEvent& event)
1337
+ View_call_pointer_event (View* view, PointerEvent* event)
1293
1338
  {
1294
- if (!view)
1339
+ if (!view || !event)
1295
1340
  argument_error(__FILE__, __LINE__);
1296
1341
 
1297
- if (event.empty())
1342
+ if (view->hidden() || event->empty())
1298
1343
  return;
1299
1344
 
1300
- PointerEvent e = event;
1301
- view->on_pointer(&e);
1345
+ PointerEvent e = event->dup();
1302
1346
 
1303
- switch (e[0].action())
1347
+ if (!e.is_captured())
1348
+ call_pointer_events_for_each_child(view, &e);
1349
+
1350
+ if (!e.is_blocked())
1304
1351
  {
1305
- case Pointer::DOWN: view->on_pointer_down(&e); break;
1306
- case Pointer::UP: view->on_pointer_up(&e); break;
1307
- case Pointer::MOVE: view->on_pointer_move(&e); break;
1308
- case Pointer::CANCEL: view->on_pointer_cancel(&e); break;
1309
- default: break;
1352
+ register_captures(view, e);
1353
+ call_pointer_events(view, &e);
1310
1354
  }
1311
1355
 
1312
- update_captures(view, &e);
1313
-
1314
- if (!e.is_captured())
1315
- call_pointer_event_for_each_child(view, e);
1356
+ unregister_captures(view, e);
1316
1357
  }
1317
1358
 
1318
1359
  void
1319
- View_call_wheel_event (View* view, const WheelEvent& event)
1360
+ View_call_wheel_event (View* view, WheelEvent* event)
1320
1361
  {
1321
- if (!view)
1362
+ if (!view || !event)
1322
1363
  argument_error(__FILE__, __LINE__);
1323
1364
 
1365
+ if (view->hidden()) return;
1366
+
1324
1367
  const Bounds& frame = view->frame();
1325
1368
 
1326
- if (!frame.is_include(event.x, event.y, event.z))
1369
+ if (!frame.is_include(event->position()))
1327
1370
  return;
1328
1371
 
1329
- WheelEvent e = event;
1330
- e.position() -= frame.position();
1372
+ WheelEvent e = event->dup();
1373
+ WheelEvent_set_position(&e, e.position() - frame.position());
1331
1374
 
1332
- view->on_wheel(&e);
1375
+ call_children(view, [&](View* child) {
1376
+ View_call_wheel_event(child, &e);
1377
+ return !e.is_blocked();
1378
+ });
1333
1379
 
1334
- call_children(view, e, View_call_wheel_event);
1380
+ if (e.is_blocked()) return;
1381
+
1382
+ view->on_wheel(&e);
1335
1383
  }
1336
1384
 
1337
1385
  void
1338
- View_call_contact_event (View* view, const ContactEvent& event)
1386
+ View_call_contact_event (View* view, ContactEvent* event)
1339
1387
  {
1340
- if (!view)
1388
+ if (!view || !event)
1341
1389
  argument_error(__FILE__, __LINE__);
1342
1390
 
1343
- ContactEvent e = event;
1391
+ ContactEvent e = event->dup();
1344
1392
  view->on_contact(&e);
1345
1393
 
1346
- switch (e.type)
1394
+ switch (e.action())
1347
1395
  {
1348
1396
  case ContactEvent::BEGIN: view->on_contact_begin(&e); break;
1349
1397
  case ContactEvent::END: view->on_contact_end(&e); break;
1350
- case ContactEvent::NONE: break;
1398
+ default: break;
1351
1399
  }
1352
1400
  }
1353
1401
 
data/src/view.h CHANGED
@@ -30,20 +30,19 @@ namespace Reflex
30
30
  void View_update_tree (View* view, const UpdateEvent& event);
31
31
 
32
32
  void View_draw_tree (
33
- View* view, const DrawEvent& event,
34
- const Point& offset, const Bounds& clip);
33
+ View* view, DrawEvent* event, const Point& offset, const Bounds& clip);
35
34
 
36
35
  void View_update_styles (View* view, const Selector& selector);
37
36
 
38
37
  void View_update_shapes (View* view);
39
38
 
40
- void View_call_key_event (View* view, const KeyEvent& event);
39
+ void View_call_key_event (View* view, KeyEvent* event);
41
40
 
42
- void View_call_pointer_event (View* view, const PointerEvent& event);
41
+ void View_call_pointer_event (View* view, PointerEvent* event);
43
42
 
44
- void View_call_wheel_event (View* view, const WheelEvent& event);
43
+ void View_call_wheel_event (View* view, WheelEvent* event);
45
44
 
46
- void View_call_contact_event (View* view, const ContactEvent& event);
45
+ void View_call_contact_event (View* view, ContactEvent* event);
47
46
 
48
47
 
49
48
  }// Reflex