efl

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

5
#include <Efl_Ui.h>
6
#include "elm_suite.h"
7

8
#define COORD_EQ(a, b) (!!(abs(a - b) < 2))
9
#define GEOMETRY_EQ(a, b) (COORD_EQ(a.x, b.x) && COORD_EQ(a.y, b.y) && \
10
                           COORD_EQ(a.w, b.w) && COORD_EQ(a.h, b.h))
11

12
typedef struct {
13
   Eina_Size2D              max;
14
   Eina_Size2D              min;
15
   double                   weightx;
16
   double                   weighty;
17
   double                   alignx;
18
   double                   aligny;
19
   int                      marginl;
20
   int                      marginr;
21
   int                      margint;
22
   int                      marginb;
23
   Efl_Gfx_Hint_Aspect mode;
24
   Eina_Size2D              aspect;
25
   Eina_Bool                fillx;
26
   Eina_Bool                filly;
27
   Eina_Size2D              layout_size;
28
   Eina_Size2D              layout_expected;
29
   Eina_Rect                expected;
30
   char                     testname[1024];
31
} Hint;
32

33
static Hint hints[] = {
34
   { EINA_SIZE2D(-1, -1), EINA_SIZE2D(0, 0), 1, 1, 0.5, 0.5, 0, 0, 0, 0,
35
     EFL_GFX_HINT_ASPECT_NONE, EINA_SIZE2D(0, 0), EINA_TRUE, EINA_TRUE,
36
     EINA_SIZE2D(200, 200), EINA_SIZE2D(200, 200),
37
     EINA_RECT(0, 0, 200, 200), "[0]" },
38
   { EINA_SIZE2D(-1, -1), EINA_SIZE2D(70, 70), 1, 1, 0.3, 0.5, 0, 0, 0, 0,
39
     EFL_GFX_HINT_ASPECT_NONE, EINA_SIZE2D(0, 0), EINA_TRUE, EINA_TRUE,
40
     EINA_SIZE2D(200, 200), EINA_SIZE2D(200, 200),
41
     EINA_RECT(0, 0, 200, 200), "[1]" },
42
   { EINA_SIZE2D(50, 150), EINA_SIZE2D(70, 70), 1, 1, 0.3, 0.7, 0, 0, 0, 0,
43
     EFL_GFX_HINT_ASPECT_NONE, EINA_SIZE2D(0, 0), EINA_TRUE, EINA_TRUE,
44
     EINA_SIZE2D(200, 200), EINA_SIZE2D(200, 200),
45
     EINA_RECT((200 - 70) * 0.3, (200 - 150) * 0.7, 70, 150), "[2]" },
46
   { EINA_SIZE2D(150, -1), EINA_SIZE2D(70, 70), 0, 0, 0.3, 0.7, 0, 0, 0, 0,
47
     EFL_GFX_HINT_ASPECT_NONE, EINA_SIZE2D(0, 0), EINA_FALSE, EINA_FALSE,
48
     EINA_SIZE2D(200, 200), EINA_SIZE2D(200, 200),
49
     EINA_RECT((200 - 70) * 0.3, (200 - 70) * 0.7, 70, 70), "[3]" },
50
   { EINA_SIZE2D(-1, -1), EINA_SIZE2D(70, 70), 1, 0, 0.3, 0.7, 0, 0, 0, 0,
51
     EFL_GFX_HINT_ASPECT_NONE, EINA_SIZE2D(0, 0), EINA_FALSE, EINA_TRUE,
52
     EINA_SIZE2D(200, 200), EINA_SIZE2D(200, 200),
53
     EINA_RECT((200 - 70) * 0.3, (200 - 70) * 0.7, 70, 70), "[4]" },
54
   { EINA_SIZE2D(150, 150), EINA_SIZE2D(70, 70), 1, 0, 0.3, 0.7, 0, 0, 0, 0,
55
     EFL_GFX_HINT_ASPECT_NONE, EINA_SIZE2D(0, 0), EINA_FALSE, EINA_TRUE,
56
     EINA_SIZE2D(200, 200), EINA_SIZE2D(200, 200),
57
     EINA_RECT((200 - 70) * 0.3, (200 - 70) * 0.7, 70, 70), "[5]" },
58
   { EINA_SIZE2D(-1, -1), EINA_SIZE2D(70, 70), 0, 1, 0.3, 0.7, 0, 0, 0, 0,
59
     EFL_GFX_HINT_ASPECT_BOTH, EINA_SIZE2D(1, 3), EINA_TRUE, EINA_FALSE,
60
     EINA_SIZE2D(200, 200), EINA_SIZE2D(200, 210),
61
     EINA_RECT((200 - 70) * 0.3, 0, 70, 70 * 3), "[6]" },
62
   { EINA_SIZE2D(-1, -1), EINA_SIZE2D(70, 70), 0, 1, 0.3, 0.7, 0, 0, 0, 0,
63
     EFL_GFX_HINT_ASPECT_BOTH, EINA_SIZE2D(1, 3), EINA_TRUE, EINA_FALSE,
64
     EINA_SIZE2D(300, 300), EINA_SIZE2D(300, 300),
65
     EINA_RECT((300 - 70) * 0.3, (300 - 70 * 3) * 0.7, 70, 70 * 3), "[7]" },
66
   { EINA_SIZE2D(-1, -1), EINA_SIZE2D(70, 70), 1, 0, 0.3, 0.7, 0, 0, 0, 0,
67
     EFL_GFX_HINT_ASPECT_BOTH, EINA_SIZE2D(1, 3), EINA_TRUE, EINA_FALSE,
68
     EINA_SIZE2D(200, 200), EINA_SIZE2D(200, 210),
69
     EINA_RECT((200 - 70) * 0.3, 0, 70, 70 * 3), "[8]" },
70
   { EINA_SIZE2D(-1, -1), EINA_SIZE2D(70, 70), 1, 0, 0.3, 0.7, 0, 0, 0, 0,
71
     EFL_GFX_HINT_ASPECT_BOTH, EINA_SIZE2D(1, 3), EINA_TRUE, EINA_FALSE,
72
     EINA_SIZE2D(300, 300), EINA_SIZE2D(300, 300),
73
     EINA_RECT((300 - 70) * 0.3, (300 - 70 * 3) * 0.7, 70, 70 * 3), "[9]" },
74
   { EINA_SIZE2D(-1, 150), EINA_SIZE2D(70, 70), 0, 1, 0.3, 0.7, 0, 0, 0, 0,
75
     EFL_GFX_HINT_ASPECT_BOTH, EINA_SIZE2D(1, 3), EINA_TRUE, EINA_FALSE,
76
     EINA_SIZE2D(200, 200), EINA_SIZE2D(200, 210),
77
     EINA_RECT((200 - 70) * 0.3, 0, 70, 70 * 3), "[10]" },
78
   { EINA_SIZE2D(-1, 150), EINA_SIZE2D(70, 70), 0, 1, 0.3, 0.7, 0, 0, 0, 0,
79
     EFL_GFX_HINT_ASPECT_BOTH, EINA_SIZE2D(1, 3), EINA_TRUE, EINA_FALSE,
80
     EINA_SIZE2D(300, 300), EINA_SIZE2D(300, 300),
81
     EINA_RECT((300 - 70) * 0.3, (300 - 70 * 3) * 0.7, 70, 70 * 3), "[11]" },
82
   { EINA_SIZE2D(-1, 150), EINA_SIZE2D(70, 70), 1, 0, 0.3, 0.7, 0, 0, 0, 0,
83
     EFL_GFX_HINT_ASPECT_BOTH, EINA_SIZE2D(1, 3), EINA_TRUE, EINA_FALSE,
84
     EINA_SIZE2D(200, 200), EINA_SIZE2D(200, 210),
85
     EINA_RECT((200 - 70) * 0.3, 0, 70, 70 * 3), "[12]" },
86
   { EINA_SIZE2D(-1, 150), EINA_SIZE2D(70, 70), 1, 0, 0.3, 0.7, 0, 0, 0, 0,
87
     EFL_GFX_HINT_ASPECT_BOTH, EINA_SIZE2D(1, 3), EINA_TRUE, EINA_FALSE,
88
     EINA_SIZE2D(300, 300), EINA_SIZE2D(300, 300),
89
     EINA_RECT((300 - 70) * 0.3, (300 - 70 * 3) * 0.7, 70, 70 * 3), "[13]" },
90
};
91

92
static Eo *win, *layout;
93

94
static void
95
btn_hint_set(Eo *btn, Hint *hint)
96
{
97
   efl_gfx_entity_size_set(layout, hint->layout_size);
98
   efl_gfx_hint_size_max_set(btn, hint->max);
99
   efl_gfx_hint_size_min_set(btn, hint->min);
100
   efl_gfx_hint_margin_set(btn, hint->marginl, hint->marginr, hint->margint,
101
                           hint->marginb);
102
   efl_gfx_hint_weight_set(btn, hint->weightx, hint->weighty);
103
   efl_gfx_hint_align_set(btn, hint->alignx, hint->aligny);
104
   efl_gfx_hint_fill_set(btn, hint->fillx, hint->filly);
105
   efl_gfx_hint_aspect_set(btn, hint->mode, hint->aspect);
106
   efl_canvas_group_calculate(layout);
107
}
108

109
static void
110
btn_geom_assert(Hint *hint, Eina_Rect btn_geom)
111
{
112
   Eina_Size2D layout_size, layout_min;
113

114
   layout_size = efl_gfx_entity_size_get(layout);
115
   layout_min = efl_gfx_hint_size_combined_min_get(layout);
116
   layout_size.w = layout_size.w > layout_min.w ? layout_size.w : layout_min.w;
117
   layout_size.h = layout_size.h > layout_min.h ? layout_size.h : layout_min.h;
118

119
   ck_assert_msg(GEOMETRY_EQ(btn_geom, hint->expected),
120
                 "Case %s failed... button geometry: (%d, %d, %d, %d) expected geometry: (%d, %d, %d, %d)",
121
                 hint->testname, btn_geom.x, btn_geom.y, btn_geom.w, btn_geom.h,
122
                 hint->expected.x, hint->expected.y, hint->expected.w, hint->expected.h);
123
   ck_assert_msg(COORD_EQ(layout_size.w, hint->layout_expected.w) &&
124
                 COORD_EQ(layout_size.h, hint->layout_expected.h),
125
                 "Case %s failed... layout size: (%d, %d) expected size: (%d, %d)",
126
                 hint->testname, layout_size.w, layout_size.h,
127
                 hint->layout_expected.w, hint->layout_expected.h);
128
}
129

130
static void
131
layout_setup()
132
{
133
   win = win_add();
134

135
   layout = efl_add(EFL_UI_BOX_STACK_CLASS, win,
136
                    efl_gfx_arrangement_content_align_set(efl_added, 0.8, 0.2),
137
                    efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL));
138
}
139

140
EFL_START_TEST (efl_ui_box_stack_class_check)
141
{
142
   const char *class;
143

144
   class = efl_class_name_get(layout);
145

146
   ck_assert(class != NULL);
147
   ck_assert(!strcmp(class, "Efl.Ui.Box_Stack"));
148
}
149
EFL_END_TEST
150

151
EFL_START_TEST (efl_ui_box_stack_layout_update)
152
{
153
   int i, max_index = (sizeof(hints) / sizeof(Hint));
154

155
   Eo *btn = efl_add(EFL_UI_BUTTON_CLASS, layout,
156
                     efl_pack_end(layout, efl_added));
157

158
   for (i = 0; i < max_index; i++)
159
     {
160
        btn_hint_set(btn, &hints[i]);
161
        btn_geom_assert(&hints[i], efl_gfx_entity_geometry_get(btn));
162
     }
163
}
164
EFL_END_TEST
165

166
EFL_START_TEST (efl_ui_box_stack_size)
167
{
168
#define USERMIN_CHECK(a, b) \
169
   efl_canvas_group_calculate(layout); \
170
   user_min = efl_gfx_hint_size_min_get(layout); \
171
   ck_assert_msg(COORD_EQ(user_min.w, (a)) && COORD_EQ(user_min.h, (b)), \
172
                 "Case box_size failed... user_min: (%d, %d) expected user_min: (%d, %d)", \
173
                 user_min.w, user_min.h, (a), (b));
174

175
#define MIN_CHECK(a, b) \
176
   efl_canvas_group_calculate(layout); \
177
   min = efl_gfx_hint_size_combined_min_get(layout); \
178
   ck_assert_msg(COORD_EQ(min.w, (a)) && COORD_EQ(min.h, (b)), \
179
                 "Case box_size failed... min: (%d, %d) expected min: (%d, %d)", \
180
                 min.w, min.h, (a), (b));
181

182
   Eo *btn, *btn2, *btn3;
183
   Eina_Size2D min, user_min;
184

185
   btn = efl_add(EFL_UI_BUTTON_CLASS, layout,
186
                 efl_gfx_hint_size_min_set(efl_added, EINA_SIZE2D(100, 100)),
187
                 efl_pack_end(layout, efl_added));
188

189
   USERMIN_CHECK(0, 0);
190
   MIN_CHECK(100, 100);
191

192
   btn2 = efl_add(EFL_UI_BUTTON_CLASS, layout,
193
                  efl_gfx_hint_size_min_set(efl_added, EINA_SIZE2D(300, 300)),
194
                  efl_pack_end(layout, efl_added));
195
   btn3 = efl_add(EFL_UI_BUTTON_CLASS, layout,
196
                  efl_gfx_hint_size_min_set(efl_added, EINA_SIZE2D(200, 200)),
197
                  efl_pack_end(layout, efl_added));
198
   USERMIN_CHECK(0, 0);
199
   MIN_CHECK(300, 300);
200

201
   efl_pack_unpack(layout, btn2);
202
   USERMIN_CHECK(0, 0);
203
   MIN_CHECK(200, 200);
204

205
   efl_pack_unpack(layout, btn3);
206
   USERMIN_CHECK(0, 0);
207
   MIN_CHECK(100, 100);
208

209
   efl_pack_unpack(layout, btn);
210
   USERMIN_CHECK(0, 0);
211
   MIN_CHECK(0, 0);
212

213
   efl_pack_end(layout, btn);
214
   efl_gfx_hint_size_min_set(layout, EINA_SIZE2D(200, 200));
215
   USERMIN_CHECK(200, 200);
216
   MIN_CHECK(200, 200);
217

218
   efl_pack_end(layout, btn2);
219
   efl_pack_end(layout, btn3);
220
   USERMIN_CHECK(200, 200);
221
   MIN_CHECK(300, 300);
222

223
#undef USERMIN_ASSERT
224
#undef MIN_ASSERT
225
}
226
EFL_END_TEST
227

228
void efl_ui_test_box_stack(TCase *tc)
229
{
230
   tcase_add_checked_fixture(tc, layout_setup, NULL);
231
   tcase_add_test(tc, efl_ui_box_stack_class_check);
232
   tcase_add_test(tc, efl_ui_box_stack_layout_update);
233
   tcase_add_test(tc, efl_ui_box_stack_size);
234
}
235