summaryrefslogtreecommitdiff
path: root/src/lib/evas/canvas/evas_box_eo.legacy.h
diff options
context:
space:
mode:
Diffstat (limited to 'src/lib/evas/canvas/evas_box_eo.legacy.h')
-rw-r--r--src/lib/evas/canvas/evas_box_eo.legacy.h646
1 files changed, 646 insertions, 0 deletions
diff --git a/src/lib/evas/canvas/evas_box_eo.legacy.h b/src/lib/evas/canvas/evas_box_eo.legacy.h
new file mode 100644
index 0000000..ba67589
--- /dev/null
+++ b/src/lib/evas/canvas/evas_box_eo.legacy.h
@@ -0,0 +1,646 @@
1#ifndef _EVAS_BOX_EO_LEGACY_H_
2#define _EVAS_BOX_EO_LEGACY_H_
3
4#ifndef _EVAS_BOX_EO_CLASS_TYPE
5#define _EVAS_BOX_EO_CLASS_TYPE
6
7typedef Eo Evas_Box;
8
9#endif
10
11#ifndef _EVAS_BOX_EO_TYPES
12#define _EVAS_BOX_EO_TYPES
13
14
15#endif
16
17/**
18 * @brief Set the alignment of the whole bounding box of contents, for a given
19 * box object.
20 *
21 * This will influence how a box object is to align its bounding box of
22 * contents within its own area. The values must be in the range $0.0 - $1.0,
23 * or undefined behavior is expected. For horizontal alignment, $0.0 means to
24 * the left, with $1.0 meaning to the right. For vertical alignment, $0.0 means
25 * to the top, with $1.0 meaning to the bottom.
26 *
27 * @note The default values for both alignments is $0.5.
28 *
29 * See also @ref evas_object_box_align_get.
30 *
31 * @param[in] obj The object.
32 * @param[in] horizontal The horizontal alignment, in pixels.
33 * @param[in] vertical The vertical alignment, in pixels.
34 *
35 * @ingroup Evas_Object_Box_Group
36 */
37EAPI void evas_object_box_align_set(Evas_Box *obj, double horizontal, double vertical);
38
39/**
40 * @brief Get the alignment of the whole bounding box of contents, for a given
41 * box object.
42 *
43 * See also @ref evas_object_box_align_set for more information.
44 *
45 * @param[in] obj The object.
46 * @param[out] horizontal The horizontal alignment, in pixels.
47 * @param[out] vertical The vertical alignment, in pixels.
48 *
49 * @ingroup Evas_Object_Box_Group
50 */
51EAPI void evas_object_box_align_get(const Evas_Box *obj, double *horizontal, double *vertical);
52
53/**
54 * @brief Set the (space) padding between cells set for a given box object.
55 *
56 * @note The default values for both padding components is $0.
57 *
58 * See also @ref evas_object_box_padding_get.
59 *
60 * @param[in] obj The object.
61 * @param[in] horizontal The horizontal padding, in pixels.
62 * @param[in] vertical The vertical padding, in pixels.
63 *
64 * @ingroup Evas_Object_Box_Group
65 */
66EAPI void evas_object_box_padding_set(Evas_Box *obj, int horizontal, int vertical);
67
68/**
69 * @brief Get the (space) padding between cells set for a given box object.
70 *
71 * See also @ref evas_object_box_padding_set.
72 *
73 * @param[in] obj The object.
74 * @param[out] horizontal The horizontal padding, in pixels.
75 * @param[out] vertical The vertical padding, in pixels.
76 *
77 * @ingroup Evas_Object_Box_Group
78 */
79EAPI void evas_object_box_padding_get(const Evas_Box *obj, int *horizontal, int *vertical);
80
81/**
82 * @brief Set a new layouting function to a given box object
83 *
84 * A box layout function affects how a box object displays child elements
85 * within its area. The list of pre-defined box layouts available in Evas are
86 * @ref evas_object_box_layout_horizontal,
87 * @ref evas_object_box_layout_vertical,
88 * @ref evas_object_box_layout_homogeneous_horizontal,
89 * @ref evas_object_box_layout_homogeneous_vertical,
90 * @ref evas_object_box_layout_homogeneous_max_size_horizontal,
91 * @ref evas_object_box_layout_homogeneous_max_size_vertical,
92 * @ref evas_object_box_layout_flow_horizontal,
93 * @ref evas_object_box_layout_flow_vertical and
94 * @ref evas_object_box_layout_stack
95 *
96 * Refer to each of their documentation texts for details on them.
97 *
98 * @note A box layouting function will be triggered by the $'calculate' smart
99 * callback of the box's smart class.
100 *
101 * @param[in] obj The object.
102 * @param[in] cb The new layout function to set on @c o.
103 * @param[in] data Data pointer to be passed to @c cb.
104 * @param[in] free_data Function to free @c data, if need be.
105 *
106 * @ingroup Evas_Object_Box_Group
107 */
108EAPI void evas_object_box_layout_set(Evas_Box *obj, Evas_Object_Box_Layout cb, const void *data, Eina_Free_Cb free_data) EINA_ARG_NONNULL(2);
109
110/**
111 * @brief Layout function which sets the box o to a (basic) horizontal box
112 *
113 * In this layout, the box object's overall behavior is controlled by its
114 * padding/alignment properties, which are set by the
115 * evas_object_box_{h,v}_{align,padding}_set family of functions. The size
116 * hints of the elements in the box -- set by the
117 * evas_object_size_hint_{align,padding,weight}_set functions -- also control
118 * the way this function works.
119 *
120 * Box's properties: @c align_h controls the horizontal alignment of the child
121 * objects relative to the containing box. When set to $0.0, children are
122 * aligned to the left. A value of $1.0 makes them aligned to the right border.
123 * Values in between align them proportionally. Note that if the size required
124 * by the children, which is given by their widths and the @c padding_h
125 * property of the box, is bigger than the their container's width, the
126 * children will be displayed out of the box's bounds. A negative value of
127 * @c align_h makes the box to justify its children. The padding between them,
128 * in this case, is corrected so that the leftmost one touches the left border
129 * and the rightmost one touches the right border (even if they must overlap).
130 * The @c align_v and @c padding_v properties of the box don't contribute to
131 * its behaviour when this layout is chosen.
132 *
133 * Child element's properties: @c align_x does not influence the box's
134 * behavior. @c padding_l and @c padding_r sum up to the container's horizontal
135 * padding between elements. The child's @c padding_t, @c padding_b and
136 * @c align_y properties apply for padding/alignment relative to the overall
137 * height of the box. Finally, there is the @c weight_x property, which, if set
138 * to a non-zero value, tells the container that the child width is not
139 * pre-defined. If the container can't accommodate all its children, it sets
140 * the widths of the ones with weights to sizes as small as they can all fit
141 * into it. If the size required by the children is less than the available,
142 * the box increases its childrens' (which have weights) widths as to fit the
143 * remaining space. The @c weight_x property, besides telling the element is
144 * resizable, gives a weight for the resizing process. The parent box will try
145 * to distribute (or take off) widths accordingly to the normalized list of
146 * weights: most weighted children remain/get larger in this process than the
147 * least ones. @c weight_y does not influence the layout.
148 *
149 * If one desires that, besides having weights, child elements must be resized
150 * bounded to a minimum or maximum size, those size hints must be set, by the
151 * evas_object_size_hint_{min,max}_set functions.
152 *
153 * @param[in] obj The object.
154 * @param[in] priv Private data pointer
155 * @param[in] data Data pointer
156 *
157 * @ingroup Evas_Object_Box_Group
158 */
159EAPI void evas_object_box_layout_horizontal(Evas_Box *obj, Evas_Object_Box_Data *priv, void *data);
160
161/**
162 * @brief Layout function which sets the box o to a (basic) vertical box
163 *
164 * This function behaves analogously to evas_object_box_layout_horizontal. The
165 * description of its behaviour can be derived from that function's
166 * documentation.
167 *
168 * @param[in] obj The object.
169 * @param[in] priv Private data pointer
170 * @param[in] data Data pointer
171 *
172 * @ingroup Evas_Object_Box_Group
173 */
174EAPI void evas_object_box_layout_vertical(Evas_Box *obj, Evas_Object_Box_Data *priv, void *data);
175
176/**
177 * @brief Layout function which sets the box o to a maximum size, homogeneous
178 * horizontal box
179 *
180 * In a maximum size, homogeneous horizontal box, besides having cells of equal
181 * size reserved for the child objects, this size will be defined by the size
182 * of the largest child in the box (in width). The box's overall behavior is
183 * controlled by its properties, which are set by the
184 * evas_object_box_{h,v}_{align,padding}_set family of functions. The size
185 * hints of the elements in the box -- set by the
186 * evas_object_size_hint_{align,padding,weight}_set functions -- also control
187 * the way this function works.
188 *
189 * Box's properties: @c padding_h tells the box to draw empty spaces of that
190 * size, in pixels, between the child objects' cells. @c align_h controls the
191 * horizontal alignment of the child objects, relative to the containing box.
192 * When set to $0.0, children are aligned to the left. A value of $1.0 lets
193 * them aligned to the right border. Values in between align them
194 * proportionally. A negative value of @c align_h makes the box to justify its
195 * children cells. The padding between them, in this case, is corrected so that
196 * the leftmost one touches the left border and the rightmost one touches the
197 * right border (even if they must overlap). The @c align_v and @c padding_v
198 * properties of the box don't contribute to its behaviour when this layout is
199 * chosen.
200 *
201 * Child element's properties: @c padding_l and @c padding_r sum up to the
202 * required width of the child element. The @c align_x property tells the
203 * relative position of this overall child width in its allocated cell ($0.0 to
204 * extreme left, $1.0 to extreme right). A value of $-1.0 to @c align_x makes
205 * the box try to resize this child element to the exact width of its cell
206 * (respecting the minimum and maximum size hints on the child's width and
207 * accounting for its horizontal padding hints). The child's @c padding_t,
208 * @c padding_b and @c align_y properties apply for padding/alignment relative
209 * to the overall height of the box. A value of $-1.0 to @c align_y makes the
210 * box try to resize this child element to the exact height of its parent
211 * (respecting the max hint on the child's height).
212 *
213 * @param[in] obj The object.
214 * @param[in] priv Private data pointer
215 * @param[in] data Data pointer
216 *
217 * @ingroup Evas_Object_Box_Group
218 */
219EAPI void evas_object_box_layout_homogeneous_max_size_horizontal(Evas_Box *obj, Evas_Object_Box_Data *priv, void *data);
220
221
222/**
223 * @brief Layout function which sets the box o to a flow vertical box.
224 *
225 * This function behaves analogously to evas_object_box_layout_flow_horizontal.
226 * The description of its behaviour can be derived from that function's
227 * documentation.
228 *
229 * @param[in] obj The object.
230 * @param[in] priv Private data pointer
231 * @param[in] data Data pointer
232 *
233 * @ingroup Evas_Object_Box_Group
234 */
235EAPI void evas_object_box_layout_flow_vertical(Evas_Box *obj, Evas_Object_Box_Data *priv, void *data);
236
237
238/**
239 * @brief Insert a new child object after another existing one, in a given box
240 * object o.
241 *
242 * On success, the $"child,added" smart event will take place.
243 *
244 * @note This function will fail if @c reference is not a member of @c o.
245 *
246 * @note The actual placing of the item relative to @c o's area will depend on
247 * the layout set to it.
248 *
249 * @note This call will trigger the box's _Evas_Object_Box_Api.insert_after
250 * smart function.
251 *
252 * @param[in] obj The object.
253 * @param[in] child A child Evas object to be made a member of @c o.
254 * @param[in] reference The child object to place this new one after.
255 *
256 * @return A box option bound to the recently added box item or @c null, on
257 * errors
258 *
259 * @ingroup Evas_Object_Box_Group
260 */
261EAPI Evas_Object_Box_Option *evas_object_box_insert_after(Evas_Box *obj, Efl_Canvas_Object *child, const Efl_Canvas_Object *reference) EINA_ARG_NONNULL(2, 3);
262
263/**
264 * @brief Remove all child objects from a box object, unparenting them again.
265 *
266 * This has the same effect of calling evas_object_box_remove on each of @c o's
267 * child objects, in sequence. If, and only if, all those calls succeed, so
268 * does this one.
269 *
270 * @param[in] obj The object.
271 * @param[in] clear If @c true, it will delete just removed children.
272 *
273 * @return @c true on success, @c false otherwise.
274 *
275 * @ingroup Evas_Object_Box_Group
276 */
277EAPI Eina_Bool evas_object_box_remove_all(Evas_Box *obj, Eina_Bool clear);
278
279/**
280 * @brief Get an iterator to walk the list of children of a given box object.
281 *
282 * @note Do not remove or delete objects while walking the list.
283 *
284 * @param[in] obj The object.
285 *
286 * @return An iterator on @c o's child objects, on success, or @c null, on
287 * errors.
288 *
289 * @ingroup Evas_Object_Box_Group
290 */
291EAPI Eina_Iterator *evas_object_box_iterator_new(const Evas_Box *obj) EINA_WARN_UNUSED_RESULT;
292
293/**
294 * @brief Add a new box as a child of a given smart object.
295 *
296 * This is a helper function that has the same effect of putting a new box
297 * object into @c parent by use of evas_object_smart_member_add.
298 *
299 * @param[in] obj The object.
300 *
301 * @return @c null on error, a pointer to a new box object on success.
302 *
303 * @ingroup Evas_Object_Box_Group
304 */
305EAPI Efl_Canvas_Object *evas_object_box_add_to(Evas_Box *obj) EINA_WARN_UNUSED_RESULT;
306
307/**
308 * @brief Append a new child object to the given box object o.
309 *
310 * On success, the $"child,added" smart event will take place.
311 *
312 * @note The actual placing of the item relative to @c o's area will depend on
313 * the layout set to it. For example, on horizontal layouts an item in the end
314 * of the box's list of children will appear on its right.
315 *
316 * @note This call will trigger the box's _Evas_Object_Box_Api.append smart
317 * function.
318 *
319 * @param[in] obj The object.
320 * @param[in] child A child Evas object to be made a member of @c o.
321 *
322 * @return A box option bound to the recently added box item or @c null, on
323 * errors.
324 *
325 * @ingroup Evas_Object_Box_Group
326 */
327EAPI Evas_Object_Box_Option *evas_object_box_append(Evas_Box *obj, Efl_Canvas_Object *child) EINA_ARG_NONNULL(2);
328
329/**
330 * @brief Get the numerical identifier of the property of the child elements of
331 * the box o which have name as name string
332 *
333 * @note This call won't do anything for a canonical Evas box. Only users which
334 * have subclassed it, setting custom box items options (see
335 * #Evas_Object_Box_Option) on it, would benefit from this function. They'd
336 * have to implement it and set it to be the
337 * _Evas_Object_Box_Api.property_id_get smart class function of the box, which
338 * is originally set to @c null.
339 *
340 * @param[in] obj The object.
341 * @param[in] name The name string of the option being searched, for its ID.
342 *
343 * @return The numerical ID of the given property or $-1, on errors.
344 *
345 * @ingroup Evas_Object_Box_Group
346 */
347EAPI int evas_object_box_option_property_id_get(const Evas_Box *obj, const char *name) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(2);
348
349/**
350 * @brief Prepend a new child object to the given box object o.
351 *
352 * On success, the $"child,added" smart event will take place.
353 *
354 * @note The actual placing of the item relative to @c o's area will depend on
355 * the layout set to it. For example, on horizontal layouts an item in the
356 * beginning of the box's list of children will appear on its left.
357 *
358 * @note This call will trigger the box's _Evas_Object_Box_Api.prepend smart
359 * function.
360 *
361 * @param[in] obj The object.
362 * @param[in] child A child Evas object to be made a member of @c o.
363 *
364 * @return A box option bound to the recently added box item or @c null, on
365 * errors.
366 *
367 * @ingroup Evas_Object_Box_Group
368 */
369EAPI Evas_Object_Box_Option *evas_object_box_prepend(Evas_Box *obj, Efl_Canvas_Object *child) EINA_ARG_NONNULL(2);
370
371/**
372 * @brief Get an accessor (a structure providing random items access) to the
373 * list of children of a given box object.
374 *
375 * @note Do not remove or delete objects while walking the list.
376 *
377 * @param[in] obj The object.
378 *
379 * @return An accessor on @c o's child objects, on success, or @c null, on
380 * errors.
381 *
382 * @ingroup Evas_Object_Box_Group
383 */
384EAPI Eina_Accessor *evas_object_box_accessor_new(const Evas_Box *obj) EINA_WARN_UNUSED_RESULT;
385
386
387
388
389/**
390 * @brief Remove an object, bound to a given position in a box object,
391 * unparenting it again.
392 *
393 * On removal, you'll get an unparented object again, just as it was before you
394 * inserted it in the box. The @c option_free box smart callback will be called
395 * automatically for you and, also, the $"child,removed" smart event will take
396 * place.
397 *
398 * @note This function will fail if the given position is invalid, given @c o's
399 * internal list of elements.
400 *
401 * @note This call will trigger the box's _Evas_Object_Box_Api.remove_at smart
402 * function.
403 *
404 * @param[in] obj The object.
405 * @param[in] pos The numeric position (starting from $0) of the child object
406 * to be removed.
407 *
408 * @return @c true on success, @c false on failure.
409 *
410 * @ingroup Evas_Object_Box_Group
411 */
412EAPI Eina_Bool evas_object_box_remove_at(Evas_Box *obj, unsigned int pos);
413
414
415
416/**
417 * @brief Insert a new child object before another existing one, in a given box
418 * object o.
419 *
420 * On success, the $"child,added" smart event will take place.
421 *
422 * @note This function will fail if @c reference is not a member of @c o.
423 *
424 * @note The actual placing of the item relative to @c o's area will depend on
425 * the layout set to it.
426 *
427 * @note This call will trigger the box's _Evas_Object_Box_Api.insert_before
428 * smart function.
429 *
430 * @param[in] obj The object.
431 * @param[in] child A child Evas object to be made a member of @c o.
432 * @param[in] reference The child object to place this new one before.
433 *
434 * @return A box option bound to the recently added box item or @c null, on
435 * errors.
436 *
437 * @ingroup Evas_Object_Box_Group
438 */
439EAPI Evas_Object_Box_Option *evas_object_box_insert_before(Evas_Box *obj, Efl_Canvas_Object *child, const Efl_Canvas_Object *reference) EINA_ARG_NONNULL(2, 3);
440
441/**
442 * @brief Get the name of the property of the child elements of the box o which
443 * have id as identifier
444 *
445 * @note This call won't do anything for a canonical Evas box. Only users which
446 * have subclassed it, setting custom box items options (see
447 * #Evas_Object_Box_Option) on it, would benefit from this function. They'd
448 * have to implement it and set it to be the
449 * _Evas_Object_Box_Api.property_name_get smart class function of the box,
450 * which is originally set to @c null.
451 *
452 * @param[in] obj The object.
453 * @param[in] property The numerical identifier of the option being searched,
454 * for its name.
455 *
456 * @return The name of the given property or @c null, on errors.
457 *
458 * @ingroup Evas_Object_Box_Group
459 */
460EAPI const char *evas_object_box_option_property_name_get(const Evas_Box *obj, int property) EINA_WARN_UNUSED_RESULT;
461
462
463/**
464 * @brief Layout function which sets the box o to a homogeneous horizontal box
465 *
466 * In a homogeneous horizontal box, its width is divided equally between the
467 * contained objects. The box's overall behavior is controlled by its
468 * padding/alignment properties, which are set by the
469 * evas_object_box_{h,v}_{align,padding}_set family of functions. The size
470 * hints the elements in the box -- set by the
471 * evas_object_size_hint_{align,padding,weight}_set functions -- also control
472 * the way this function works.
473 *
474 * Box's properties: @c align_h has no influence on the box for this layout.
475 * @c padding_h tells the box to draw empty spaces of that size, in pixels,
476 * between the (equal) child objects' cells. The @c align_v and @c padding_v
477 * properties of the box don't contribute to its behaviour when this layout is
478 * chosen.
479 *
480 * Child element's properties: @c padding_l and @c padding_r sum up to the
481 * required width of the child element. The @c align_x property tells the
482 * relative position of this overall child width in its allocated cell ($0.0 to
483 * extreme left, $1.0 to extreme right). A value of $-1.0 to @c align_x makes
484 * the box try to resize this child element to the exact width of its cell
485 * (respecting the minimum and maximum size hints on the child's width and
486 * accounting for its horizontal padding hints). The child's @c padding_t,
487 * @c padding_b and @c align_y properties apply for padding/alignment relative
488 * to the overall height of the box. A value of $-1.0 to @c align_y makes the
489 * box try to resize this child element to the exact height of its parent
490 * (respecting the maximum size hint on the child's height).
491 *
492 * @param[in] obj The object.
493 * @param[in] priv Private data pointer
494 * @param[in] data Data pointer
495 *
496 * @ingroup Evas_Object_Box_Group
497 */
498EAPI void evas_object_box_layout_homogeneous_horizontal(Evas_Box *obj, Evas_Object_Box_Data *priv, void *data);
499
500
501/**
502 * @brief Layout function which sets the box o to a maximum size, homogeneous
503 * vertical box
504 *
505 * This function behaves analogously to
506 * evas_object_box_layout_homogeneous_max_size_horizontal. The description of
507 * its behaviour can be derived from that function's documentation.
508 *
509 * @param[in] obj The object.
510 * @param[in] priv Private data pointer
511 * @param[in] data Data pointer
512 *
513 * @ingroup Evas_Object_Box_Group
514 */
515EAPI void evas_object_box_layout_homogeneous_max_size_vertical(Evas_Box *obj, Evas_Object_Box_Data *priv, void *data);
516
517
518/**
519 * @brief Insert a new child object at a given position, in a given box object
520 * @c o.
521 *
522 * On success, the $"child,added" smart event will take place.
523 *
524 * @note This function will fail if the given position is invalid, given @c o's
525 * internal list of elements.
526 *
527 * @note The actual placing of the item relative to @c o's area will depend on
528 * the layout set to it.
529 *
530 * @note This call will trigger the box's _Evas_Object_Box_Api.insert_at smart
531 * function.
532 *
533 * @param[in] obj The object.
534 * @param[in] child A child Evas object to be made a member of @c o.
535 * @param[in] pos The numeric position (starting from $0) to place the new
536 * child object at.
537 *
538 * @return A box option bound to the recently added box item or @c null, on
539 * errors.
540 *
541 * @ingroup Evas_Object_Box_Group
542 */
543EAPI Evas_Object_Box_Option *evas_object_box_insert_at(Evas_Box *obj, Efl_Canvas_Object *child, unsigned int pos) EINA_ARG_NONNULL(2);
544
545
546/**
547 * @brief Remove a given object from a box object, unparenting it again.
548 *
549 * On removal, you'll get an unparented object again, just as it was before you
550 * inserted it in the box. The _Evas_Object_Box_Api.option_free box smart
551 * callback will be called automatically for you and, also, the
552 * $"child,removed" smart event will take place.
553 *
554 * @note This call will trigger the box's _Evas_Object_Box_Api.remove smart
555 * function.
556 *
557 * @param[in] obj The object.
558 * @param[in] child The handle to the child object to be removed.
559 *
560 * @return @c true on success, @c false otherwise.
561 *
562 * @ingroup Evas_Object_Box_Group
563 */
564EAPI Eina_Bool evas_object_box_remove(Evas_Box *obj, Efl_Canvas_Object *child) EINA_ARG_NONNULL(2);
565
566/**
567 * @brief Layout function which sets the box o to a stacking box
568 *
569 * In a stacking box, all children will be given the same size -- the box's own
570 * size -- and they will be stacked one above the other, so that the first
571 * object in @c o's internal list of child elements will be the bottommost in
572 * the stack.
573 *
574 * Box's properties: No box properties are used.
575 *
576 * Child element's properties: @c padding_l and @c padding_r sum up to the
577 * required width of the child element. The @c align_x property tells the
578 * relative position of this overall child width in its allocated cell ($0.0 to
579 * extreme left, $1.0 to extreme right). A value of $-1.0 to @c align_x makes
580 * the box try to resize this child element to the exact width of its cell
581 * (respecting the min and max hints on the child's width and accounting for
582 * its horizontal padding properties). The same applies to the vertical axis.
583 *
584 * @param[in] obj The object.
585 * @param[in] priv Private data pointer
586 * @param[in] data Data pointer
587 *
588 * @ingroup Evas_Object_Box_Group
589 */
590EAPI void evas_object_box_layout_stack(Evas_Box *obj, Evas_Object_Box_Data *priv, void *data);
591
592/**
593 * @brief Layout function which sets the box o to a homogeneous vertical box.
594 *
595 * This function behaves analogously to
596 * evas_object_box_layout_homogeneous_horizontal. The description of its
597 * behaviour can be derived from that function's documentation.
598 *
599 * @param[in] obj The object.
600 * @param[in] priv Private data pointer
601 * @param[in] data Data pointer
602 *
603 * @ingroup Evas_Object_Box_Group
604 */
605EAPI void evas_object_box_layout_homogeneous_vertical(Evas_Box *obj, Evas_Object_Box_Data *priv, void *data);
606
607/**
608 * @brief Layout function which sets the box o to a flow horizontal box.
609 *
610 * In a flow horizontal box, the box's child elements are placed in rows (think
611 * of text as an analogy). A row has as many elements as can fit into the box's
612 * width. The box's overall behavior is controlled by its properties, which are
613 * set by the evas_object_box_{h,v}_{align,padding}_set family of functions.
614 * The size hints of the elements in the box -- set by the
615 * evas_object_size_hint_{align,padding,weight}_set functions -- also control
616 * the way this function works.
617 *
618 * Box's properties: @c padding_h tells the box to draw empty spaces of that
619 * size, in pixels, between the child objects' cells. @c align_h dictates the
620 * horizontal alignment of the rows ($0.0 to left align them, $1.0 to right
621 * align). A value of $-1.0 to @c align_h lets the rows justified horizontally.
622 * @c align_v controls the vertical alignment of the entire set of rows ($0.0
623 * to top, $1.0 to bottom). A value of $-1.0 to @c align_v makes the box to
624 * justify the rows vertically. The padding between them in this case is
625 * corrected so that the first row touches the top border and the last one
626 * touches the bottom border (even if they must overlap). @c padding_v has no
627 * influence on the layout.
628 *
629 * Child element's properties: @c padding_l and @c padding_r sum up to the
630 * required width of the child element. The @c align_x property has no
631 * influence on the layout. The child's @c padding_t and @c padding_b sum up to
632 * the required height of the child element and is the only means (besides row
633 * justifying) of setting space between rows. Note, however, that @c align_y
634 * dictates positioning relative to the largest height required by a child
635 * object in the actual row.
636 *
637 * @param[in] obj The object.
638 * @param[in] priv Private data pointer
639 * @param[in] data Data pointer
640 *
641 * @ingroup Evas_Object_Box_Group
642 */
643EAPI void evas_object_box_layout_flow_horizontal(Evas_Box *obj, Evas_Object_Box_Data *priv, void *data);
644
645
646#endif