efl

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

5
#include <Efl_Ui.h>
6
#include <Elementary.h>
7
#include "elm_suite.h"
8
#include "elm_priv.h"
9

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

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

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

94
static Hint hints2[][2] = {
95
   {
96
      { EINA_SIZE2D(-1, -1), EINA_SIZE2D(70, 70), 1, 1, 0.3, 0.7, 0, 0, 0, 0,
97
        EFL_GFX_HINT_ASPECT_NONE, EINA_SIZE2D(0, 0), EINA_FALSE, EINA_FALSE,
98
        EINA_SIZE2D(150, 300), EINA_SIZE2D(150, 300),
99
        EINA_RECT((150 - 70) * 0.3, (150 - 70) * 0.7, 70, 70), "[1/1 weight btn]" },
100
      { EINA_SIZE2D(-1, -1), EINA_SIZE2D(70, 70), 1, 1, 0.8, 0.2, 0, 0, 0, 0,
101
        EFL_GFX_HINT_ASPECT_NONE, EINA_SIZE2D(0, 0), EINA_FALSE, EINA_FALSE,
102
        EINA_SIZE2D(150, 300), EINA_SIZE2D(150, 300),
103
        EINA_RECT((150 - 70) * 0.8, (150 - 70) * 0.2 + 150, 70, 70), "[1/1 weight btn2]" }
104
   },
105
   {
106
      { EINA_SIZE2D(-1, -1), EINA_SIZE2D(70, 70), 1, 0, 0.3, 0.7, 0, 0, 0, 0,
107
        EFL_GFX_HINT_ASPECT_NONE, EINA_SIZE2D(0, 0), EINA_FALSE, EINA_FALSE,
108
        EINA_SIZE2D(150, 300), EINA_SIZE2D(150, 300),
109
        EINA_RECT((150 - 70) * 0.3, 0, 70, 70), "[0/1 weight btn]" },
110
      { EINA_SIZE2D(-1, -1), EINA_SIZE2D(70, 70), 1, 1, 0.8, 0.2, 0, 0, 0, 0,
111
        EFL_GFX_HINT_ASPECT_VERTICAL, EINA_SIZE2D(1, 3), EINA_TRUE, EINA_TRUE,
112
        EINA_SIZE2D(150, 300), EINA_SIZE2D(150, 300),
113
        EINA_RECT((150 - ((300 - 70) / 3)) * 0.8, 70, (300 - 70) / 3, (300 - 70)), "[0/1 weight btn2]" }
114
   },
115
   {
116
      { EINA_SIZE2D(-1, -1), EINA_SIZE2D(70, 70), 1, 0, 0.3, 0.7, 0, 0, 0, 0,
117
        EFL_GFX_HINT_ASPECT_NONE, EINA_SIZE2D(0, 0), EINA_FALSE, EINA_FALSE,
118
        EINA_SIZE2D(150, 300), EINA_SIZE2D(150, 300),
119
        EINA_RECT((150 - 70) * 0.3, (300 - 280) * 0.2, 70, 70), "[0/0 weight btn]" },
120
      { EINA_SIZE2D(-1, -1), EINA_SIZE2D(70, 70), 1, 0, 0.8, 0.2, 0, 0, 0, 0,
121
        EFL_GFX_HINT_ASPECT_HORIZONTAL, EINA_SIZE2D(1, 3), EINA_TRUE, EINA_FALSE,
122
        EINA_SIZE2D(150, 300), EINA_SIZE2D(150, 300),
123
        EINA_RECT((150 - 70) * 0.8, (300 - 280) * 0.2 + 70, 70, 70 * 3), "[0/0 weight btn2]" }
124
   },
125
};
126

127
static Hint hints3[][3] = {
128
   {
129
      { EINA_SIZE2D(-1, -1), EINA_SIZE2D(70, 70), 1, 1, 0.3, 0.7, 0, 0, 0, 0,
130
        EFL_GFX_HINT_ASPECT_NONE, EINA_SIZE2D(0, 0), EINA_TRUE, EINA_TRUE,
131
        EINA_SIZE2D(150, 300), EINA_SIZE2D(150, 300),
132
        EINA_RECT(0, 0, 150, 100), "[1/1/1 weight_l btn]" },
133
      { EINA_SIZE2D(-1, -1), EINA_SIZE2D(70, 100), 1, 1, 0.8, 0.2, 0, 0, 0, 0,
134
        EFL_GFX_HINT_ASPECT_NONE, EINA_SIZE2D(0, 0), EINA_TRUE, EINA_TRUE,
135
        EINA_SIZE2D(150, 300), EINA_SIZE2D(150, 300),
136
        EINA_RECT(0, 100, 150, 100), "[1/1/1 weight_l btn2]" },
137
      { EINA_SIZE2D(-1, -1), EINA_SIZE2D(70, 70), 1, 1, 0.8, 0.2, 0, 0, 0, 0,
138
        EFL_GFX_HINT_ASPECT_NONE, EINA_SIZE2D(0, 0), EINA_TRUE, EINA_TRUE,
139
        EINA_SIZE2D(150, 300), EINA_SIZE2D(150, 300),
140
        EINA_RECT(0, 100 + 100, 150, 100), "[1/1/1 weight_l btn3]" }
141
   },
142
   {
143
      { EINA_SIZE2D(-1, -1), EINA_SIZE2D(70, 70), 1, 1, 0.3, 0.7, 0, 0, 0, 0,
144
        EFL_GFX_HINT_ASPECT_NONE, EINA_SIZE2D(0, 0), EINA_TRUE, EINA_TRUE,
145
        EINA_SIZE2D(150, 270), EINA_SIZE2D(150, 270),
146
        EINA_RECT(0, 0, 150, 85), "[1/1/1 weight_m btn]" },
147
      { EINA_SIZE2D(-1, -1), EINA_SIZE2D(70, 100), 1, 1, 0.8, 0.2, 0, 0, 0, 0,
148
        EFL_GFX_HINT_ASPECT_NONE, EINA_SIZE2D(0, 0), EINA_TRUE, EINA_TRUE,
149
        EINA_SIZE2D(150, 270), EINA_SIZE2D(150, 270),
150
        EINA_RECT(0, 85, 150, 100), "[1/1/1 weight_m btn2]" },
151
      { EINA_SIZE2D(-1, -1), EINA_SIZE2D(70, 70), 1, 1, 0.8, 0.2, 0, 0, 0, 0,
152
        EFL_GFX_HINT_ASPECT_NONE, EINA_SIZE2D(0, 0), EINA_TRUE, EINA_TRUE,
153
        EINA_SIZE2D(150, 270), EINA_SIZE2D(150, 270),
154
        EINA_RECT(0, 100 + 85, 150, 85), "[1/1/1 weight_m btn3]" }
155
   },
156
   {
157
      { EINA_SIZE2D(-1, -1), EINA_SIZE2D(70, 70), 1, 1, 0.3, 0.7, 0, 0, 0, 0,
158
        EFL_GFX_HINT_ASPECT_NONE, EINA_SIZE2D(0, 0), EINA_TRUE, EINA_TRUE,
159
        EINA_SIZE2D(150, 200), EINA_SIZE2D(150, 240),
160
        EINA_RECT(0, 0, 150, 70), "[1/1/1 weight_s btn]" },
161
      { EINA_SIZE2D(-1, -1), EINA_SIZE2D(70, 100), 1, 1, 0.8, 0.2, 0, 0, 0, 0,
162
        EFL_GFX_HINT_ASPECT_NONE, EINA_SIZE2D(0, 0), EINA_TRUE, EINA_TRUE,
163
        EINA_SIZE2D(150, 200), EINA_SIZE2D(150, 240),
164
        EINA_RECT(0, 70, 150, 100), "[1/1/1 weight_s btn2]" },
165
      { EINA_SIZE2D(-1, -1), EINA_SIZE2D(70, 70), 1, 1, 0.8, 0.2, 0, 0, 0, 0,
166
        EFL_GFX_HINT_ASPECT_NONE, EINA_SIZE2D(0, 0), EINA_TRUE, EINA_TRUE,
167
        EINA_SIZE2D(150, 200), EINA_SIZE2D(150, 240),
168
        EINA_RECT(0, 170, 150, 70), "[1/1/1 weight_s btn3]" }
169
   },
170
   {
171
      { EINA_SIZE2D(-1, -1), EINA_SIZE2D(0, 0), 1, 1, 0.5, 0.5, 0, 0, 0, 0,
172
        EFL_GFX_HINT_ASPECT_BOTH, EINA_SIZE2D(1, 3), EINA_TRUE, EINA_TRUE,
173
        EINA_SIZE2D(300, 900), EINA_SIZE2D(300, 900),
174
        EINA_RECT(100, 0, 100, 300), "[aspect resize btn]" },
175
      { EINA_SIZE2D(-1, -1), EINA_SIZE2D(0, 0), 1, 1, 0.5, 0.5, 0, 0, 0, 0,
176
        EFL_GFX_HINT_ASPECT_BOTH, EINA_SIZE2D(1, 3), EINA_TRUE, EINA_TRUE,
177
        EINA_SIZE2D(300, 900), EINA_SIZE2D(300, 900),
178
        EINA_RECT(100, 300, 100, 300), "[aspect resize btn2]" },
179
      { EINA_SIZE2D(-1, -1), EINA_SIZE2D(0, 0), 1, 1, 0.5, 0.5, 0, 0, 0, 0,
180
        EFL_GFX_HINT_ASPECT_BOTH, EINA_SIZE2D(1, 3), EINA_TRUE, EINA_TRUE,
181
        EINA_SIZE2D(300, 900), EINA_SIZE2D(300, 900),
182
        EINA_RECT(100, 300 + 300, 100, 300), "[aspect resize btn3]" }
183
   },
184
};
185

186
static Eo *win, *layout;
187

188
static void
189
btn_hint_set(Eo *btn, Hint *hint)
190
{
191
   efl_gfx_entity_size_set(layout, hint->layout_size);
192
   efl_gfx_hint_size_min_set(layout, hint->layout_size);
193
   efl_gfx_hint_size_max_set(btn, hint->max);
194
   efl_gfx_hint_size_min_set(btn, hint->min);
195
   efl_gfx_hint_weight_set(btn, hint->weightx, hint->weighty);
196
   efl_gfx_hint_align_set(btn, hint->alignx, hint->aligny);
197
   efl_gfx_hint_fill_set(btn, hint->fillx, hint->filly);
198
   efl_gfx_hint_aspect_set(btn, hint->mode, hint->aspect);
199
   efl_canvas_group_calculate(layout);
200
}
201

202
static void
203
btn_geom_assert(Hint *hint, Eina_Rect btn_geom)
204
{
205
   Eina_Size2D layout_size, layout_min;
206

207
   layout_size = efl_gfx_entity_size_get(layout);
208
   layout_min = efl_gfx_hint_size_combined_min_get(layout);
209
   layout_size.w = layout_size.w > layout_min.w ? layout_size.w : layout_min.w;
210
   layout_size.h = layout_size.h > layout_min.h ? layout_size.h : layout_min.h;
211

212
   ck_assert_msg(GEOMETRY_EQ(btn_geom, hint->expected),
213
                 "Case %s failed... button geometry: (%d, %d, %d, %d) expected geometry: (%d, %d, %d, %d)",
214
                 hint->testname, btn_geom.x, btn_geom.y, btn_geom.w, btn_geom.h,
215
                 hint->expected.x, hint->expected.y, hint->expected.w, hint->expected.h);
216
   ck_assert_msg(COORD_EQ(layout_size.w, hint->layout_expected.w) &&
217
                 COORD_EQ(layout_size.h, hint->layout_expected.h),
218
                 "Case %s failed... layout size: (%d, %d) expected size: (%d, %d)",
219
                 hint->testname, layout_size.w, layout_size.h,
220
                 hint->layout_expected.w, hint->layout_expected.h);
221
}
222

223
static void
224
layout_setup()
225
{
226
   win = win_add();
227

228
   layout = efl_add(EFL_UI_BOX_CLASS, win);
229
}
230

231
EFL_START_TEST (efl_ui_box_class_check)
232
{
233
   const char *class;
234

235
   class = efl_class_name_get(layout);
236

237
   ck_assert(class != NULL);
238
   ck_assert(!strcmp(class, "Efl.Ui.Box"));
239
}
240
EFL_END_TEST
241

242
EFL_START_TEST (efl_ui_box_layout_update)
243
{
244
   int i, max_index = (sizeof(hints) / sizeof(Hint));
245

246
   efl_gfx_arrangement_content_align_set(layout, 0.8, 0.2);
247
   efl_ui_layout_orientation_set(layout, EFL_UI_LAYOUT_ORIENTATION_VERTICAL);
248

249
   Eo *btn = efl_add(EFL_UI_BUTTON_CLASS, layout,
250
                     efl_pack_end(layout, efl_added));
251

252
   for (i = 0; i < max_index; i++)
253
     {
254
        btn_hint_set(btn, &hints[i]);
255
        btn_geom_assert(&hints[i], efl_gfx_entity_geometry_get(btn));
256
     }
257
}
258
EFL_END_TEST
259

260
EFL_START_TEST (efl_ui_box_layout_update_pack)
261
{
262
   int i, max_index2, max_index3;
263
   Eo *btn, *btn2, *btn3;
264

265
   efl_gfx_arrangement_content_align_set(layout, 0.8, 0.2);
266
   efl_ui_layout_orientation_set(layout, EFL_UI_LAYOUT_ORIENTATION_VERTICAL);
267

268
   max_index2 = ((sizeof(hints2) / sizeof(Hint)) / 2);
269
   max_index3 = ((sizeof(hints3) / sizeof(Hint)) / 3);
270

271
   btn = efl_add(EFL_UI_BUTTON_CLASS, layout,
272
                 efl_pack_end(layout, efl_added));
273
   btn2 = efl_add(EFL_UI_BUTTON_CLASS, layout,
274
                  efl_pack_end(layout, efl_added));
275

276
   for (i = 0; i < max_index2; i++)
277
     {
278
        btn_hint_set(btn, &hints2[i][0]);
279
        btn_hint_set(btn2, &hints2[i][1]);
280
        btn_geom_assert(&hints2[i][0], efl_gfx_entity_geometry_get(btn));
281
        btn_geom_assert(&hints2[i][1], efl_gfx_entity_geometry_get(btn2));
282
     }
283

284
   btn3 = efl_add(EFL_UI_BUTTON_CLASS, layout,
285
                  efl_pack_end(layout, efl_added));
286

287
   for (i = 0; i < max_index3; i++)
288
     {
289
        btn_hint_set(btn, &hints3[i][0]);
290
        btn_hint_set(btn2, &hints3[i][1]);
291
        btn_hint_set(btn3, &hints3[i][2]);
292
        btn_geom_assert(&hints3[i][0], efl_gfx_entity_geometry_get(btn));
293
        btn_geom_assert(&hints3[i][1], efl_gfx_entity_geometry_get(btn2));
294
        btn_geom_assert(&hints3[i][2], efl_gfx_entity_geometry_get(btn3));
295
     }
296

297
   // aspect resize test
298
   hints3[3][0].layout_expected = hints3[3][0].layout_size = EINA_SIZE2D(150, 450);
299
   hints3[3][1].layout_expected = hints3[3][1].layout_size = EINA_SIZE2D(150, 450);
300
   hints3[3][2].layout_expected = hints3[3][2].layout_size = EINA_SIZE2D(150, 450);
301
   hints3[3][0].expected = EINA_RECT(50, 0, 50, 150);
302
   hints3[3][1].expected = EINA_RECT(50, 150, 50, 150);
303
   hints3[3][2].expected = EINA_RECT(50, 300, 50, 150);
304

305
   btn_hint_set(btn, &hints3[3][0]);
306
   btn_hint_set(btn2, &hints3[3][1]);
307
   btn_hint_set(btn3, &hints3[3][2]);
308
   btn_geom_assert(&hints3[3][0], efl_gfx_entity_geometry_get(btn));
309
   btn_geom_assert(&hints3[3][1], efl_gfx_entity_geometry_get(btn2));
310
   btn_geom_assert(&hints3[3][2], efl_gfx_entity_geometry_get(btn3));
311

312
   efl_ui_layout_orientation_set(layout, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
313
   hints3[3][0].layout_expected = hints3[3][0].layout_size = EINA_SIZE2D(300, 900);
314
   hints3[3][1].layout_expected = hints3[3][1].layout_size = EINA_SIZE2D(300, 900);
315
   hints3[3][2].layout_expected = hints3[3][2].layout_size = EINA_SIZE2D(300, 900);
316
   hints3[3][0].expected = EINA_RECT(0, 300, 100, 300);
317
   hints3[3][1].expected = EINA_RECT(100, 300, 100, 300);
318
   hints3[3][2].expected = EINA_RECT(200, 300, 100, 300);
319

320
   btn_hint_set(btn, &hints3[3][0]);
321
   btn_hint_set(btn2, &hints3[3][1]);
322
   btn_hint_set(btn3, &hints3[3][2]);
323
   btn_geom_assert(&hints3[3][0], efl_gfx_entity_geometry_get(btn));
324
   btn_geom_assert(&hints3[3][1], efl_gfx_entity_geometry_get(btn2));
325
   btn_geom_assert(&hints3[3][2], efl_gfx_entity_geometry_get(btn3));
326

327
   hints3[3][0].layout_expected = hints3[3][0].layout_size = EINA_SIZE2D(150, 450);
328
   hints3[3][1].layout_expected = hints3[3][1].layout_size = EINA_SIZE2D(150, 450);
329
   hints3[3][2].layout_expected = hints3[3][2].layout_size = EINA_SIZE2D(150, 450);
330
   hints3[3][0].expected = EINA_RECT(0, 150, 50, 150);
331
   hints3[3][1].expected = EINA_RECT(50, 150, 50, 150);
332
   hints3[3][2].expected = EINA_RECT(100, 150, 50, 150);
333

334
   btn_hint_set(btn, &hints3[3][0]);
335
   btn_hint_set(btn2, &hints3[3][1]);
336
   btn_hint_set(btn3, &hints3[3][2]);
337
   btn_geom_assert(&hints3[3][0], efl_gfx_entity_geometry_get(btn));
338
   btn_geom_assert(&hints3[3][1], efl_gfx_entity_geometry_get(btn2));
339
   btn_geom_assert(&hints3[3][2], efl_gfx_entity_geometry_get(btn3));
340
}
341
EFL_END_TEST
342

343
EFL_START_TEST (efl_ui_box_size)
344
{
345
#define USERMIN_CHECK(a, b) \
346
   efl_canvas_group_calculate(layout); \
347
   user_min = efl_gfx_hint_size_min_get(layout); \
348
   ck_assert_msg(COORD_EQ(user_min.w, (a)) && COORD_EQ(user_min.h, (b)), \
349
                 "Case box_size failed... user_min: (%d, %d) expected user_min: (%d, %d)", \
350
                 user_min.w, user_min.h, (a), (b));
351

352
#define MIN_CHECK(a, b) \
353
   efl_canvas_group_calculate(layout); \
354
   min = efl_gfx_hint_size_combined_min_get(layout); \
355
   ck_assert_msg(COORD_EQ(min.w, (a)) && COORD_EQ(min.h, (b)), \
356
                 "Case box_size failed... min: (%d, %d) expected min: (%d, %d)", \
357
                 min.w, min.h, (a), (b));
358

359
   Eo *btn, *btn2, *btn3;
360
   Eina_Size2D min, user_min;
361

362
   efl_ui_layout_orientation_set(layout, EFL_UI_LAYOUT_ORIENTATION_VERTICAL);
363

364
   btn = efl_add(EFL_UI_BUTTON_CLASS, layout,
365
                 efl_gfx_hint_size_min_set(efl_added, EINA_SIZE2D(100, 100)),
366
                 efl_pack_end(layout, efl_added));
367

368
   USERMIN_CHECK(0, 0);
369
   MIN_CHECK(100, 100);
370

371
   btn2 = efl_add(EFL_UI_BUTTON_CLASS, layout,
372
                  efl_gfx_hint_size_min_set(efl_added, EINA_SIZE2D(100, 100)),
373
                  efl_pack_end(layout, efl_added));
374
   btn3 = efl_add(EFL_UI_BUTTON_CLASS, layout,
375
                  efl_gfx_hint_size_min_set(efl_added, EINA_SIZE2D(100, 100)),
376
                  efl_pack_end(layout, efl_added));
377
   USERMIN_CHECK(0, 0);
378
   MIN_CHECK(100, 300);
379

380
   efl_pack_unpack(layout, btn2);
381
   USERMIN_CHECK(0, 0);
382
   MIN_CHECK(100, 200);
383

384
   efl_pack_unpack(layout, btn3);
385
   USERMIN_CHECK(0, 0);
386
   MIN_CHECK(100, 100);
387

388
   efl_pack_unpack(layout, btn);
389
   USERMIN_CHECK(0, 0);
390
   MIN_CHECK(0, 0);
391

392
   efl_pack_end(layout, btn);
393
   efl_gfx_hint_size_min_set(layout, EINA_SIZE2D(200, 200));
394
   USERMIN_CHECK(200, 200);
395
   MIN_CHECK(200, 200);
396

397
   efl_pack_end(layout, btn2);
398
   efl_pack_end(layout, btn3);
399
   USERMIN_CHECK(200, 200);
400
   MIN_CHECK(200, 300);
401

402
#undef USERMIN_ASSERT
403
#undef MIN_ASSERT
404
}
405
EFL_END_TEST
406

407
EFL_START_TEST (efl_ui_box_pack_unpack)
408
{
409
#define BTN_NUM 6
410
   Eo *o, *btn[BTN_NUM];
411
   Eina_Iterator *itr;
412
   int i;
413

414
   for (i = 0; i < BTN_NUM; i++)
415
     btn[i] = efl_add(EFL_UI_BUTTON_CLASS, layout);
416

417
   //pack test
418
   ck_assert(efl_pack(layout, btn[1]));
419
   ck_assert_ptr_eq(efl_pack_content_get(layout, 0), btn[1]);
420
   ck_assert_int_eq(efl_pack_index_get(layout, btn[1]), 0);
421
   EXPECT_ERROR_START;
422
   ck_assert(!efl_pack_end(layout, btn[1]));
423
   EXPECT_ERROR_END;
424
   EXPECT_ERROR_START;
425
   ck_assert(!efl_pack(layout, NULL));
426
   EXPECT_ERROR_END;
427
   ck_assert(efl_pack_after(layout, btn[3], btn[1]));
428
   ck_assert_ptr_eq(efl_pack_content_get(layout, 1), btn[3]);
429
   ck_assert_int_eq(efl_pack_index_get(layout, btn[3]), 1);
430
   ck_assert(efl_pack_after(layout, btn[5], NULL));
431
   ck_assert_ptr_eq(efl_pack_content_get(layout, 2), btn[5]);
432
   ck_assert_int_eq(efl_pack_index_get(layout, btn[5]), 2);
433
   ck_assert_ptr_eq(efl_pack_content_get(layout, -1), btn[5]);
434
   ck_assert_int_eq(efl_pack_index_get(layout, btn[5]), 2);
435
   EXPECT_ERROR_START;
436
   ck_assert(!efl_pack_after(layout, btn[5], NULL));
437
   EXPECT_ERROR_END;
438
   EXPECT_ERROR_START;
439
   ck_assert(!efl_pack_after(layout, NULL, btn[5]));
440
   EXPECT_ERROR_END;
441
   ck_assert(efl_pack_before(layout, btn[4], btn[5]));
442
   ck_assert(efl_pack_begin(layout, btn[0]));
443
   ck_assert_ptr_eq(efl_pack_content_get(layout, 0), btn[0]);
444
   ck_assert_int_eq(efl_pack_index_get(layout, btn[0]), 0);
445
   ck_assert(efl_pack_at(layout, btn[2], 2));
446
   ck_assert_ptr_eq(efl_pack_content_get(layout, 2), btn[2]);
447
   ck_assert_int_eq(efl_pack_index_get(layout, btn[2]), 2);
448

449
   ck_assert_int_eq(efl_content_count(layout), BTN_NUM);
450

451
   i = 0;
452
   itr = efl_content_iterate(layout);
453
   EINA_ITERATOR_FOREACH(itr, o)
454
     {
455
        ck_assert_ptr_eq(o, btn[i++]);
456
     }
457
   eina_iterator_free(itr);
458

459
   /* btn array index :  0   1   2   3   4   5
460
    * children  index :  0   1   2   3   4   5
461
    * negative  index : -6  -5  -4  -3  -2  -1
462
    */
463
   //negative index test
464
   for (i = -1; i >= -BTN_NUM; i--)
465
     {
466
        o = efl_pack_content_get(layout, i);
467
        ck_assert_ptr_eq(o, btn[BTN_NUM + i]);
468
        ck_assert_int_eq(efl_pack_index_get(layout, o), BTN_NUM + i);
469
     }
470

471
   //unpack test
472
   ck_assert_ptr_eq(efl_pack_unpack_at(layout, 2), btn[2]);
473
   EXPECT_ERROR_START;
474
   ck_assert(!efl_pack_unpack(layout, btn[2]));
475
   EXPECT_ERROR_END;
476
   efl_pack_at(layout, btn[2], 2);
477
   ck_assert(efl_pack_unpack(layout, efl_pack_content_get(layout, 2)));
478
   EXPECT_ERROR_START;
479
   ck_assert(!efl_pack_unpack(layout, btn[2]));
480
   EXPECT_ERROR_END;
481

482
   efl_pack_at(layout, btn[2], 2);
483
   ck_assert_ptr_eq(efl_pack_unpack_at(layout, efl_pack_index_get(layout, btn[2])), btn[2]);
484

485
   EXPECT_ERROR_START;
486
   ck_assert(!efl_pack_unpack(layout, NULL));
487
   EXPECT_ERROR_END;
488
   ck_assert_int_eq(efl_content_count(layout), BTN_NUM - 1);
489

490
   efl_pack_unpack_all(layout);
491
   ck_assert_int_eq(efl_content_count(layout), 0);
492
   ck_assert(!efl_invalidated_get(btn[0]));
493

494
   for (i = 0; i < BTN_NUM; i++)
495
     efl_pack_end(layout, btn[i]);
496

497
   efl_pack_clear(layout);
498
   ck_assert_int_eq(efl_content_count(layout), 0);
499
   ck_assert(efl_invalidated_get(btn[0]));
500
#undef BTN_NUM
501
}
502
EFL_END_TEST
503

504
EFL_START_TEST (efl_ui_box_properties)
505
{
506
   double h, v;
507
   unsigned int ph, pv;
508

509
   //align test
510
   efl_gfx_arrangement_content_align_get(layout, &h, &v);
511
   ck_assert(EINA_DBL_EQ(h, 0.5));
512
   ck_assert(EINA_DBL_EQ(v, 0.5));
513

514
   efl_gfx_arrangement_content_align_set(layout, 0.3, 0.8234);
515
   efl_gfx_arrangement_content_align_get(layout, &h, &v);
516
   ck_assert(EINA_DBL_EQ(h, 0.3));
517
   ck_assert(EINA_DBL_EQ(v, 0.8234));
518

519
   efl_gfx_arrangement_content_align_set(layout, -0.23, 123);
520
   efl_gfx_arrangement_content_align_get(layout, &h, &v);
521
   ck_assert(EINA_DBL_EQ(h, -1));
522
   ck_assert(EINA_DBL_EQ(v, 1));
523

524
   //padding test
525
   efl_gfx_arrangement_content_padding_get(layout, &ph, &pv);
526
   ck_assert_int_eq(ph, 0.0);
527
   ck_assert_int_eq(pv, 0.0);
528

529
   efl_gfx_arrangement_content_padding_set(layout, 3, 8234);
530
   efl_gfx_arrangement_content_padding_get(layout, &ph, &pv);
531
   ck_assert_int_eq(ph, 3);
532
   ck_assert_int_eq(pv, 8234);
533

534
   //direction test
535
   ck_assert_int_eq(efl_ui_layout_orientation_get(layout), EFL_UI_LAYOUT_ORIENTATION_VERTICAL);
536

537
   efl_ui_layout_orientation_set(layout, EFL_UI_LAYOUT_ORIENTATION_DEFAULT);
538
   ck_assert_int_eq(efl_ui_layout_orientation_get(layout), EFL_UI_LAYOUT_ORIENTATION_VERTICAL);
539

540
   efl_ui_layout_orientation_set(layout, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
541
   ck_assert_int_eq(efl_ui_layout_orientation_get(layout), EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
542

543
   //homogeneous test
544
   ck_assert_int_eq(efl_ui_box_homogeneous_get(layout), 0);
545

546
   efl_ui_box_homogeneous_set(layout, 123);
547
   ck_assert_int_eq(efl_ui_box_homogeneous_get(layout), 1);
548
}
549
EFL_END_TEST
550

551
EFL_START_TEST (efl_ui_box_internal)
552
{
553
   Efl_Ui_Widget *w = efl_add(EFL_UI_BUTTON_CLASS, win);
554

555
   efl_ui_widget_internal_set(layout, EINA_TRUE);
556
   ck_assert_ptr_eq(efl_ui_widget_parent_get(w), win);
557
   efl_pack(layout, w);
558
   ck_assert_ptr_eq(efl_ui_widget_parent_get(w), win);
559
}
560
EFL_END_TEST
561

562
void efl_ui_test_box(TCase *tc)
563
{
564
   tcase_add_checked_fixture(tc, layout_setup, NULL);
565
   tcase_add_test(tc, efl_ui_box_class_check);
566
   tcase_add_test(tc, efl_ui_box_layout_update);
567
   tcase_add_test(tc, efl_ui_box_layout_update_pack);
568
   tcase_add_test(tc, efl_ui_box_size);
569
   tcase_add_test(tc, efl_ui_box_pack_unpack);
570
   tcase_add_test(tc, efl_ui_box_properties);
571
   tcase_add_test(tc, efl_ui_box_internal);
572
}
573