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