class Evas.Box (Evas.Smart_Clipped)
{
   legacy_prefix: evas_object_box;
   eo_prefix: evas_obj_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: Evas.Coord; [[The horizontal padding, in pixels.]]
            vertical: Evas.Coord; [[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)*; [[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: Evas_Object_Box_Data *;
              data: void *;
         }
      }
      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: Evas_Object_Box_Data *;
              data: void *;
         }
      }
      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: Evas_Object_Box_Data *;
              data: void *;
         }

      }
      internal_remove {
         [[No description supplied by the EAPI.]]
         return: Evas.Object *;
         legacy: null;
         params {
            @in child: Evas.Object *;
         }
      }
      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: Evas_Object_Box_Data *;
              data: void *;
         }
      }
      internal_option_free {
         [[No description supplied by the EAPI.]]
         legacy: null;
         params {
            @in opt: Evas_Object_Box_Option *;
         }
      }
      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: Evas_Object_Box_Option *; [[A box option bound to the recently added box item or
                                             $null, on errors]]
         params {
            @in child: Evas.Object * @nonull; [[A child Evas object to be made a member of $o.]]
            @in reference: const(Evas.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<Evas.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: Evas.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: Evas_Object_Box_Option *; [[A box option bound to the recently added box item or
                                             $null, on errors.]]
         params {
            @in child: Evas.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: const(char)* @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: Evas_Object_Box_Option *; [[A box option bound to the recently added box item or
                                             $null, on errors.]]
         params {
            @in child: Evas.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<Evas.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: Evas_Object_Box_Option *;
         params {
            @in child: Evas.Object *;
         }
      }
      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: 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: 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: Evas.Object *;
         params {
            @in pos: uint;
         }
      }
      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: 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: 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: Evas_Object_Box_Option *;
         params {
            @in child: Evas.Object *;
            @in pos: uint;
         }
      }
      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: Evas_Object_Box_Option *; [[A box option bound to the recently added box item or
                                             $null, on errors.]]
         params {
            @in child: Evas.Object * @nonull; [[A child Evas object to be made a member of $o.]]
            @in reference: const(Evas.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: const(char)* @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: Evas_Object_Box_Option *;
         params {
            @in child: Evas.Object *;
            @in reference: const(Evas.Object)*;
         }
      }
      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: Evas_Object_Box_Data *;
            @in data: void *;
         }
      }
      internal_option_new {
         [[No description supplied by the EAPI.]]
         legacy: null;
         return: Evas_Object_Box_Option*;
         params {
            @in child: Evas.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: Evas_Object_Box_Data *;
            @in data: void *;
         }
      }
      internal_insert_after {
         [[No description supplied by the EAPI.]]
         legacy: null;
         return: Evas_Object_Box_Option *;
         params {
            @in child: Evas.Object *;
            @in reference: const(Evas.Object)*;
         }
      }
      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: Evas_Object_Box_Option *; [[A box option bound to the recently added box item or
                                             $null, on errors.]]
         params {
            @in child: Evas.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: Evas_Object_Box_Option*;
         params {
            @in child: Evas.Object *;
         }
      }
      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: Evas.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: Evas_Object_Box_Data *;
            @in data: void *;
         }
      }
      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: Evas_Object_Box_Data *;
              data: void *;
         }
      }
      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: Evas_Object_Box_Data *;
              data: void *;
         }

      }
   }
   implements {
      class.constructor;
      Eo.Base.constructor;
      Evas.Object.smart_data.get;
      Evas.Object_Smart.calculate;
      Evas.Object_Smart.add;
      Evas.Object_Smart.del;
      Evas.Object_Smart.resize;
   }
   events {
      child,added;
      child,removed;
   }

}
