efl

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

5
#include <Elementary.h>
6
#include "elm_entry_eo.h" //needed to check that spin is in text mode
7
#include <Efl_Ui.h>
8
#include "efl_ui_suite.h"
9

10
static Eo *win, *spin;
11

12
static void
13
spin_setup()
14
{
15
   win = win_add();
16

17
   spin = efl_add(EFL_UI_SPIN_BUTTON_CLASS, win);
18
   efl_content_set(win, spin);
19
   efl_gfx_entity_geometry_set(win, EINA_RECT(0, 0, 200, 50));
20
}
21

22
static void
23
_set_flag(void *data, const Efl_Event *ev)
24
{
25
   Eina_Bool *b = data;
26

27
   ck_assert_int_eq(*b, EINA_FALSE);
28
   *b = EINA_TRUE;
29
   ck_assert_ptr_eq(ev->info, NULL);
30
}
31

32
static void
33
_set_flag_quit(void *data, const Efl_Event *ev)
34
{
35
   Eina_Bool *b = data;
36

37
   ck_assert_int_eq(*b, EINA_FALSE);
38
   *b = EINA_TRUE;
39
   ck_assert_ptr_eq(ev->info, NULL);
40

41
   efl_loop_quit(efl_main_loop_get(), EINA_VALUE_EMPTY);
42
}
43

44
static void
45
click_spin_part(Eo *obj, const char *part)
46
{
47
   get_me_to_those_events(spin);
48
   click_part(obj, part);
49
}
50

51
EFL_START_TEST (spin_wheel_test)
52
{
53
   Eina_Bool changed = EINA_FALSE, min_reached = EINA_FALSE, max_reached = EINA_FALSE;
54

55
   efl_ui_range_limits_set(spin, -100.0, 100.0);
56
   efl_ui_range_value_set(spin, 0.0);
57
   efl_ui_range_step_set(spin, 10.0);
58
   efl_event_callback_add(spin, EFL_UI_RANGE_EVENT_CHANGED, _set_flag, &changed);
59
   efl_event_callback_add(spin, EFL_UI_RANGE_EVENT_MIN_REACHED, _set_flag, &min_reached);
60
   efl_event_callback_add(spin, EFL_UI_RANGE_EVENT_MAX_REACHED, _set_flag, &max_reached);
61

62
   efl_gfx_entity_size_set(win, EINA_SIZE2D(60, 60));
63
   get_me_to_those_events(spin);
64
   evas_event_feed_mouse_move(evas_object_evas_get(spin), 30, 30, 1234, NULL);
65
   evas_event_feed_mouse_wheel(evas_object_evas_get(spin), -1, -1, 12345, NULL);
66
   ck_assert(EINA_DBL_EQ(efl_ui_range_value_get(spin), 10.0));
67
   ck_assert_int_eq(changed, EINA_TRUE);
68
   ck_assert_int_eq(min_reached, EINA_FALSE);
69
   ck_assert_int_eq(max_reached, EINA_FALSE);
70
   changed = EINA_FALSE;
71
   min_reached = EINA_FALSE;
72
   max_reached = EINA_FALSE;
73

74
   evas_event_feed_mouse_wheel(evas_object_evas_get(spin), -1, 1, 12345, NULL);
75
   ck_assert(EINA_DBL_EQ(efl_ui_range_value_get(spin), 0.0));
76
   ck_assert_int_eq(changed, EINA_TRUE);
77
   ck_assert_int_eq(min_reached, EINA_FALSE);
78
   ck_assert_int_eq(max_reached, EINA_FALSE);
79
   changed = EINA_FALSE;
80
   min_reached = EINA_FALSE;
81
   max_reached = EINA_FALSE;
82
}
83
EFL_END_TEST
84

85
EFL_START_TEST (spin_value_inc)
86
{
87
   Eina_Bool changed = EINA_FALSE, min_reached = EINA_FALSE, max_reached = EINA_FALSE, delay_changed = EINA_FALSE;
88

89
   efl_ui_range_limits_set(spin, 0.0, 3.0);
90
   efl_ui_range_value_set(spin, 1.0);
91
   efl_event_callback_add(spin, EFL_UI_RANGE_EVENT_CHANGED, _set_flag, &changed);
92
   efl_event_callback_add(spin, EFL_UI_RANGE_EVENT_MIN_REACHED, _set_flag, &min_reached);
93
   efl_event_callback_add(spin, EFL_UI_RANGE_EVENT_MAX_REACHED, _set_flag, &max_reached);
94
   efl_event_callback_add(spin, EFL_UI_RANGE_EVENT_STEADY, _set_flag_quit, &delay_changed);
95

96
   click_spin_part(spin, "efl.inc_button");
97

98
   ck_assert_int_eq(changed, EINA_TRUE);
99
   ck_assert_int_eq(min_reached, EINA_FALSE);
100
   ck_assert_int_eq(max_reached, EINA_FALSE);
101
   changed = EINA_FALSE;
102
   min_reached = EINA_FALSE;
103
   max_reached = EINA_FALSE;
104

105
   efl_loop_begin(efl_main_loop_get());
106
   ck_assert_int_eq(delay_changed, EINA_TRUE);
107
}
108
EFL_END_TEST
109

110
EFL_START_TEST (spin_value_inc_max)
111
{
112
   Eina_Bool changed = EINA_FALSE, min_reached = EINA_FALSE, max_reached = EINA_FALSE, delay_changed = EINA_FALSE;
113

114
   efl_ui_range_limits_set(spin, 0.0, 3.0);
115
   efl_ui_range_value_set(spin, 2.0);
116
   efl_event_callback_add(spin, EFL_UI_RANGE_EVENT_CHANGED, _set_flag, &changed);
117
   efl_event_callback_add(spin, EFL_UI_RANGE_EVENT_MIN_REACHED, _set_flag, &min_reached);
118
   efl_event_callback_add(spin, EFL_UI_RANGE_EVENT_MAX_REACHED, _set_flag, &max_reached);
119
   efl_event_callback_add(spin, EFL_UI_RANGE_EVENT_STEADY, _set_flag_quit, &delay_changed);
120

121
   click_spin_part(spin, "efl.inc_button");
122

123
   ck_assert_int_eq(changed, EINA_TRUE);
124
   ck_assert_int_eq(min_reached, EINA_FALSE);
125
   ck_assert_int_eq(max_reached, EINA_TRUE);
126
   changed = EINA_FALSE;
127
   min_reached = EINA_FALSE;
128
   max_reached = EINA_FALSE;
129

130
   efl_loop_begin(efl_main_loop_get());
131
   ck_assert_int_eq(delay_changed, EINA_TRUE);
132
}
133
EFL_END_TEST
134

135
EFL_START_TEST (spin_value_dec_min)
136
{
137
   Eina_Bool changed = EINA_FALSE, min_reached = EINA_FALSE, max_reached = EINA_FALSE, delay_changed = EINA_FALSE;
138

139
   efl_ui_range_limits_set(spin, 0.0, 3.0);
140
   efl_ui_range_value_set(spin, 1.0);
141
   efl_event_callback_add(spin, EFL_UI_RANGE_EVENT_CHANGED, _set_flag, &changed);
142
   efl_event_callback_add(spin, EFL_UI_RANGE_EVENT_MIN_REACHED, _set_flag, &min_reached);
143
   efl_event_callback_add(spin, EFL_UI_RANGE_EVENT_MAX_REACHED, _set_flag, &max_reached);
144
   efl_event_callback_add(spin, EFL_UI_RANGE_EVENT_STEADY, _set_flag_quit, &delay_changed);
145

146
   click_spin_part(spin, "efl.dec_button");
147

148
   ck_assert_int_eq(changed, EINA_TRUE);
149
   ck_assert_int_eq(min_reached, EINA_TRUE);
150
   ck_assert_int_eq(max_reached, EINA_FALSE);
151
   changed = EINA_FALSE;
152
   min_reached = EINA_FALSE;
153
   max_reached = EINA_FALSE;
154

155
   efl_loop_begin(efl_main_loop_get());
156
   ck_assert_int_eq(delay_changed, EINA_TRUE);
157
}
158
EFL_END_TEST
159

160
EFL_START_TEST (spin_wraparound)
161
{
162
   efl_ui_spin_button_wraparound_set(spin, EINA_TRUE);
163
   efl_ui_range_limits_set(spin, 10, 30);
164
   efl_ui_range_step_set(spin, 20);
165

166
   efl_ui_range_value_set(spin, 20);
167
   click_spin_part(spin, "efl.inc_button");
168
   ck_assert_int_eq(efl_ui_range_value_get(spin), 10);
169

170
   efl_ui_range_value_set(spin, 20);
171
   click_spin_part(spin, "efl.dec_button");
172
   ck_assert_int_eq(efl_ui_range_value_get(spin), 30);
173

174
}
175
EFL_END_TEST
176

177
EFL_START_TEST (spin_double_values)
178
{
179
   double step = 0.1;
180
   efl_ui_range_limits_set(spin, 10, 30);
181
   efl_ui_range_value_set(spin, 20);
182
   efl_ui_range_step_set(spin, step);
183
   ck_assert(EINA_DBL_EQ(efl_ui_range_step_get(spin), step));
184
   get_me_to_those_events(spin);
185
   ck_assert(EINA_DBL_EQ(efl_ui_range_value_get(spin), 20.0));
186

187
   for (int i = 0; i < 5; ++i)
188
     {
189
        click_part(spin, "efl.inc_button");
190
        get_me_to_those_events(spin);
191
     }
192
   ck_assert_int_eq(EINA_DBL_EQ(efl_ui_range_value_get(spin), 20.5), 1);
193
}
194
EFL_END_TEST
195

196
EFL_START_TEST (spin_double_values_hitting_max_with_step)
197
{
198
   //idea is to check that spin button can hit max with inc, even if value is not multiple is 2.7
199
   efl_ui_range_limits_set(spin, 10, 30);
200
   efl_ui_range_value_set(spin, 27);
201
   efl_ui_range_step_set(spin, 2.7);
202
   get_me_to_those_events(spin);
203

204
   for (int i = 0; i < 2; ++i)
205
     {
206
        click_part(spin, "efl.inc_button");
207
        get_me_to_those_events(spin);
208
     }
209
   ck_assert_int_eq(EINA_DBL_EQ(efl_ui_range_value_get(spin), 30), 1);
210
}
211
EFL_END_TEST
212

213
static inline void
214
_try_direct_text_input(const char *text, double result)
215
{
216
   Eo *entry;
217

218
   efl_ui_focus_util_focus(efl_content_get(efl_part(spin, "efl.text_button")));
219
   get_me_to_those_events(spin);
220
   entry = efl_content_get(efl_part(spin, "efl.entry"));
221
   elm_object_text_set(entry, "");
222
   ck_assert_int_eq(efl_isa(entry, ELM_ENTRY_CLASS), 1);
223
   efl_ui_focus_util_focus(entry);
224
   get_me_to_those_events(spin);
225

226
   write_key_sequence(spin, text);
227
   get_me_to_those_events(spin);
228

229
   efl_ui_focus_util_focus(efl_content_get(efl_part(spin, "efl.inc_button")));
230
   ck_assert_msg(EINA_DBL_EQ(efl_ui_range_value_get(spin), result), "Values do not match %f - %f (%s)", efl_ui_range_value_get(spin), result, elm_object_text_get(entry));
231
}
232

233
EFL_START_TEST (spin_direct_text_input)
234
{
235
   efl_ui_spin_button_direct_text_input_set(spin, EINA_TRUE);
236
   efl_ui_range_limits_set(spin, -30, 30);
237
   efl_ui_range_value_set(spin, 20);
238
   get_me_to_those_events(spin);
239
   _try_direct_text_input("1asdf2", 12);
240
   _try_direct_text_input("1-2", 12);
241
   _try_direct_text_input("-12", -12);
242
   _try_direct_text_input("-100", -30);
243
   _try_direct_text_input("1.8", 18);
244
   _try_direct_text_input("12342435", 30);
245
}
246
EFL_END_TEST
247

248
EFL_START_TEST (spin_direct_text_input_comma_value)
249
{
250
   efl_ui_spin_button_direct_text_input_set(spin, EINA_TRUE);
251
   efl_ui_range_limits_set(spin, -30, 30);
252
   efl_ui_range_value_set(spin, 20);
253
   efl_ui_format_string_set(spin, "%.2f", EFL_UI_FORMAT_STRING_TYPE_SIMPLE);
254
   efl_ui_focus_util_focus(efl_content_get(efl_part(spin, "efl.text_button")));
255
   get_me_to_those_events(spin);
256
   _try_direct_text_input("1asdf2.1", 12.1);
257
   _try_direct_text_input("1-2.2", 12.2);
258
   _try_direct_text_input("-12.8", -12.8);
259
   _try_direct_text_input("-100", -30);
260
   _try_direct_text_input("10.8", 10.8);
261
   _try_direct_text_input("12342435.12312341342", 30);
262
}
263
EFL_END_TEST
264

265
void efl_ui_test_spin_button(TCase *tc)
266
{
267
   tcase_add_checked_fixture(tc, fail_on_errors_setup, fail_on_errors_teardown);
268
   tcase_add_checked_fixture(tc, spin_setup, NULL);
269
   tcase_add_test(tc, spin_wheel_test);
270
   tcase_add_test(tc, spin_value_inc);
271
   tcase_add_test(tc, spin_value_inc_max);
272
   tcase_add_test(tc, spin_value_dec_min);
273
   tcase_add_test(tc, spin_wraparound);
274
   tcase_add_test(tc, spin_double_values);
275
   tcase_add_test(tc, spin_double_values_hitting_max_with_step);
276
   tcase_add_test(tc, spin_direct_text_input);
277
   tcase_add_test(tc, spin_direct_text_input_comma_value);
278
}
279