efl

1
#ifdef HAVE_CONFIG_H
2
# include "elementary_config.h"
3
#endif
4

5
#include <Elementary.h>
6
#include "efl_ui_suite.h"
7

8
static void
9
_boolean_flag_set(void *data, const Efl_Event *ev EINA_UNUSED)
10
{
11
   Eina_Bool *flag = data;
12
   *flag = EINA_TRUE;
13

14
   efl_loop_quit(efl_main_loop_get(), EINA_VALUE_EMPTY);
15
}
16

17
EFL_START_TEST(efl_ui_win_test_scene_focus)
18
{
19
   Efl_Ui_Win *win1;
20
   Ecore_Evas *ee;
21

22
   Eina_Bool win1_focus_in = EINA_FALSE;
23
   Eina_Bool win1_focus_out = EINA_FALSE;
24

25
   win1 = efl_new(EFL_UI_WIN_CLASS);
26

27
   //we want to test here the correct propagation of events from ecore_evas to the win object
28
   //in order to ensure that we are resetting ee focus first here.
29
   ee = ecore_evas_ecore_evas_get(evas_object_evas_get(win1));
30
   ecore_evas_focus_set(ee, EINA_TRUE);
31
   ecore_evas_focus_set(ee, EINA_FALSE);
32
   efl_event_callback_add(win1, EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_IN, _boolean_flag_set, &win1_focus_in);
33
   efl_event_callback_add(win1, EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_OUT, _boolean_flag_set, &win1_focus_out);
34

35
   //focus in check
36
   ecore_evas_focus_set(ee, EINA_TRUE);
37
   if (!win1_focus_in)
38
     efl_loop_begin(efl_main_loop_get());
39
   ck_assert_int_eq(win1_focus_in, EINA_TRUE);
40
   ck_assert_int_eq(win1_focus_out, EINA_FALSE);
41
   win1_focus_in = EINA_FALSE;
42

43
   //focus out check
44
   ecore_evas_focus_set(ee, EINA_FALSE);
45
   if (!win1_focus_out)
46
     efl_loop_begin(efl_main_loop_get());
47

48
   ck_assert_int_eq(win1_focus_out, EINA_TRUE);
49
   ck_assert_int_eq(win1_focus_in, EINA_FALSE);
50

51
   efl_unref(win1);
52
}
53
EFL_END_TEST
54

55
static void
56
_check_focus_event(void *data, const Efl_Event *ev)
57
{
58
   void **tmp = data;
59

60
   *tmp = efl_input_focus_object_get(ev->info);
61
}
62

63
EFL_START_TEST(efl_ui_win_test_object_focus)
64
{
65
   Efl_Ui_Win *win1;
66

67
   void *win1_focus_in = NULL;
68
   void *win1_focus_out = NULL;
69

70
   win1 = efl_new(EFL_UI_WIN_CLASS);
71

72
   efl_event_callback_add(win1, EFL_CANVAS_SCENE_EVENT_OBJECT_FOCUS_IN, _check_focus_event, &win1_focus_in);
73
   efl_event_callback_add(win1, EFL_CANVAS_SCENE_EVENT_OBJECT_FOCUS_OUT, _check_focus_event, &win1_focus_out);
74

75
   Eo *r1 = efl_add(EFL_CANVAS_RECTANGLE_CLASS, evas_object_evas_get(win1));
76
   efl_canvas_object_seat_focus_add(r1, NULL);
77
   ck_assert_ptr_eq(win1_focus_in, r1);
78
   ck_assert_ptr_eq(win1_focus_out, NULL);
79
   win1_focus_in = NULL;
80
   win1_focus_out = NULL;
81

82
   Eo *r2 = efl_add(EFL_CANVAS_RECTANGLE_CLASS, evas_object_evas_get(win1));
83
   efl_canvas_object_seat_focus_add(r2, NULL);
84
   ck_assert_ptr_eq(win1_focus_in, r2);
85
   ck_assert_ptr_eq(win1_focus_out, r1);
86
   win1_focus_in = NULL;
87
   win1_focus_out = NULL;
88

89
   efl_canvas_object_seat_focus_del(r2, NULL);
90
   ck_assert_ptr_eq(win1_focus_in, NULL);
91
   ck_assert_ptr_eq(win1_focus_out, r2);
92

93
   efl_unref(win1);
94
}
95
EFL_END_TEST
96

97

98
static void
99
create_environment(Eo **win, Eo **rect)
100
{
101
   *win = efl_new(EFL_UI_WIN_CLASS);
102
   *rect = efl_add(EFL_CANVAS_RECTANGLE_CLASS, evas_object_evas_get(*win));
103
   efl_canvas_object_seat_focus_add(*rect, NULL);
104
   efl_gfx_entity_geometry_set(*win, EINA_RECT(0, 0, 200, 200));
105
   efl_gfx_entity_geometry_set(*rect, EINA_RECT(0, 0, 200, 200));
106
   get_me_to_those_events(evas_object_evas_get(*win));
107
}
108

109
EFL_START_TEST(efl_ui_win_test_efl_input_interface_focus)
110
{
111
   Efl_Ui_Win *win;
112
   Efl_Canvas_Object *rect, *focus_in = NULL, *focus_out = NULL;
113
   create_environment(&win, &rect);
114
   efl_canvas_object_seat_focus_del(rect, NULL);
115

116
   efl_event_callback_add(rect, EFL_EVENT_FOCUS_IN , _check_focus_event, &focus_in);
117
   efl_event_callback_add(rect, EFL_EVENT_FOCUS_OUT, _check_focus_event, &focus_out);
118

119
   efl_canvas_object_seat_focus_add(rect, NULL);
120
   ck_assert_ptr_eq(focus_out, NULL);
121
   ck_assert_ptr_eq(focus_in, rect);
122
   focus_out = NULL;
123
   focus_in = NULL;
124

125
   efl_canvas_object_seat_focus_del(rect, NULL);
126
   ck_assert_ptr_eq(focus_out, rect);
127
   ck_assert_ptr_eq(focus_in, NULL);
128
   focus_out = NULL;
129
   focus_in = NULL;
130
}
131
EFL_END_TEST
132

133
#define TIMESTAMP 1337
134

135
static void
136
_check_key_event(void *data, const Efl_Event *ev)
137
{
138
   Eina_Bool *pressed = data;
139

140
   ck_assert_int_eq(efl_input_timestamp_get(ev->info), TIMESTAMP);
141
   ck_assert_str_eq(efl_input_key_name_get(ev->info), "odiaeresis");
142
   ck_assert_str_eq(efl_input_key_sym_get(ev->info), "ö");
143
   ck_assert_str_eq(efl_input_key_string_get(ev->info), "Ö");
144
   ck_assert_str_eq(efl_input_key_compose_string_get(ev->info), "Ö");
145
   ck_assert_int_eq(efl_input_key_code_get(ev->info), 0xffe1);
146
   *pressed = efl_input_key_pressed_get(ev->info);
147
}
148

149
EFL_START_TEST(efl_ui_win_test_efl_input_interface_key_down)
150
{
151
   Efl_Ui_Win *win;
152
   Eina_Bool pressed = EINA_FALSE;
153
   Efl_Canvas_Object *rect;
154
   create_environment(&win, &rect);
155

156
   efl_event_callback_add(rect, EFL_EVENT_KEY_DOWN , _check_key_event, &pressed);
157
   efl_event_callback_add(rect, EFL_EVENT_KEY_UP, _check_key_event, &pressed);
158

159
   evas_event_feed_key_down_with_keycode(evas_object_evas_get(win), "odiaeresis", "ö", "Ö", "Ö", TIMESTAMP, NULL, 0xffe1);
160
   ck_assert_int_eq(pressed, EINA_TRUE);
161

162
   evas_event_feed_key_up_with_keycode(evas_object_evas_get(win), "odiaeresis", "ö", "Ö", "Ö", TIMESTAMP, NULL, 0xffe1);
163
   ck_assert_int_eq(pressed, EINA_FALSE);
164
}
165
EFL_END_TEST
166

167
static void
168
position_eq(Eina_Position2D a, Eina_Position2D b)
169
{
170
   ck_assert_int_eq(a.x, b.x);
171
   ck_assert_int_eq(a.y, b.y);
172
}
173

174
static void
175
_check_ptr_move_event(void *data, const Efl_Event *ev)
176
{
177
   Eina_Bool *called = data;
178
   ck_assert_int_eq(efl_input_timestamp_get(ev->info), TIMESTAMP);
179
   ck_assert_int_eq(efl_input_pointer_wheel_delta_get(ev->info), 0);
180
   ck_assert_int_eq(efl_input_pointer_wheel_horizontal_get(ev->info), 0);
181
   ck_assert_int_eq(efl_input_pointer_double_click_get(ev->info), 0);
182
   ck_assert_int_eq(efl_input_pointer_triple_click_get(ev->info), 0);
183
   ck_assert_int_eq(efl_input_pointer_button_flags_get(ev->info), 0);
184
   ck_assert_int_eq(efl_input_pointer_touch_id_get(ev->info), 0);
185
   position_eq(efl_input_pointer_previous_position_get(ev->info), EINA_POSITION2D(20, 20));
186
   position_eq(efl_input_pointer_position_get(ev->info), EINA_POSITION2D(25, 25));
187
   ck_assert_int_eq(efl_input_pointer_button_get(ev->info), 0);
188
   ck_assert_int_eq(efl_input_pointer_action_get(ev->info), EFL_POINTER_ACTION_MOVE);
189
   *called = EINA_TRUE;
190
}
191

192
EFL_START_TEST(efl_ui_win_test_efl_input_interface_pointer_move)
193
{
194
   Efl_Ui_Win *win;
195
   Eina_Bool called = EINA_FALSE;
196
   Efl_Canvas_Object *rect;
197
   create_environment(&win, &rect);
198

199
   evas_event_feed_mouse_move(evas_object_evas_get(win), 20, 20, TIMESTAMP - 1, NULL);
200
   efl_event_callback_add(rect, EFL_EVENT_POINTER_MOVE , _check_ptr_move_event, &called);
201
   evas_event_feed_mouse_move(evas_object_evas_get(win), 25, 25, TIMESTAMP, NULL);
202
   ck_assert_int_eq(called, EINA_TRUE);
203
}
204
EFL_END_TEST
205

206
static void
207
_check_ptr_down_event(void *data, const Efl_Event *ev)
208
{
209
   Eina_Bool *called = data;
210
   ck_assert_int_eq(efl_input_timestamp_get(ev->info), TIMESTAMP);
211
   ck_assert_int_eq(efl_input_pointer_wheel_delta_get(ev->info), 0);
212
   ck_assert_int_eq(efl_input_pointer_wheel_horizontal_get(ev->info), 0);
213
   ck_assert_int_eq(efl_input_pointer_double_click_get(ev->info), 0);
214
   ck_assert_int_eq(efl_input_pointer_triple_click_get(ev->info), EINA_TRUE);
215
   ck_assert_int_eq(efl_input_pointer_button_flags_get(ev->info), EVAS_BUTTON_TRIPLE_CLICK);
216
   ck_assert_int_eq(efl_input_pointer_touch_id_get(ev->info), 0);
217
   position_eq(efl_input_pointer_position_get(ev->info), EINA_POSITION2D(20, 20));
218
   ck_assert_int_eq(efl_input_pointer_button_get(ev->info), 1);
219
   ck_assert_int_eq(efl_input_pointer_action_get(ev->info), EFL_POINTER_ACTION_DOWN);
220
   *called = EINA_TRUE;
221
}
222

223
EFL_START_TEST(efl_ui_win_test_efl_input_interface_pointer_down)
224
{
225
   Efl_Ui_Win *win;
226
   Eina_Bool called = EINA_FALSE;
227
   Efl_Canvas_Object *rect;
228
   create_environment(&win, &rect);
229

230
   evas_event_feed_mouse_move(evas_object_evas_get(win), 20, 20, TIMESTAMP - 1, NULL);
231
   efl_event_callback_add(rect, EFL_EVENT_POINTER_DOWN , _check_ptr_down_event, &called);
232
   evas_event_feed_mouse_down(evas_object_evas_get(win), 1, EVAS_BUTTON_TRIPLE_CLICK, TIMESTAMP, NULL);
233
   ck_assert_int_eq(called, EINA_TRUE);
234
}
235
EFL_END_TEST
236

237
static void
238
_check_ptr_up_event(void *data, const Efl_Event *ev)
239
{
240
   Eina_Bool *called = data;
241
   ck_assert_int_eq(efl_input_timestamp_get(ev->info), TIMESTAMP);
242
   ck_assert_int_eq(efl_input_pointer_wheel_delta_get(ev->info), 0);
243
   ck_assert_int_eq(efl_input_pointer_wheel_horizontal_get(ev->info), 0);
244
   ck_assert_int_eq(efl_input_pointer_double_click_get(ev->info), 0);
245
   ck_assert_int_eq(efl_input_pointer_triple_click_get(ev->info), EINA_TRUE);
246
   ck_assert_int_eq(efl_input_pointer_button_flags_get(ev->info), EVAS_BUTTON_TRIPLE_CLICK);
247
   ck_assert_int_eq(efl_input_pointer_touch_id_get(ev->info), 0);
248
   position_eq(efl_input_pointer_position_get(ev->info), EINA_POSITION2D(20, 20));
249
   ck_assert_int_eq(efl_input_pointer_button_get(ev->info), 1);
250
   ck_assert_int_eq(efl_input_pointer_action_get(ev->info), EFL_POINTER_ACTION_UP);
251
   *called = EINA_TRUE;
252
}
253

254
EFL_START_TEST(efl_ui_win_test_efl_input_interface_pointer_up)
255
{
256
   Efl_Ui_Win *win;
257
   Eina_Bool called = EINA_FALSE;
258
   Efl_Canvas_Object *rect;
259
   create_environment(&win, &rect);
260

261
   evas_event_feed_mouse_move(evas_object_evas_get(win), 20, 20, TIMESTAMP - 1, NULL);
262
   evas_event_feed_mouse_down(evas_object_evas_get(win), 1, EVAS_BUTTON_TRIPLE_CLICK, TIMESTAMP, NULL);
263
   efl_event_callback_add(rect, EFL_EVENT_POINTER_UP , _check_ptr_up_event, &called);
264
   evas_event_feed_mouse_up(evas_object_evas_get(win), 1, EVAS_BUTTON_TRIPLE_CLICK, TIMESTAMP, NULL);
265
   ck_assert_int_eq(called, EINA_TRUE);
266
}
267
EFL_END_TEST
268

269
static void
270
_check_pointer_in_cb(void *data, const Efl_Event *ev)
271
{
272
   Eina_Bool *called = data;
273
   ck_assert_int_eq(efl_input_timestamp_get(ev->info), TIMESTAMP);
274
   ck_assert_int_eq(efl_input_pointer_wheel_delta_get(ev->info), 0);
275
   ck_assert_int_eq(efl_input_pointer_wheel_horizontal_get(ev->info), 0);
276
   ck_assert_int_eq(efl_input_pointer_double_click_get(ev->info), 0);
277
   ck_assert_int_eq(efl_input_pointer_triple_click_get(ev->info), 0);
278
   ck_assert_int_eq(efl_input_pointer_button_flags_get(ev->info), 0);
279
   ck_assert_int_eq(efl_input_pointer_touch_id_get(ev->info), 0);
280
   position_eq(efl_input_pointer_position_get(ev->info), EINA_POSITION2D(20, 20));
281
   ck_assert_int_eq(efl_input_pointer_button_get(ev->info), 0);
282
   ck_assert_int_eq(efl_input_pointer_action_get(ev->info), EFL_POINTER_ACTION_IN );
283
   *called = EINA_TRUE;
284
}
285

286
static void
287
_check_pointer_out_cb(void *data, const Efl_Event *ev)
288
{
289
   Eina_Bool *called = data;
290
   ck_assert_int_eq(efl_input_timestamp_get(ev->info), TIMESTAMP);
291
   ck_assert_int_eq(efl_input_pointer_wheel_delta_get(ev->info), 0);
292
   ck_assert_int_eq(efl_input_pointer_wheel_horizontal_get(ev->info), 0);
293
   ck_assert_int_eq(efl_input_pointer_double_click_get(ev->info), 0);
294
   ck_assert_int_eq(efl_input_pointer_triple_click_get(ev->info), 0);
295
   ck_assert_int_eq(efl_input_pointer_button_flags_get(ev->info), 0);
296
   ck_assert_int_eq(efl_input_pointer_touch_id_get(ev->info), 0);
297
   position_eq(efl_input_pointer_position_get(ev->info), EINA_POSITION2D(5, 5));
298
   ck_assert_int_eq(efl_input_pointer_button_get(ev->info), 0);
299
   ck_assert_int_eq(efl_input_pointer_action_get(ev->info), EFL_POINTER_ACTION_OUT );
300
   *called = EINA_TRUE;
301
}
302

303
EFL_START_TEST(efl_ui_win_test_efl_input_interface_pointer_in_out)
304
{
305
   Efl_Ui_Win *win;
306
   Eina_Bool pointer_in = EINA_FALSE, pointer_out = EINA_FALSE;
307
   Efl_Canvas_Object *rect;
308

309
   create_environment(&win, &rect);
310
   evas_event_feed_mouse_move(evas_object_evas_get(win), 5, 5, TIMESTAMP - 1, NULL);
311
   evas_object_geometry_set(rect, 10, 10, 20, 20);
312

313
   evas_event_feed_mouse_move(evas_object_evas_get(win), 5, 5, TIMESTAMP - 1, NULL);
314
   efl_event_callback_add(rect, EFL_EVENT_POINTER_IN, _check_pointer_in_cb, &pointer_in);
315
   efl_event_callback_add(rect, EFL_EVENT_POINTER_OUT, _check_pointer_out_cb, &pointer_out);
316

317
   evas_event_feed_mouse_move(evas_object_evas_get(win), 20, 20, TIMESTAMP, NULL);
318
   ck_assert_int_eq(pointer_in, EINA_TRUE);
319
   ck_assert_int_eq(pointer_out, EINA_FALSE);
320
   pointer_in = EINA_FALSE;
321
   pointer_out = EINA_FALSE;
322

323
   evas_event_feed_mouse_move(evas_object_evas_get(win), 5, 5, TIMESTAMP, NULL);
324
   ck_assert_int_eq(pointer_in, EINA_FALSE);
325
   ck_assert_int_eq(pointer_out, EINA_TRUE);
326
}
327
EFL_END_TEST
328

329
static void
330
_check_pointer_wheel_cb(void *data, const Efl_Event *ev)
331
{
332
   Eina_Bool *called = data;
333
   ck_assert_int_eq(efl_input_timestamp_get(ev->info), TIMESTAMP);
334
   ck_assert_int_eq(efl_input_pointer_wheel_delta_get(ev->info), 2);
335
   ck_assert_int_eq(efl_input_pointer_wheel_horizontal_get(ev->info), 1);
336
   ck_assert_int_eq(efl_input_pointer_double_click_get(ev->info), 0);
337
   ck_assert_int_eq(efl_input_pointer_triple_click_get(ev->info), 0);
338
   ck_assert_int_eq(efl_input_pointer_button_flags_get(ev->info), 0);
339
   ck_assert_int_eq(efl_input_pointer_touch_id_get(ev->info), 0);
340
   position_eq(efl_input_pointer_position_get(ev->info), EINA_POSITION2D(20, 20));
341
   ck_assert_int_eq(efl_input_pointer_button_get(ev->info), 0);
342
   ck_assert_int_eq(efl_input_pointer_action_get(ev->info), EFL_POINTER_ACTION_WHEEL );
343
   *called = EINA_TRUE;
344
}
345

346
EFL_START_TEST(efl_ui_win_test_efl_input_interface_pointer_wheel)
347
{
348
   Efl_Ui_Win *win;
349
   Eina_Bool pointer_wheel = EINA_FALSE;
350
   Efl_Canvas_Object *rect;
351

352
   create_environment(&win, &rect);
353

354
   efl_event_callback_add(rect, EFL_EVENT_POINTER_WHEEL, _check_pointer_wheel_cb, &pointer_wheel);
355

356
   evas_event_feed_mouse_move(evas_object_evas_get(win), 20, 20, TIMESTAMP, NULL);
357
   evas_event_feed_mouse_wheel(evas_object_evas_get(win), 1, 2, TIMESTAMP, NULL);
358
   ck_assert_int_eq(pointer_wheel, EINA_TRUE);
359
}
360
EFL_END_TEST
361

362

363
static void
364
_check_ptr_cancel_down_event(void *data, const Efl_Event *ev)
365
{
366
   Eina_Bool *called = data;
367
   ck_assert_int_eq(efl_input_timestamp_get(ev->info), TIMESTAMP);
368
   ck_assert_int_eq(efl_input_pointer_wheel_delta_get(ev->info), 0);
369
   ck_assert_int_eq(efl_input_pointer_wheel_horizontal_get(ev->info), 0);
370
   ck_assert_int_eq(efl_input_pointer_double_click_get(ev->info), 0);
371
   ck_assert_int_eq(efl_input_pointer_triple_click_get(ev->info), 0);
372
   ck_assert_int_eq(efl_input_pointer_button_flags_get(ev->info), 0);
373
   ck_assert_int_eq(efl_input_pointer_touch_id_get(ev->info), 0);
374
   position_eq(efl_input_pointer_position_get(ev->info), EINA_POSITION2D(20, 20));
375
   ck_assert_int_eq(efl_input_pointer_button_get(ev->info), 1);
376
   ck_assert_int_eq(efl_input_pointer_action_get(ev->info), EFL_POINTER_ACTION_DOWN);
377
   *called = EINA_TRUE;
378
}
379

380
static void
381
_check_ptr_cancel_event(void *data, const Efl_Event *ev)
382
{
383
   int *called = data;
384
   ck_assert_int_eq(efl_input_timestamp_get(ev->info), TIMESTAMP);
385
   ck_assert_int_eq(efl_input_pointer_wheel_delta_get(ev->info), 0);
386
   ck_assert_int_eq(efl_input_pointer_wheel_horizontal_get(ev->info), 0);
387
   ck_assert_int_eq(efl_input_pointer_double_click_get(ev->info), 0);
388
   ck_assert_int_eq(efl_input_pointer_triple_click_get(ev->info), 0);
389
   ck_assert_int_eq(efl_input_pointer_button_flags_get(ev->info), 0);
390
   ck_assert_int_eq(efl_input_pointer_touch_id_get(ev->info), 0);
391
   position_eq(efl_input_pointer_position_get(ev->info), EINA_POSITION2D(20, 20));
392
   ck_assert_int_eq(efl_input_pointer_button_get(ev->info), 1);
393
   ck_assert_int_eq(efl_input_pointer_action_get(ev->info), EFL_POINTER_ACTION_CANCEL );
394
   ck_assert_int_eq(*called, 0);
395
   *called = 1;
396
}
397

398
static void
399
_check_ptr_cancel_up_event(void *data, const Efl_Event *ev)
400
{
401
   Eina_Bool *called = data;
402
   ck_assert_int_eq(efl_input_timestamp_get(ev->info), TIMESTAMP);
403
   ck_assert_int_eq(efl_input_pointer_wheel_delta_get(ev->info), 0);
404
   ck_assert_int_eq(efl_input_pointer_wheel_horizontal_get(ev->info), 0);
405
   ck_assert_int_eq(efl_input_pointer_double_click_get(ev->info), 0);
406
   ck_assert_int_eq(efl_input_pointer_triple_click_get(ev->info), 0);
407
   ck_assert_int_eq(efl_input_pointer_button_flags_get(ev->info), 0);
408
   ck_assert_int_eq(efl_input_pointer_touch_id_get(ev->info), 0);
409
   position_eq(efl_input_pointer_position_get(ev->info), EINA_POSITION2D(20, 20));
410
   ck_assert_int_eq(efl_input_pointer_button_get(ev->info), 1);
411
   ck_assert_int_eq(efl_input_pointer_action_get(ev->info), EFL_POINTER_ACTION_UP);
412
   ck_assert_int_eq(*called, 1);
413
   *called = 2;
414
}
415

416
EFL_START_TEST(efl_ui_win_test_efl_input_interface_pointer_cancel)
417
{
418
   Efl_Ui_Win *win;
419
   Eina_Bool called_down = EINA_FALSE;
420
   int called;
421
   Efl_Canvas_Object *rect;
422
   create_environment(&win, &rect);
423

424
   evas_event_feed_mouse_move(evas_object_evas_get(win), 20, 20, TIMESTAMP - 1, NULL);
425
   efl_event_callback_add(rect, EFL_EVENT_POINTER_DOWN, _check_ptr_cancel_down_event, &called_down);
426
   evas_event_feed_mouse_down(evas_object_evas_get(win), 1, 0, TIMESTAMP, NULL);
427
   ck_assert_int_eq(called_down, EINA_TRUE);
428
   called = EINA_FALSE;
429

430
   efl_event_callback_add(rect, EFL_EVENT_POINTER_CANCEL, _check_ptr_cancel_event, &called);
431
   efl_event_callback_add(rect, EFL_EVENT_POINTER_UP, _check_ptr_cancel_up_event, &called);
432
   evas_event_feed_mouse_cancel(evas_object_evas_get(win), TIMESTAMP, NULL);
433
   ck_assert_int_eq(called, 2);
434
}
435
EFL_END_TEST
436

437
EFL_START_TEST(efl_ui_win_test_type)
438
{
439
   Efl_Ui_Win *win;
440

441
   win = win_add();
442

443
   ck_assert_int_eq(efl_ui_win_type_get(win), EFL_UI_WIN_TYPE_BASIC);
444
}
445
EFL_END_TEST
446

447
void
448
efl_ui_test_win(TCase *tc)
449
{
450
   tcase_add_test(tc, efl_ui_win_test_scene_focus);
451
   tcase_add_test(tc, efl_ui_win_test_object_focus);
452
   tcase_add_test(tc, efl_ui_win_test_object_focus);
453
   tcase_add_test(tc, efl_ui_win_test_efl_input_interface_focus);
454
   tcase_add_test(tc, efl_ui_win_test_efl_input_interface_key_down);
455
   tcase_add_test(tc, efl_ui_win_test_efl_input_interface_pointer_move);
456
   tcase_add_test(tc, efl_ui_win_test_efl_input_interface_pointer_down);
457
   tcase_add_test(tc, efl_ui_win_test_efl_input_interface_pointer_up);
458
   tcase_add_test(tc, efl_ui_win_test_efl_input_interface_pointer_in_out);
459
   tcase_add_test(tc, efl_ui_win_test_efl_input_interface_pointer_wheel);
460
   tcase_add_test(tc, efl_ui_win_test_efl_input_interface_pointer_cancel);
461
   tcase_add_test(tc, efl_ui_win_test_type);
462
}
463