aboutsummaryrefslogtreecommitdiffstats
path: root/src/lib/evas/canvas/evas_box.eo
blob: 36fca8a4dcb0c6068024e5ed6479dcfda4bff4cb (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
type @extern Evas_Object_Box_Data: __undefined_type; [[Evas object box data type]] /* FIXME: Not implemented because annonymous structs are not supported  */
type @extern Evas_Object_Box_Option: __undefined_type; [[Evas object box option type]] /* FIXME: Not implemented because bitfields are not supported. */
type @extern Evas_Object_Box_Layout: __undefined_type; [[Evas object box layout type]] /* FIXME: Function pointers are not supported */
type @extern Eina_Free_Cb: __undefined_type; [[Eina free callback type]] /* FIXME: Function pointers are not supported  */
type @extern va_list: __undefined_type; [[va_list type]] /* FIXME: va_list is not supported */

class Evas.Box (Efl.Canvas.Group.Clipped)
{
   [[Evas box class]]
   legacy_prefix: evas_object_box;
   eo_prefix: evas_obj_box;
   event_prefix: evas_box;
   data: Evas_Object_Box_Data;
   methods {
      @property align {
         set {
            [[Set the alignment of the whole bounding box of contents, for a
              given box object.

              This will influence how a box object is to align its bounding box
              of contents within its own area. The values must be in the range
              $0.0 - $1.0, or undefined behavior is expected. For horizontal
              alignment, $0.0 means to the left, with $1.0 meaning to the
              right. For vertical alignment, $0.0 means to the top, with $1.0
              meaning to the bottom.

              Note: The default values for both alignments is $0.5.

              See also @.align.get.]]
         }
         get {
            [[Get the alignment of the whole bounding box of contents, for a
              given box object.

              See also @.align.set for more information.]]
         }
         values {
            horizontal: double; [[The horizontal alignment, in pixels.]]
            vertical: double; [[The vertical alignment, in pixels.]]
         }
      }
      @property padding {
         set {
            [[Set the (space) padding between cells set for a given box object.

              Note: The default values for both padding components is $0.

              See also @.padding.get.]]
         }
         get {
            [[Get the (space) padding between cells set for a given box object.

              See also @.padding.set.]]
         }
         values {
            horizontal: int; [[The horizontal padding, in pixels.]]
            vertical: int; [[The vertical padding, in pixels.]]
         }
      }
      @property layout {
         set {
            [[Set a new layouting function to a given box object

              A box layout function affects how a box object displays child
              elements within its area. The list of pre-defined box layouts
              available in Evas are @.layout_horizontal, @.layout_vertical,
              @.layout_homogeneous_horizontal, @.layout_homogeneous_vertical,
              @.layout_homogeneous_max_size_horizontal, @.layout_homogeneous_max_size_vertical,
              @.layout_flow_horizontal, @.layout_flow_vertical and @.layout_stack

              Refer to each of their documentation texts for details on them.

              Note: A box layouting function will be triggered by the
              $'calculate' smart callback of the box's smart class.]]
         }
         values {
            cb: Evas_Object_Box_Layout @nonull; [[The new layout function to set on $o.]]
            data: const(void_ptr); [[Data pointer to be passed to $cb.]]
            free_data: Eina_Free_Cb; [[Function to free $data, if need be.]]
         }
      }
      layout_horizontal {
         [[Layout function which sets the box o to a (basic) horizontal box

           In this layout, the box object's overall behavior is controlled by
           its padding/alignment properties, which are set by the
           evas_object_box_{h,v}_{align,padding}_set family of
           functions. The size hints of the elements in the box -- set by the
           evas_object_size_hint_{align,padding,weight}_set functions
           -- also control the way this function works.

           Box's properties:
           $align_h controls the horizontal alignment of the child objects
           relative to the containing box. When set to $0.0, children are
           aligned to the left. A value of $1.0 makes them aligned to the
           right border. Values in between align them proportionally. Note
           that if the size required by the children, which is given by their
           widths and the $padding_h property of the box, is bigger than the
           their container's width, the children will be displayed out of the
           box's bounds. A negative value of $align_h makes the box to
           justify its children. The padding between them, in this case, is
           corrected so that the leftmost one touches the left border and the
           rightmost one touches the right border (even if they must
           overlap). The $align_v and $padding_v properties of the box
           don't contribute to its behaviour when this layout is chosen.

           Child element's properties:
           $align_x does not influence the box's behavior. $padding_l
           and $padding_r sum up to the container's horizontal padding
           between elements. The child's $padding_t, $padding_b and
           $align_y properties apply for padding/alignment relative to the
           overall height of the box. Finally, there is the $weight_x
           property, which, if set to a non-zero value, tells the container
           that the child width is not pre-defined. If the container can't
           accommodate all its children, it sets the widths of the ones
           with weights to sizes as small as they can all fit into
           it. If the size required by the children is less than the
           available, the box increases its childrens' (which have weights)
           widths as to fit the remaining space. The $weight_x property,
           besides telling the element is resizable, gives a weight for the
           resizing process.  The parent box will try to distribute (or take
           off) widths accordingly to the normalized list of weights: most
           weighted children remain/get larger in this process than the least
           ones. $weight_y does not influence the layout.

           If one desires that, besides having weights, child elements must be
           resized bounded to a minimum or maximum size, those size hints must
           be set, by the evas_object_size_hint_{min,max}_set
           functions.]]
         params {
              priv: ptr(Evas_Object_Box_Data); [[Private data pointer]]
              data: void_ptr; [[Data pointer]]
         }
      }
      layout_vertical {
         [[Layout function which sets the box o to a (basic) vertical box

           This function behaves analogously to
           evas_object_box_layout_horizontal. The description of its
           behaviour can be derived from that function's documentation.]]
         params {
              priv: ptr(Evas_Object_Box_Data); [[Private data pointer]]
              data: void_ptr; [[Data pointer]]
         }
      }
      layout_homogeneous_max_size_horizontal {
         [[Layout function which sets the box o to a maximum size,
           homogeneous horizontal box

           In a maximum size, homogeneous horizontal box, besides having cells
           of equal size reserved for the child objects, this size will
           be defined by the size of the largest child in the box (in
           width). The box's overall behavior is controlled by its properties,
           which are set by the
           evas_object_box_{h,v}_{align,padding}_set family of
           functions.  The size hints of the elements in the box -- set by the
           evas_object_size_hint_{align,padding,weight}_set functions
           -- also control the way this function works.

           Box's properties:
           $padding_h tells the box to draw empty spaces of that size, in
           pixels, between the child objects' cells. $align_h controls the
           horizontal alignment of the child objects, relative to the
           containing box. When set to $0.0, children are aligned to the
           left. A value of $1.0 lets them aligned to the right
           border. Values in between align them proportionally. A negative
           value of $align_h makes the box to justify its children
           cells. The padding between them, in this case, is corrected so that
           the leftmost one touches the left border and the rightmost one
           touches the right border (even if they must overlap). The
           $align_v and $padding_v properties of the box don't contribute to
           its behaviour when this layout is chosen.

           Child element's properties:
           $padding_l and $padding_r sum up to the required width of the
           child element. The $align_x property tells the relative position
           of this overall child width in its allocated cell ($0.0 to
           extreme left, $1.0 to extreme right). A value of $-1.0 to
           $align_x makes the box try to resize this child element to the exact
           width of its cell (respecting the minimum and maximum size hints on
           the child's width and accounting for its horizontal padding
           hints). The child's $padding_t, $padding_b and $align_y
           properties apply for padding/alignment relative to the overall
           height of the box. A value of $-1.0 to $align_y makes the box
           try to resize this child element to the exact height of its parent
           (respecting the max hint on the child's height).]]
         params {
              priv: ptr(Evas_Object_Box_Data); [[Private data pointer]]
              data: void_ptr; [[Data pointer]]
         }

      }
      internal_remove {
         [[No description supplied by the EAPI.]]
         return: Efl.Canvas.Object; [[New object with child removed]]
         legacy: null;
         params {
            @in child: Efl.Canvas.Object; [[Child object to be removed]]
         }
      }
      layout_flow_vertical {
         [[Layout function which sets the box o to a flow vertical box.

           This function behaves analogously to
           evas_object_box_layout_flow_horizontal. The description of its
           behaviour can be derived from that function's documentation.]]
         params {
              priv: ptr(Evas_Object_Box_Data); [[Private data pointer]]
              data: void_ptr; [[Data pointer]]
         }
      }
      internal_option_free {
         [[No description supplied by the EAPI.]]
         legacy: null;
         params {
            @in opt: ptr(Evas_Object_Box_Option); [[Box option to be freed]]
         }
      }
      insert_after {
         [[Insert a new child object after another existing one, in
           a given box object o.

           On success, the $"child,added" smart event will take place.

           Note: This function will fail if $reference is not a member of $o.

           Note: The actual placing of the item relative to $o's area will
           depend on the layout set to it.

           Note: This call will trigger the box's
           _Evas_Object_Box_Api.insert_after smart function.]]

         return: ptr(Evas_Object_Box_Option); [[A box option bound to the recently added box item or
                                             $null, on errors]]
         params {
            @in child: Efl.Canvas.Object @nonull; [[A child Evas object to be made a member of $o.]]
            @in reference: const(Efl.Canvas.Object) @nonull; [[The child object to place this new one after.]]
         }
      }
      remove_all {
         [[Remove all child objects from a box object, unparenting them again.

           This has the same effect of calling evas_object_box_remove on
           each of $o's child objects, in sequence. If, and only if, all
           those calls succeed, so does this one.]]

         return: bool; [[$true on success, $false otherwise.]]
         params {
            @in clear: bool; [[If $true, it will delete just removed children.]]
         }
      }
      iterator_new @const {
         [[Get an iterator to walk the list of children of a given box object.

           Note: Do not remove or delete objects while walking the list.]]
         return: free(own(iterator<Efl.Canvas.Object>), eina_iterator_free)
            @warn_unused; [[An iterator on $o's child objects, on success, or $null, on errors.]]
      }
      add_to {
         [[Add a new box as a child of a given smart object.

           This is a helper function that has the same effect of putting a new
           box object into $parent by use of evas_object_smart_member_add.]]

         return: Efl.Canvas.Object @warn_unused; [[$null on error, a pointer to a new box object on
                                               success.]]
      }
      append {
         [[Append a new child object to the given box object o.

           On success, the $"child,added" smart event will take place.

           Note: The actual placing of the item relative to $o's area will
           depend on the layout set to it. For example, on horizontal layouts
           an item in the end of the box's list of children will appear on its
           right.

           Note: This call will trigger the box's _Evas_Object_Box_Api.append
           smart function.]]

         return: ptr(Evas_Object_Box_Option); [[A box option bound to the recently added box item or
                                             $null, on errors.]]
         params {
            @in child: Efl.Canvas.Object @nonull; [[A child Evas object to be made a member of $o.]]
         }
      }
      option_property_id_get @const {
         [[Get the numerical identifier of the property of the child elements
           of the box o which have name as name string

           Note: This call won't do anything for a canonical Evas box. Only
           users which have subclassed it, setting custom box items options
           (see #Evas_Object_Box_Option) on it, would benefit from this
           function. They'd have to implement it and set it to be the
           _Evas_Object_Box_Api.property_id_get smart class function of the
           box, which is originally set to $null.]]
         return: int @warn_unused; [[The numerical ID of the given property or $-1, on
                                     errors.]]
         params {
            @in name: string @nonull; [[The name string of the option being searched, for
                                              its ID.]]
         }
      }
      prepend {
         [[Prepend a new child object to the given box object o.

           On success, the $"child,added" smart event will take place.

           Note: The actual placing of the item relative to $o's area will
           depend on the layout set to it. For example, on horizontal layouts
           an item in the beginning of the box's list of children will appear
           on its left.

           Note: This call will trigger the box's
           _Evas_Object_Box_Api.prepend smart function.]]

         return: ptr(Evas_Object_Box_Option); [[A box option bound to the recently added box item or
                                             $null, on errors.]]
         params {
            @in child: Efl.Canvas.Object @nonull; [[A child Evas object to be made a member of $o.]]
         }
      }
      accessor_new @const {
         [[Get an accessor (a structure providing random items access) to the
           list of children of a given box object.

           Note: Do not remove or delete objects while walking the list.]]
         return: free(own(accessor<Efl.Canvas.Object>), eina_accessor_free)
            @warn_unused; [[An accessor on $o's child objects, on success, or $null,
                            on errors.]]
      }
      internal_append {
         [[No description supplied by the EAPI.]]
         legacy: null;
         return: ptr(Evas_Object_Box_Option); [[Box option]]
         params {
            @in child: Efl.Canvas.Object; [[Child object to be appended]]
         }
      }
      option_property_vset {
         [[Set a property value (by its given numerical identifier), on a
           given box child element -- by a variable argument list

           This is a variable argument list variant of the
           evas_object_box_option_property_set. See its documentation for
           more details.]]

         return: bool; [[$ture on success, $false on failure.]]
         params {
            @in opt: ptr(Evas_Object_Box_Option) @nonull; [[The box option structure bound to the child box element
                                                         to set a property on.]]
            @in property: int; [[The numerical ID of the given property.]]
            @in args: ptr(va_list); [[The variable argument list implementing the value to
                                      be set for this property. It must be of the same type the user has
                                      defined for it.]]
         }
         legacy: null;
      }
      internal_remove_at {
         [[No description supplied by the EAPI.]]
         legacy: null;
         return: Efl.Canvas.Object; [[Canvas object]]
         params {
            @in pos: uint; [[Position of object to be removed]]
         }
      }
      remove_at {
         [[Remove an object, bound to a given position in a box object,
           unparenting it again.

           On removal, you'll get an unparented object again, just as it was
           before you inserted it in the box. The $option_free box smart
           callback will be called automatically for you and, also, the
           $"child,removed" smart event will take place.

           Note: This function will fail if the given position is invalid,
           given $o's internal list of elements.

           Note: This call will trigger the box's
           _Evas_Object_Box_Api.remove_at smart function.]]

         return: bool; [[$ture on success, $false on failure.]]
         params {
            @in pos: uint; [[The numeric position (starting from $0) of the child
                             object to be removed.]]
         }
      }
      option_property_vget @const {
         [[Get a property's value (by its given numerical identifier), on a
           given box child element -- by a variable argument list

           This is a variable argument list variant of the
           evas_object_box_option_property_get. See its documentation for
           more details.]]
         return: bool;  [[$ture on success, $false on failure.]]
         params {
            @in opt: ptr(Evas_Object_Box_Option) @nonull; [[The box option structure bound to the child box element
                                                         to get a property from.]]
            @in property: int; [[The numerical ID of the given property.]]
            @in args: ptr(va_list); [[The variable argument list with pointers to where to
                                      store the values of this property. They must point to variables
                                      of the same type the user has defined for them.]]
         }
         legacy: null;
      }
      internal_insert_at {
         [[No description supplied by the EAPI.]]
         legacy: null;
         return: ptr(Evas_Object_Box_Option); [[Box option]]
         params {
            @in child: Efl.Canvas.Object; [[Child object to be inserted]]
            @in pos: uint; [[Position where the object will be inserted]]
         }
      }
      insert_before {
         [[Insert a new child object before another existing one, in
           a given box object o.

           On success, the $"child,added" smart event will take place.

           Note: This function will fail if $reference is not a member of $o.

           Note: The actual placing of the item relative to $o's area will
           depend on the layout set to it.

           Note: This call will trigger the box's
           _Evas_Object_Box_Api.insert_before smart function.]]

         return: ptr(Evas_Object_Box_Option); [[A box option bound to the recently added box item or
                                             $null, on errors.]]
         params {
            @in child: Efl.Canvas.Object @nonull; [[A child Evas object to be made a member of $o.]]
            @in reference: const(Efl.Canvas.Object) @nonull; [[The child object to place this new one before.]]
         }
      }
      option_property_name_get @const {
         [[Get the name of the property of the child elements of the box o
           which have id as identifier

           Note: This call won't do anything for a canonical Evas box. Only
           users which have subclassed it, setting custom box items options
           (see #Evas_Object_Box_Option) on it, would benefit from this
           function. They'd have to implement it and set it to be the
           _Evas_Object_Box_Api.property_name_get smart class function of the
           box, which is originally set to $null.]]
         return: string @warn_unused; [[The name of the given property or $null, on errors.]]
         params {
            @in property: int; [[The numerical identifier of the option being searched,
                                 for its name.]]
         }
      }
      internal_insert_before {
         [[No description supplied by the EAPI.]]
         legacy: null;
         return: ptr(Evas_Object_Box_Option); [[Box option]]
         params {
            @in child: Efl.Canvas.Object; [[Object to be inserted]]
            @in reference: const(Efl.Canvas.Object); [[Reference where the object will be inserted]]
         }
      }
      layout_homogeneous_horizontal {
         [[Layout function which sets the box o to a homogeneous
           horizontal box

           In a homogeneous horizontal box, its width is divided equally
           between the contained objects. The box's overall behavior is
           controlled by its padding/alignment properties, which are set by
           the evas_object_box_{h,v}_{align,padding}_set family of
           functions.  The size hints the elements in the box -- set by the
           evas_object_size_hint_{align,padding,weight}_set functions
           -- also control the way this function works.

           Box's properties:
           $align_h has no influence on the box for this layout.
           $padding_h tells the box to draw empty spaces of that size, in
           pixels, between the (equal) child objects' cells. The $align_v
           and $padding_v properties of the box don't contribute to its
           behaviour when this layout is chosen.

           Child element's properties:
           $padding_l and $padding_r sum up to the required width of the
           child element. The $align_x property tells the relative position
           of this overall child width in its allocated cell ($0.0 to
           extreme left, $1.0 to extreme right). A value of $-1.0 to
           $align_x makes the box try to resize this child element to the exact
           width of its cell (respecting the minimum and maximum size hints on
           the child's width and accounting for its horizontal padding
           hints). The child's $padding_t, $padding_b and $align_y
           properties apply for padding/alignment relative to the overall
           height of the box. A value of $-1.0 to $align_y makes the box
           try to resize this child element to the exact height of its parent
           (respecting the maximum size hint on the child's height).]]
         params {
            @in priv: ptr(Evas_Object_Box_Data); [[Private data pointer]]
            @in data: void_ptr; [[Data pointer]]
         }
      }
      internal_option_new {
         [[No description supplied by the EAPI.]]
         legacy: null;
         return: ptr(Evas_Object_Box_Option); [[Box option]]
         params {
            @in child: Efl.Canvas.Object; [[New box object]]
         }
      }
      layout_homogeneous_max_size_vertical {
         [[Layout function which sets the box o to a maximum size,
           homogeneous vertical box

           This function behaves analogously to
           evas_object_box_layout_homogeneous_max_size_horizontal. The
           description of its behaviour can be derived from that function's
           documentation.]]
         params {
            @in priv: ptr(Evas_Object_Box_Data); [[Private data pointer]]
            @in data: void_ptr; [[Data pointer]]
         }
      }
      internal_insert_after {
         [[No description supplied by the EAPI.]]
         legacy: null;
         return: ptr(Evas_Object_Box_Option); [[Box option]]
         params {
            @in child: Efl.Canvas.Object; [[Object top be inserted]]
            @in reference: const(Efl.Canvas.Object); [[Reference where the object will be inserted]]
         }
      }
      insert_at {
         [[Insert a new child object at a given position, in a given
           box object $o.

           On success, the $"child,added" smart event will take place.

           Note: This function will fail if the given position is invalid,
           given $o's internal list of elements.

           Note: The actual placing of the item relative to $o's area will
           depend on the layout set to it.

           Note: This call will trigger the box's
           _Evas_Object_Box_Api.insert_at smart function.]]

         return: ptr(Evas_Object_Box_Option); [[A box option bound to the recently added box item or
                                             $null, on errors.]]
         params {
            @in child: Efl.Canvas.Object @nonull; [[A child Evas object to be made a member of $o.]]
            @in pos: uint; [[The numeric position (starting from $0) to place the
                             new child object at.]]
         }
      }
      internal_prepend {
         [[No description supplied by the EAPI.]]
         legacy: null;
         return: ptr(Evas_Object_Box_Option); [[Box option]]
         params {
            @in child: Efl.Canvas.Object; [[Object to be prepended]]
         }
      }
      remove {
         [[Remove a given object from a box object, unparenting it again.

           On removal, you'll get an unparented object again, just as it was
           before you inserted it in the box. The
           _Evas_Object_Box_Api.option_free box smart callback will be called
           automatically for you and, also, the $"child,removed" smart event
           will take place.

           Note: This call will trigger the box's _Evas_Object_Box_Api.remove
           smart function.]]

         return: bool; [[$true on success, $false otherwise.]]
         params {
            @in child: Efl.Canvas.Object @nonull; [[The handle to the child object to be removed.]]
         }
      }
      layout_stack {
         [[Layout function which sets the box o to a stacking box

           In a stacking box, all children will be given the same size -- the
           box's own size -- and they will be stacked one above the other, so
           that the first object in $o's internal list of child elements
           will be the bottommost in the stack.

           Box's properties:
           No box properties are used.

           Child element's properties:
           $padding_l and $padding_r sum up to the required width of the
           child element. The $align_x property tells the relative position
           of this overall child width in its allocated cell ($0.0 to
           extreme left, $1.0 to extreme right). A value of $-1.0 to
           $align_x makes the box try to resize this child element to the exact
           width of its cell (respecting the min and max hints on the child's
           width and accounting for its horizontal padding properties). The
           same applies to the vertical axis.]]
         params {
            @in priv: ptr(Evas_Object_Box_Data); [[Private data pointer]]
            @in data: void_ptr; [[Data pointer]]
         }
      }
      layout_homogeneous_vertical {
         [[Layout function which sets the box o to a homogeneous
           vertical box.

           This function behaves analogously to
           evas_object_box_layout_homogeneous_horizontal.  The description
           of its behaviour can be derived from that function's documentation.]]
         params {
              priv: ptr(Evas_Object_Box_Data); [[Private data pointer]]
              data: void_ptr; [[Data pointer]]
         }
      }
      layout_flow_horizontal {
         [[Layout function which sets the box o to a flow horizontal
           box.

           In a flow horizontal box, the box's child elements are placed in
           rows (think of text as an analogy). A row has as much elements as
           can fit into the box's width. The box's overall behavior is
           controlled by its properties, which are set by the
           evas_object_box_{h,v}_{align,padding}_set family of
           functions.  The size hints of the elements in the box -- set by the
           evas_object_size_hint_{align,padding,weight}_set functions
           -- also control the way this function works.

           Box's properties:
           $padding_h tells the box to draw empty spaces of that size, in
           pixels, between the child objects' cells. $align_h dictates the
           horizontal alignment of the rows ($0.0 to left align them, $1.0
           to right align). A value of $-1.0 to $align_h lets the rows
           justified horizontally. $align_v controls the vertical alignment
           of the entire set of rows ($0.0 to top, $1.0 to bottom). A
           value of $-1.0 to $align_v makes the box to justify the rows
           vertically. The padding between them, in this case, is corrected so
           that the first row touches the top border and the last one touches
           the bottom border (even if they must overlap). $padding_v has no
           influence on the layout.

           Child element's properties:
           $padding_l and $padding_r sum up to the required width of the
           child element. The $align_x property has no influence on the
           layout. The child's $padding_t and $padding_b sum up to the
           required height of the child element and is the only means (besides
           row justifying) of setting space between rows. Note, however, that
           $align_y dictates positioning relative to the largest
           height required by a child object in the actual row.]]
         params {
              priv: ptr(Evas_Object_Box_Data); [[Private data pointer]]
              data: void_ptr; [[Data pointer]]
         }
      }
      count {
         [[Returns the number of items in the box.]]
         legacy: null;
         return: int; [[Number of items in the box]]
      }
   }
   implements {
      class.constructor;
      Efl.Object.constructor;
      Efl.Gfx.size { set; }
      Efl.Gfx.position { set; }
      Efl.Canvas.Group.group_calculate;
   }
   events {
      child,added; [[Called when a child object was added to the box]]
      child,removed; [[Called when a child object was removed from the box]]
   }
}