#ifndef EFL_GENERATED_EVAS_BOX_HH
#define EFL_GENERATED_EVAS_BOX_HH

extern "C"
{
#include <Efl.h>
}
#include <Eo.hh>

#include <eo_cxx_interop.hh>

extern "C"
{
#include "evas_box.eo.h"
}

#include "evas_smart_clipped.eo.hh"
#include <canvas/evas_object.eo.hh>
#include <string>

namespace evas {

struct box;

}

/// @cond EO_CXX_ABSTRACT
namespace eo_cxx {

namespace evas {

struct box
{
   /// @brief Layout function which sets the box @a 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
   /// <c>evas_object_box_{h,v}_{align,padding}_set()</c> family of
   /// functions. The size hints of the elements in the box -- set by the
   /// <c>evas_object_size_hint_{align,padding,weight}_set()</c> functions
   /// -- also control the way this function works.
   ///
   /// \par Box's properties:
   /// @c align_h controls the horizontal alignment of the child objects
   /// relative to the containing box. When set to @c 0.0, children are
   /// aligned to the left. A value of @c 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 @c 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 @c align_h makes the box to
   /// @b 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 @c align_v and @c padding_v properties of the box
   /// @b don't contribute to its behaviour when this layout is chosen.
   ///
   /// \par Child element's properties:
   /// @c align_x does @b not influence the box's behavior. @c padding_l
   /// and @c padding_r sum up to the container's horizontal padding
   /// between elements. The child's @c padding_t, @c padding_b and
   /// @c align_y properties apply for padding/alignment relative to the
   /// overall height of the box. Finally, there is the @c weight_x
   /// property, which, if set to a non-zero value, tells the container
   /// that the child width is @b not pre-defined. If the container can't
   /// accommodate all its children, it sets the widths of the ones
   /// <b>with weights</b> 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 @c weight_x property,
   /// besides telling the element is resizable, gives a @b weight for the
   /// resizing process.  The parent box will try to distribute (or take
   /// off) widths accordingly to the @b normalized list of weights: most
   /// weighted children remain/get larger in this process than the least
   /// ones. @c 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 <c>evas_object_size_hint_{min,max}_set()</c>
   /// functions.
   ///
   /// @param priv 
   /// @param data 
   ///
   void layout_horizontal(Evas_Object_Box_Data * priv_, void * data_) const;

   /// @brief Layout function which sets the box @a 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.
   ///
   /// @param priv 
   /// @param data 
   ///
   void layout_vertical(Evas_Object_Box_Data * priv_, void * data_) const;

   /// @brief Layout function which sets the box @a o to a <b>maximum size,
   /// homogeneous</b> horizontal box
   ///
   /// In a maximum size, homogeneous horizontal box, besides having cells
   /// of <b>equal size</b> reserved for the child objects, this size will
   /// be defined by the size of the @b largest child in the box (in
   /// width). The box's overall behavior is controlled by its properties,
   /// which are set by the
   /// <c>evas_object_box_{h,v}_{align,padding}_set()</c> family of
   /// functions.  The size hints of the elements in the box -- set by the
   /// <c>evas_object_size_hint_{align,padding,weight}_set()</c> functions
   /// -- also control the way this function works.
   ///
   /// \par Box's properties:
   /// @c padding_h tells the box to draw empty spaces of that size, in
   /// pixels, between the child objects' cells. @c align_h controls the
   /// horizontal alignment of the child objects, relative to the
   /// containing box. When set to @c 0.0, children are aligned to the
   /// left. A value of @c 1.0 lets them aligned to the right
   /// border. Values in between align them proportionally. A negative
   /// value of @c align_h makes the box to @b 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
   /// @c align_v and @c padding_v properties of the box don't contribute to
   /// its behaviour when this layout is chosen.
   ///
   /// \par Child element's properties:
   /// @c padding_l and @c padding_r sum up to the required width of the
   /// child element. The @c align_x property tells the relative position
   /// of this overall child width in its allocated cell (@c 0.0 to
   /// extreme left, @c 1.0 to extreme right). A value of @c -1.0 to
   /// @c 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 @c padding_t, @c padding_b and @c align_y
   /// properties apply for padding/alignment relative to the overall
   /// height of the box. A value of @c -1.0 to @c 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).
   ///
   /// @param priv 
   /// @param data 
   ///
   void layout_homogeneous_max_size_horizontal(Evas_Object_Box_Data * priv_, void * data_) const;

   /// @brief No description supplied by the EAPI.
   ///
   /// @param child 
   ///
   ::evas::object internal_remove(::evas::object child_) const;

   /// @brief Layout function which sets the box @a o to a @b 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.
   ///
   /// @param priv 
   /// @param data 
   ///
   void layout_flow_vertical(Evas_Object_Box_Data * priv_, void * data_) const;

   /// @brief No description supplied by the EAPI.
   ///
   /// @param opt 
   ///
   void internal_option_free(Evas_Object_Box_Option * opt_) const;

   /// @brief Insert a new @a child object <b>after another existing one</b>, in
   /// a given box object @a o.
   ///
   /// @return A box option bound to the recently added box item or @c
   /// NULL, on errors
   ///
   /// On success, the @c "child,added" smart event will take place.
   ///
   /// @note This function will fail if @p reference is not a member of @p
   /// o.
   ///
   /// @note The actual placing of the item relative to @p 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.
   ///
   /// @param child A child Evas object to be made a member of @p o
   /// @param reference The child object to place this new one after
   ///
   Evas_Object_Box_Option * insert_after(::evas::object child_, const Evas_Object * reference_) const;

   /// @brief Remove @b all child objects from a box object, unparenting them
   /// again.
   ///
   /// @return @c EINA_TRUE, on success, @c EINA_FALSE otherwise
   ///
   /// This has the same effect of calling evas_object_box_remove() on
   /// each of @p o's child objects, in sequence. If, and only if, all
   /// those calls succeed, so does this one.
   ///
   /// @param clear if true, it will delete just removed children.
   ///
   bool remove_all(bool clear_) const;

   /// @brief Get an iterator to walk the list of children of a given box object.
   ///
   /// @return An iterator on @p o's child objects, on success, or @c NULL,
   /// on errors
   ///
   /// @note Do @b not remove or delete objects while walking the list.
   ///
   Eina_Iterator * iterator_new() const;

   /// @brief Add a new box as a @b child of a given smart object.
   ///
   /// @return @c NULL on error, a pointer to a new box object on
   /// success.
   ///
   /// This is a helper function that has the same effect of putting a new
   /// box object into @p parent by use of evas_object_smart_member_add().
   ///
   /// @see evas_object_box_add()
   ///
   ::evas::object add_to() const;

   /// @brief Append a new @a child object to the given box object @a o.
   ///
   /// @return A box option bound to the recently added box item or @c
   /// NULL, on errors
   ///
   /// On success, the @c "child,added" smart event will take place.
   ///
   /// @note The actual placing of the item relative to @p 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.
   ///
   /// @param child A child Evas object to be made a member of @p o
   ///
   Evas_Object_Box_Option * append(::evas::object child_) const;

   /// @brief Get the numerical identifier of the property of the child elements
   /// of the box @a o which have @a name as name string
   ///
   /// @return The numerical ID of the given property or @c -1, on
   /// errors.
   ///
   /// @note This call won't do anything for a canonical Evas box. Only
   /// users which have @b 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 @c NULL.
   ///
   /// @param name The name string of the option being searched, for
   /// its ID
   ///
   int option_property_id_get(::efl::eina::string_view name_) const;

   /// @brief Prepend a new @a child object to the given box object @a o.
   ///
   /// @return A box option bound to the recently added box item or @c
   /// NULL, on errors
   ///
   /// On success, the @c "child,added" smart event will take place.
   ///
   /// @note The actual placing of the item relative to @p 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.
   ///
   /// @param child A child Evas object to be made a member of @p o
   ///
   Evas_Object_Box_Option * prepend(::evas::object child_) const;

   /// @brief Get an accessor (a structure providing random items access) to the
   /// list of children of a given box object.
   ///
   /// @return An accessor on @p o's child objects, on success, or @c NULL,
   /// on errors
   ///
   /// @note Do not remove or delete objects while walking the list.
   ///
   Eina_Accessor * accessor_new() const;

   /// @brief No description supplied by the EAPI.
   ///
   /// @param child 
   ///
   Evas_Object_Box_Option * internal_append(::evas::object child_) const;

   /// @brief Set a property value (by its given numerical identifier), on a
   /// given box child element -- by a variable argument list
   ///
   /// @return @c EINA_TRUE on success, @c EINA_FALSE on failure.
   ///
   /// This is a variable argument list variant of the
   /// evas_object_box_option_property_set(). See its documentation for
   /// more details.
   ///
   /// @param opt The box option structure bound to the child box element
   /// to set a property on
   /// @param property The numerical ID of the given property
   /// @param args The variable argument list implementing the value to
   /// be set for this property. It @b must be of the same type the user has
   /// defined for it.
   ///
   bool option_property_vset(Evas_Object_Box_Option * opt_, int property_, va_list * args_) const;

   /// @brief No description supplied by the EAPI.
   ///
   /// @param pos 
   ///
   ::evas::object internal_remove_at(unsigned int pos_) const;

   /// @brief Remove an object, <b>bound to a given position</b> in a box object,
   /// unparenting it again.
   ///
   /// @return @c EINA_TRUE, on success, @c EINA_FALSE otherwise
   ///
   /// On removal, you'll get an unparented object again, just as it was
   /// before you inserted it in the box. The @c option_free() box smart
   /// callback will be called automatically for you and, also, the
   /// @c "child,removed" smart event will take place.
   ///
   /// @note This function will fail if the given position is invalid,
   /// given @p o's internal list of elements.
   ///
   /// @note This call will trigger the box's
   /// _Evas_Object_Box_Api.remove_at smart function.
   ///
   /// @param pos The numeric position (starting from @c 0) of the child
   /// object to be removed
   ///
   bool remove_at(unsigned int pos_) const;

   /// @brief Get a property's value (by its given numerical identifier), on a
   /// given box child element -- by a variable argument list
   ///
   /// @return @c EINA_TRUE on success, @c EINA_FALSE on failure.
   ///
   /// This is a variable argument list variant of the
   /// evas_object_box_option_property_get(). See its documentation for
   /// more details.
   ///
   /// @param opt The box option structure bound to the child box element
   /// to get a property from
   /// @param property The numerical ID of the given property
   /// @param args The variable argument list with pointers to where to
   /// store the values of this property. They @b must point to variables
   /// of the same type the user has defined for them.
   ///
   bool option_property_vget(Evas_Object_Box_Option * opt_, int property_, va_list * args_) const;

   /// @brief No description supplied by the EAPI.
   ///
   /// @param child 
   /// @param pos 
   ///
   Evas_Object_Box_Option * internal_insert_at(::evas::object child_, unsigned int pos_) const;

   /// @brief Insert a new @a child object <b>before another existing one</b>, in
   /// a given box object @a o.
   ///
   /// @return A box option bound to the recently added box item or @c
   /// NULL, on errors
   ///
   /// On success, the @c "child,added" smart event will take place.
   ///
   /// @note This function will fail if @p reference is not a member of @p
   /// o.
   ///
   /// @note The actual placing of the item relative to @p 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.
   ///
   /// @param child A child Evas object to be made a member of @p o
   /// @param reference The child object to place this new one before
   ///
   Evas_Object_Box_Option * insert_before(::evas::object child_, const Evas_Object * reference_) const;

   /// @brief Get the name of the property of the child elements of the box @a o
   /// which have @a id as identifier
   ///
   /// @return The name of the given property or @c NULL, on errors.
   ///
   /// @note This call won't do anything for a canonical Evas box. Only
   /// users which have @b 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 @c NULL.
   ///
   /// @param property The numerical identifier of the option being searched,
   /// for its name
   ///
   ::efl::eina::string_view option_property_name_get(int property_) const;

   /// @brief No description supplied by the EAPI.
   ///
   /// @param child 
   /// @param reference 
   ///
   Evas_Object_Box_Option * internal_insert_before(::evas::object child_, const Evas_Object * reference_) const;

   /// @brief Layout function which sets the box @a o to a @b homogeneous
   /// horizontal box
   ///
   /// In a homogeneous horizontal box, its width is divided @b equally
   /// between the contained objects. The box's overall behavior is
   /// controlled by its padding/alignment properties, which are set by
   /// the <c>evas_object_box_{h,v}_{align,padding}_set()</c> family of
   /// functions.  The size hints the elements in the box -- set by the
   /// <c>evas_object_size_hint_{align,padding,weight}_set()</c> functions
   /// -- also control the way this function works.
   ///
   /// \par Box's properties:
   /// @c align_h has no influence on the box for this layout.
   /// @c padding_h tells the box to draw empty spaces of that size, in
   /// pixels, between the (equal) child objects' cells. The @c align_v
   /// and @c padding_v properties of the box don't contribute to its
   /// behaviour when this layout is chosen.
   ///
   /// \par Child element's properties:
   /// @c padding_l and @c padding_r sum up to the required width of the
   /// child element. The @c align_x property tells the relative position
   /// of this overall child width in its allocated cell (@c 0.0 to
   /// extreme left, @c 1.0 to extreme right). A value of @c -1.0 to
   /// @c 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 @c padding_t, @c padding_b and @c align_y
   /// properties apply for padding/alignment relative to the overall
   /// height of the box. A value of @c -1.0 to @c 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).
   ///
   /// @param priv 
   /// @param data 
   ///
   void layout_homogeneous_horizontal(Evas_Object_Box_Data * priv_, void * data_) const;

   /// @brief No description supplied by the EAPI.
   ///
   /// @param child 
   ///
   Evas_Object_Box_Option * internal_option_new(::evas::object child_) const;

   /// @brief Layout function which sets the box @a o to a <b>maximum size,
   /// homogeneous</b> 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.
   ///
   /// @param priv 
   /// @param data 
   ///
   void layout_homogeneous_max_size_vertical(Evas_Object_Box_Data * priv_, void * data_) const;

   /// @brief No description supplied by the EAPI.
   ///
   /// @param child 
   /// @param reference 
   ///
   Evas_Object_Box_Option * internal_insert_after(::evas::object child_, const Evas_Object * reference_) const;

   /// @brief Insert a new @a child object <b>at a given position</b>, in a given
   /// box object @a o.
   ///
   /// @return A box option bound to the recently added box item or @c
   /// NULL, on errors
   ///
   /// On success, the @c "child,added" smart event will take place.
   ///
   /// @note This function will fail if the given position is invalid,
   /// given @p o's internal list of elements.
   ///
   /// @note The actual placing of the item relative to @p 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.
   ///
   /// @param child A child Evas object to be made a member of @p o
   /// @param pos The numeric position (starting from @c 0) to place the
   /// new child object at
   ///
   Evas_Object_Box_Option * insert_at(::evas::object child_, unsigned int pos_) const;

   /// @brief No description supplied by the EAPI.
   ///
   /// @param child 
   ///
   Evas_Object_Box_Option * internal_prepend(::evas::object child_) const;

   /// @brief Remove a given object from a box object, unparenting it again.
   ///
   /// @return @c EINA_TRUE, on success, @c EINA_FALSE otherwise
   ///
   /// 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 @c "child,removed" smart event
   /// will take place.
   ///
   /// @note This call will trigger the box's _Evas_Object_Box_Api.remove
   /// smart function.
   ///
   /// @param child The handle to the child object to be removed
   ///
   bool remove(::evas::object child_) const;

   /// @brief Layout function which sets the box @a o to a @b 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 @p o's internal list of child elements
   /// will be the bottommost in the stack.
   ///
   /// \par Box's properties:
   /// No box properties are used.
   ///
   /// \par Child element's properties:
   /// @c padding_l and @c padding_r sum up to the required width of the
   /// child element. The @c align_x property tells the relative position
   /// of this overall child width in its allocated cell (@c 0.0 to
   /// extreme left, @c 1.0 to extreme right). A value of @c -1.0 to @c
   /// 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.
   ///
   /// @param priv 
   /// @param data 
   ///
   void layout_stack(Evas_Object_Box_Data * priv_, void * data_) const;

   /// @brief Layout function which sets the box @a o to a @b 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.
   ///
   /// @param priv 
   /// @param data 
   ///
   void layout_homogeneous_vertical(Evas_Object_Box_Data * priv_, void * data_) const;

   /// @brief Layout function which sets the box @a o to a @b flow horizontal
   /// box.
   ///
   /// In a flow horizontal box, the box's child elements are placed in
   /// @b 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
   /// <c>evas_object_box_{h,v}_{align,padding}_set()</c> family of
   /// functions.  The size hints of the elements in the box -- set by the
   /// <c>evas_object_size_hint_{align,padding,weight}_set()</c> functions
   /// -- also control the way this function works.
   ///
   /// \par Box's properties:
   /// @c padding_h tells the box to draw empty spaces of that size, in
   /// pixels, between the child objects' cells. @c align_h dictates the
   /// horizontal alignment of the rows (@c 0.0 to left align them, @c 1.0
   /// to right align). A value of @c -1.0 to @c align_h lets the rows
   /// @b justified horizontally. @c align_v controls the vertical alignment
   /// of the entire set of rows (@c 0.0 to top, @c 1.0 to bottom). A
   /// value of @c -1.0 to @c align_v makes the box to @b 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). @c padding_v has no
   /// influence on the layout.
   ///
   /// \par Child element's properties:
   /// @c padding_l and @c padding_r sum up to the required width of the
   /// child element. The @c align_x property has no influence on the
   /// layout. The child's @c padding_t and @c 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
   /// @c align_y dictates positioning relative to the <b>largest
   /// height</b> required by a child object in the actual row.
   ///
   /// @param priv 
   /// @param data 
   ///
   void layout_flow_horizontal(Evas_Object_Box_Data * priv_, void * data_) const;

   /// @brief Get the alignment of the whole bounding box of contents, for a
   /// given box object.
   ///
   /// @see evas_object_box_align_set() for more information
   ///
   /// @param horizontal The horizontal alignment, in pixels
   /// @param vertical the vertical alignment, in pixels
   ///
   void align_get(double* horizontal_, double* vertical_) const;

   /// @brief 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 @b must be in the range
   /// @c 0.0 - @c 1.0, or undefined behavior is expected. For horizontal
   /// alignment, @c 0.0 means to the left, with @c 1.0 meaning to the
   /// right. For vertical alignment, @c 0.0 means to the top, with @c 1.0
   /// meaning to the bottom.
   ///
   /// @note The default values for both alignments is @c 0.5.
   ///
   /// @see evas_object_box_align_get()
   ///
   /// @param horizontal The horizontal alignment, in pixels
   /// @param vertical the vertical alignment, in pixels
   ///
   void align_set(double horizontal_, double vertical_) const;

   /// @brief Get the (space) padding between cells set for a given box object.
   ///
   /// @see evas_object_box_padding_set()
   ///
   /// @param horizontal The horizontal padding, in pixels
   /// @param vertical the vertical padding, in pixels
   ///
   void padding_get(Evas_Coord* horizontal_, Evas_Coord* vertical_) const;

   /// @brief Set the (space) padding between cells set for a given box object.
   ///
   /// @note The default values for both padding components is @c 0.
   ///
   /// @see evas_object_box_padding_get()
   ///
   /// @param horizontal The horizontal padding, in pixels
   /// @param vertical the vertical padding, in pixels
   ///
   void padding_set(Evas_Coord horizontal_, Evas_Coord vertical_) const;

   /// @brief 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 is:
   /// - evas_object_box_layout_horizontal()
   /// - evas_object_box_layout_vertical()
   /// - evas_object_box_layout_homogeneous_horizontal()
   /// - evas_object_box_layout_homogeneous_vertical()
   /// - evas_object_box_layout_homogeneous_max_size_horizontal()
   /// - evas_object_box_layout_homogeneous_max_size_vertical()
   /// - evas_object_box_layout_flow_horizontal()
   /// - evas_object_box_layout_flow_vertical()
   /// - evas_object_box_layout_stack()
   ///
   /// Refer to each of their documentation texts for details on them.
   ///
   /// @note A box layouting function will be triggered by the @c
   /// 'calculate' smart callback of the box's smart class.
   ///
   /// @param cb The new layout function to set on @p o.
   /// @param data Data pointer to be passed to @p cb.
   /// @param free_data Function to free @p data, if need be.
   ///
   void layout_set(Evas_Object_Box_Layout cb_, const void * data_, Eina_Free_Cb free_data_) const;

   template <typename F>
   ::efl::eo::signal_connection
   callback_child_added_add(F && callback_,
                        ::efl::eo::callback_priority priority_ =
                        ::efl::eo::callback_priorities::default_)
   {
      typedef typename std::remove_reference<F>::type function_type;
      ::std::unique_ptr<function_type> f ( new function_type(std::forward<F>(callback_)) );
      eo_do(_concrete_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_BOX_EVENT_CHILD_ADDED, priority_,
            &::efl::eo::_detail::event_callback<::evas::box, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _concrete_eo_ptr(), &::efl::eo::_detail::event_callback<::evas::box, function_type>,
         EVAS_BOX_EVENT_CHILD_ADDED );
   }

   template <typename T>
   void
   callback_child_added_call(T* info)
   {
      eo_do(_concrete_eo_ptr(), eo_event_callback_call
            (EVAS_BOX_EVENT_CHILD_ADDED, info));
   }

   template <typename F>
   ::efl::eo::signal_connection
   callback_child_removed_add(F && callback_,
                        ::efl::eo::callback_priority priority_ =
                        ::efl::eo::callback_priorities::default_)
   {
      typedef typename std::remove_reference<F>::type function_type;
      ::std::unique_ptr<function_type> f ( new function_type(std::forward<F>(callback_)) );
      eo_do(_concrete_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_BOX_EVENT_CHILD_REMOVED, priority_,
            &::efl::eo::_detail::event_callback<::evas::box, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _concrete_eo_ptr(), &::efl::eo::_detail::event_callback<::evas::box, function_type>,
         EVAS_BOX_EVENT_CHILD_REMOVED );
   }

   template <typename T>
   void
   callback_child_removed_call(T* info)
   {
      eo_do(_concrete_eo_ptr(), eo_event_callback_call
            (EVAS_BOX_EVENT_CHILD_REMOVED, info));
   }



   static Eo_Class const* _eo_class()
   {
      return(EVAS_BOX_CLASS);
   }

   operator ::evas::box() const;
   operator ::evas::box&();
   operator ::evas::box const&() const;

   /// @cond LOCAL
   template <typename D>
   struct address_of
   {
      operator ::evas::box*() const { return static_cast<::evas::box*>(static_cast<D const*>(this)->p); }
      operator ::evas::box const*() const { return static_cast<::evas::box const*>(static_cast<D const*>(this)->p); }
   };

   template <typename D>
   struct address_const_of
   {
      operator ::evas::box const*() const { return static_cast<::evas::box const*>(static_cast<D const*>(this)->p); }
   };
   /// @endcond

private:

   /// @internal
   Eo* _concrete_eo_ptr() const
   {
      return static_cast<::efl::eo::concrete const*>(static_cast<void const*>(this))->_eo_ptr();
   }

};

}

}
/// @endcond

namespace evas {

/// @brief Class box
struct box
      : ::efl::eo::concrete
      , EO_CXX_INHERIT(efl::gfx::base)
      , EO_CXX_INHERIT(efl::gfx::stack)
      , EO_CXX_INHERIT(eo::base)
      , EO_CXX_INHERIT(evas::common_interface)
      , EO_CXX_INHERIT(evas::object)
      , EO_CXX_INHERIT(evas::object_smart)
      , EO_CXX_INHERIT(evas::signal_interface)
      , EO_CXX_INHERIT(evas::smart_clipped)
{
   //@{
   /**
      @brief Constructs a new evas::box object.

      Constructs a new evas::box object. If you want this object to be a child
      of another Eo object, use an @ref efl::eo::parent expression, like the example.

      Example:
      @code
      evas::box my_box(efl::eo::parent = parent_object);
      @endcode

      @see box(Eo* eo)
   */
   explicit box(::efl::eo::parent_type _p)
      : box(_ctors_call(_p))
   {}

   explicit box()
      : box(_ctors_call(::efl::eo::parent = nullptr))
   {}
   //@}

   /// @brief Eo Constructor.
   ///
   /// Constructs the object from an Eo* pointer stealing its ownership.
   ///
   /// @param eo The Eo object pointer.
   ///
   explicit box(Eo* eo)
      : ::efl::eo::concrete(eo)
   {}

   /// @brief nullptr_t Constructor.
   ///
   /// Constructs an empty (null) object.
   ///
   explicit box(std::nullptr_t)
      : ::efl::eo::concrete(nullptr)
   {}

   /// @brief Copy Constructor.
   ///
   box(box const& other)
      : box(eo_ref(other._eo_ptr()))
   {}

   ~box() {}

   /// @brief Layout function which sets the box @a 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
   /// <c>evas_object_box_{h,v}_{align,padding}_set()</c> family of
   /// functions. The size hints of the elements in the box -- set by the
   /// <c>evas_object_size_hint_{align,padding,weight}_set()</c> functions
   /// -- also control the way this function works.
   ///
   /// \par Box's properties:
   /// @c align_h controls the horizontal alignment of the child objects
   /// relative to the containing box. When set to @c 0.0, children are
   /// aligned to the left. A value of @c 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 @c 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 @c align_h makes the box to
   /// @b 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 @c align_v and @c padding_v properties of the box
   /// @b don't contribute to its behaviour when this layout is chosen.
   ///
   /// \par Child element's properties:
   /// @c align_x does @b not influence the box's behavior. @c padding_l
   /// and @c padding_r sum up to the container's horizontal padding
   /// between elements. The child's @c padding_t, @c padding_b and
   /// @c align_y properties apply for padding/alignment relative to the
   /// overall height of the box. Finally, there is the @c weight_x
   /// property, which, if set to a non-zero value, tells the container
   /// that the child width is @b not pre-defined. If the container can't
   /// accommodate all its children, it sets the widths of the ones
   /// <b>with weights</b> 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 @c weight_x property,
   /// besides telling the element is resizable, gives a @b weight for the
   /// resizing process.  The parent box will try to distribute (or take
   /// off) widths accordingly to the @b normalized list of weights: most
   /// weighted children remain/get larger in this process than the least
   /// ones. @c 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 <c>evas_object_size_hint_{min,max}_set()</c>
   /// functions.
   ///
   /// @param priv 
   /// @param data 
   ///
   void layout_horizontal(Evas_Object_Box_Data * priv_, void * data_) const;

   /// @brief Layout function which sets the box @a 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.
   ///
   /// @param priv 
   /// @param data 
   ///
   void layout_vertical(Evas_Object_Box_Data * priv_, void * data_) const;

   /// @brief Layout function which sets the box @a o to a <b>maximum size,
   /// homogeneous</b> horizontal box
   ///
   /// In a maximum size, homogeneous horizontal box, besides having cells
   /// of <b>equal size</b> reserved for the child objects, this size will
   /// be defined by the size of the @b largest child in the box (in
   /// width). The box's overall behavior is controlled by its properties,
   /// which are set by the
   /// <c>evas_object_box_{h,v}_{align,padding}_set()</c> family of
   /// functions.  The size hints of the elements in the box -- set by the
   /// <c>evas_object_size_hint_{align,padding,weight}_set()</c> functions
   /// -- also control the way this function works.
   ///
   /// \par Box's properties:
   /// @c padding_h tells the box to draw empty spaces of that size, in
   /// pixels, between the child objects' cells. @c align_h controls the
   /// horizontal alignment of the child objects, relative to the
   /// containing box. When set to @c 0.0, children are aligned to the
   /// left. A value of @c 1.0 lets them aligned to the right
   /// border. Values in between align them proportionally. A negative
   /// value of @c align_h makes the box to @b 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
   /// @c align_v and @c padding_v properties of the box don't contribute to
   /// its behaviour when this layout is chosen.
   ///
   /// \par Child element's properties:
   /// @c padding_l and @c padding_r sum up to the required width of the
   /// child element. The @c align_x property tells the relative position
   /// of this overall child width in its allocated cell (@c 0.0 to
   /// extreme left, @c 1.0 to extreme right). A value of @c -1.0 to
   /// @c 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 @c padding_t, @c padding_b and @c align_y
   /// properties apply for padding/alignment relative to the overall
   /// height of the box. A value of @c -1.0 to @c 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).
   ///
   /// @param priv 
   /// @param data 
   ///
   void layout_homogeneous_max_size_horizontal(Evas_Object_Box_Data * priv_, void * data_) const;

   /// @brief No description supplied by the EAPI.
   ///
   /// @param child 
   ///
   ::evas::object internal_remove(::evas::object child_) const;

   /// @brief Layout function which sets the box @a o to a @b 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.
   ///
   /// @param priv 
   /// @param data 
   ///
   void layout_flow_vertical(Evas_Object_Box_Data * priv_, void * data_) const;

   /// @brief No description supplied by the EAPI.
   ///
   /// @param opt 
   ///
   void internal_option_free(Evas_Object_Box_Option * opt_) const;

   /// @brief Insert a new @a child object <b>after another existing one</b>, in
   /// a given box object @a o.
   ///
   /// @return A box option bound to the recently added box item or @c
   /// NULL, on errors
   ///
   /// On success, the @c "child,added" smart event will take place.
   ///
   /// @note This function will fail if @p reference is not a member of @p
   /// o.
   ///
   /// @note The actual placing of the item relative to @p 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.
   ///
   /// @param child A child Evas object to be made a member of @p o
   /// @param reference The child object to place this new one after
   ///
   Evas_Object_Box_Option * insert_after(::evas::object child_, const Evas_Object * reference_) const;

   /// @brief Remove @b all child objects from a box object, unparenting them
   /// again.
   ///
   /// @return @c EINA_TRUE, on success, @c EINA_FALSE otherwise
   ///
   /// This has the same effect of calling evas_object_box_remove() on
   /// each of @p o's child objects, in sequence. If, and only if, all
   /// those calls succeed, so does this one.
   ///
   /// @param clear if true, it will delete just removed children.
   ///
   bool remove_all(bool clear_) const;

   /// @brief Get an iterator to walk the list of children of a given box object.
   ///
   /// @return An iterator on @p o's child objects, on success, or @c NULL,
   /// on errors
   ///
   /// @note Do @b not remove or delete objects while walking the list.
   ///
   Eina_Iterator * iterator_new() const;

   /// @brief Add a new box as a @b child of a given smart object.
   ///
   /// @return @c NULL on error, a pointer to a new box object on
   /// success.
   ///
   /// This is a helper function that has the same effect of putting a new
   /// box object into @p parent by use of evas_object_smart_member_add().
   ///
   /// @see evas_object_box_add()
   ///
   ::evas::object add_to() const;

   /// @brief Append a new @a child object to the given box object @a o.
   ///
   /// @return A box option bound to the recently added box item or @c
   /// NULL, on errors
   ///
   /// On success, the @c "child,added" smart event will take place.
   ///
   /// @note The actual placing of the item relative to @p 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.
   ///
   /// @param child A child Evas object to be made a member of @p o
   ///
   Evas_Object_Box_Option * append(::evas::object child_) const;

   /// @brief Get the numerical identifier of the property of the child elements
   /// of the box @a o which have @a name as name string
   ///
   /// @return The numerical ID of the given property or @c -1, on
   /// errors.
   ///
   /// @note This call won't do anything for a canonical Evas box. Only
   /// users which have @b 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 @c NULL.
   ///
   /// @param name The name string of the option being searched, for
   /// its ID
   ///
   int option_property_id_get(::efl::eina::string_view name_) const;

   /// @brief Prepend a new @a child object to the given box object @a o.
   ///
   /// @return A box option bound to the recently added box item or @c
   /// NULL, on errors
   ///
   /// On success, the @c "child,added" smart event will take place.
   ///
   /// @note The actual placing of the item relative to @p 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.
   ///
   /// @param child A child Evas object to be made a member of @p o
   ///
   Evas_Object_Box_Option * prepend(::evas::object child_) const;

   /// @brief Get an accessor (a structure providing random items access) to the
   /// list of children of a given box object.
   ///
   /// @return An accessor on @p o's child objects, on success, or @c NULL,
   /// on errors
   ///
   /// @note Do not remove or delete objects while walking the list.
   ///
   Eina_Accessor * accessor_new() const;

   /// @brief No description supplied by the EAPI.
   ///
   /// @param child 
   ///
   Evas_Object_Box_Option * internal_append(::evas::object child_) const;

   /// @brief Set a property value (by its given numerical identifier), on a
   /// given box child element -- by a variable argument list
   ///
   /// @return @c EINA_TRUE on success, @c EINA_FALSE on failure.
   ///
   /// This is a variable argument list variant of the
   /// evas_object_box_option_property_set(). See its documentation for
   /// more details.
   ///
   /// @param opt The box option structure bound to the child box element
   /// to set a property on
   /// @param property The numerical ID of the given property
   /// @param args The variable argument list implementing the value to
   /// be set for this property. It @b must be of the same type the user has
   /// defined for it.
   ///
   bool option_property_vset(Evas_Object_Box_Option * opt_, int property_, va_list * args_) const;

   /// @brief No description supplied by the EAPI.
   ///
   /// @param pos 
   ///
   ::evas::object internal_remove_at(unsigned int pos_) const;

   /// @brief Remove an object, <b>bound to a given position</b> in a box object,
   /// unparenting it again.
   ///
   /// @return @c EINA_TRUE, on success, @c EINA_FALSE otherwise
   ///
   /// On removal, you'll get an unparented object again, just as it was
   /// before you inserted it in the box. The @c option_free() box smart
   /// callback will be called automatically for you and, also, the
   /// @c "child,removed" smart event will take place.
   ///
   /// @note This function will fail if the given position is invalid,
   /// given @p o's internal list of elements.
   ///
   /// @note This call will trigger the box's
   /// _Evas_Object_Box_Api.remove_at smart function.
   ///
   /// @param pos The numeric position (starting from @c 0) of the child
   /// object to be removed
   ///
   bool remove_at(unsigned int pos_) const;

   /// @brief Get a property's value (by its given numerical identifier), on a
   /// given box child element -- by a variable argument list
   ///
   /// @return @c EINA_TRUE on success, @c EINA_FALSE on failure.
   ///
   /// This is a variable argument list variant of the
   /// evas_object_box_option_property_get(). See its documentation for
   /// more details.
   ///
   /// @param opt The box option structure bound to the child box element
   /// to get a property from
   /// @param property The numerical ID of the given property
   /// @param args The variable argument list with pointers to where to
   /// store the values of this property. They @b must point to variables
   /// of the same type the user has defined for them.
   ///
   bool option_property_vget(Evas_Object_Box_Option * opt_, int property_, va_list * args_) const;

   /// @brief No description supplied by the EAPI.
   ///
   /// @param child 
   /// @param pos 
   ///
   Evas_Object_Box_Option * internal_insert_at(::evas::object child_, unsigned int pos_) const;

   /// @brief Insert a new @a child object <b>before another existing one</b>, in
   /// a given box object @a o.
   ///
   /// @return A box option bound to the recently added box item or @c
   /// NULL, on errors
   ///
   /// On success, the @c "child,added" smart event will take place.
   ///
   /// @note This function will fail if @p reference is not a member of @p
   /// o.
   ///
   /// @note The actual placing of the item relative to @p 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.
   ///
   /// @param child A child Evas object to be made a member of @p o
   /// @param reference The child object to place this new one before
   ///
   Evas_Object_Box_Option * insert_before(::evas::object child_, const Evas_Object * reference_) const;

   /// @brief Get the name of the property of the child elements of the box @a o
   /// which have @a id as identifier
   ///
   /// @return The name of the given property or @c NULL, on errors.
   ///
   /// @note This call won't do anything for a canonical Evas box. Only
   /// users which have @b 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 @c NULL.
   ///
   /// @param property The numerical identifier of the option being searched,
   /// for its name
   ///
   ::efl::eina::string_view option_property_name_get(int property_) const;

   /// @brief No description supplied by the EAPI.
   ///
   /// @param child 
   /// @param reference 
   ///
   Evas_Object_Box_Option * internal_insert_before(::evas::object child_, const Evas_Object * reference_) const;

   /// @brief Layout function which sets the box @a o to a @b homogeneous
   /// horizontal box
   ///
   /// In a homogeneous horizontal box, its width is divided @b equally
   /// between the contained objects. The box's overall behavior is
   /// controlled by its padding/alignment properties, which are set by
   /// the <c>evas_object_box_{h,v}_{align,padding}_set()</c> family of
   /// functions.  The size hints the elements in the box -- set by the
   /// <c>evas_object_size_hint_{align,padding,weight}_set()</c> functions
   /// -- also control the way this function works.
   ///
   /// \par Box's properties:
   /// @c align_h has no influence on the box for this layout.
   /// @c padding_h tells the box to draw empty spaces of that size, in
   /// pixels, between the (equal) child objects' cells. The @c align_v
   /// and @c padding_v properties of the box don't contribute to its
   /// behaviour when this layout is chosen.
   ///
   /// \par Child element's properties:
   /// @c padding_l and @c padding_r sum up to the required width of the
   /// child element. The @c align_x property tells the relative position
   /// of this overall child width in its allocated cell (@c 0.0 to
   /// extreme left, @c 1.0 to extreme right). A value of @c -1.0 to
   /// @c 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 @c padding_t, @c padding_b and @c align_y
   /// properties apply for padding/alignment relative to the overall
   /// height of the box. A value of @c -1.0 to @c 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).
   ///
   /// @param priv 
   /// @param data 
   ///
   void layout_homogeneous_horizontal(Evas_Object_Box_Data * priv_, void * data_) const;

   /// @brief No description supplied by the EAPI.
   ///
   /// @param child 
   ///
   Evas_Object_Box_Option * internal_option_new(::evas::object child_) const;

   /// @brief Layout function which sets the box @a o to a <b>maximum size,
   /// homogeneous</b> 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.
   ///
   /// @param priv 
   /// @param data 
   ///
   void layout_homogeneous_max_size_vertical(Evas_Object_Box_Data * priv_, void * data_) const;

   /// @brief No description supplied by the EAPI.
   ///
   /// @param child 
   /// @param reference 
   ///
   Evas_Object_Box_Option * internal_insert_after(::evas::object child_, const Evas_Object * reference_) const;

   /// @brief Insert a new @a child object <b>at a given position</b>, in a given
   /// box object @a o.
   ///
   /// @return A box option bound to the recently added box item or @c
   /// NULL, on errors
   ///
   /// On success, the @c "child,added" smart event will take place.
   ///
   /// @note This function will fail if the given position is invalid,
   /// given @p o's internal list of elements.
   ///
   /// @note The actual placing of the item relative to @p 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.
   ///
   /// @param child A child Evas object to be made a member of @p o
   /// @param pos The numeric position (starting from @c 0) to place the
   /// new child object at
   ///
   Evas_Object_Box_Option * insert_at(::evas::object child_, unsigned int pos_) const;

   /// @brief No description supplied by the EAPI.
   ///
   /// @param child 
   ///
   Evas_Object_Box_Option * internal_prepend(::evas::object child_) const;

   /// @brief Remove a given object from a box object, unparenting it again.
   ///
   /// @return @c EINA_TRUE, on success, @c EINA_FALSE otherwise
   ///
   /// 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 @c "child,removed" smart event
   /// will take place.
   ///
   /// @note This call will trigger the box's _Evas_Object_Box_Api.remove
   /// smart function.
   ///
   /// @param child The handle to the child object to be removed
   ///
   bool remove(::evas::object child_) const;

   /// @brief Layout function which sets the box @a o to a @b 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 @p o's internal list of child elements
   /// will be the bottommost in the stack.
   ///
   /// \par Box's properties:
   /// No box properties are used.
   ///
   /// \par Child element's properties:
   /// @c padding_l and @c padding_r sum up to the required width of the
   /// child element. The @c align_x property tells the relative position
   /// of this overall child width in its allocated cell (@c 0.0 to
   /// extreme left, @c 1.0 to extreme right). A value of @c -1.0 to @c
   /// 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.
   ///
   /// @param priv 
   /// @param data 
   ///
   void layout_stack(Evas_Object_Box_Data * priv_, void * data_) const;

   /// @brief Layout function which sets the box @a o to a @b 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.
   ///
   /// @param priv 
   /// @param data 
   ///
   void layout_homogeneous_vertical(Evas_Object_Box_Data * priv_, void * data_) const;

   /// @brief Layout function which sets the box @a o to a @b flow horizontal
   /// box.
   ///
   /// In a flow horizontal box, the box's child elements are placed in
   /// @b 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
   /// <c>evas_object_box_{h,v}_{align,padding}_set()</c> family of
   /// functions.  The size hints of the elements in the box -- set by the
   /// <c>evas_object_size_hint_{align,padding,weight}_set()</c> functions
   /// -- also control the way this function works.
   ///
   /// \par Box's properties:
   /// @c padding_h tells the box to draw empty spaces of that size, in
   /// pixels, between the child objects' cells. @c align_h dictates the
   /// horizontal alignment of the rows (@c 0.0 to left align them, @c 1.0
   /// to right align). A value of @c -1.0 to @c align_h lets the rows
   /// @b justified horizontally. @c align_v controls the vertical alignment
   /// of the entire set of rows (@c 0.0 to top, @c 1.0 to bottom). A
   /// value of @c -1.0 to @c align_v makes the box to @b 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). @c padding_v has no
   /// influence on the layout.
   ///
   /// \par Child element's properties:
   /// @c padding_l and @c padding_r sum up to the required width of the
   /// child element. The @c align_x property has no influence on the
   /// layout. The child's @c padding_t and @c 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
   /// @c align_y dictates positioning relative to the <b>largest
   /// height</b> required by a child object in the actual row.
   ///
   /// @param priv 
   /// @param data 
   ///
   void layout_flow_horizontal(Evas_Object_Box_Data * priv_, void * data_) const;

   /// @brief Get the alignment of the whole bounding box of contents, for a
   /// given box object.
   ///
   /// @see evas_object_box_align_set() for more information
   ///
   /// @param horizontal The horizontal alignment, in pixels
   /// @param vertical the vertical alignment, in pixels
   ///
   void align_get(double* horizontal_, double* vertical_) const;

   /// @brief 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 @b must be in the range
   /// @c 0.0 - @c 1.0, or undefined behavior is expected. For horizontal
   /// alignment, @c 0.0 means to the left, with @c 1.0 meaning to the
   /// right. For vertical alignment, @c 0.0 means to the top, with @c 1.0
   /// meaning to the bottom.
   ///
   /// @note The default values for both alignments is @c 0.5.
   ///
   /// @see evas_object_box_align_get()
   ///
   /// @param horizontal The horizontal alignment, in pixels
   /// @param vertical the vertical alignment, in pixels
   ///
   void align_set(double horizontal_, double vertical_) const;

   /// @brief Get the (space) padding between cells set for a given box object.
   ///
   /// @see evas_object_box_padding_set()
   ///
   /// @param horizontal The horizontal padding, in pixels
   /// @param vertical the vertical padding, in pixels
   ///
   void padding_get(Evas_Coord* horizontal_, Evas_Coord* vertical_) const;

   /// @brief Set the (space) padding between cells set for a given box object.
   ///
   /// @note The default values for both padding components is @c 0.
   ///
   /// @see evas_object_box_padding_get()
   ///
   /// @param horizontal The horizontal padding, in pixels
   /// @param vertical the vertical padding, in pixels
   ///
   void padding_set(Evas_Coord horizontal_, Evas_Coord vertical_) const;

   /// @brief 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 is:
   /// - evas_object_box_layout_horizontal()
   /// - evas_object_box_layout_vertical()
   /// - evas_object_box_layout_homogeneous_horizontal()
   /// - evas_object_box_layout_homogeneous_vertical()
   /// - evas_object_box_layout_homogeneous_max_size_horizontal()
   /// - evas_object_box_layout_homogeneous_max_size_vertical()
   /// - evas_object_box_layout_flow_horizontal()
   /// - evas_object_box_layout_flow_vertical()
   /// - evas_object_box_layout_stack()
   ///
   /// Refer to each of their documentation texts for details on them.
   ///
   /// @note A box layouting function will be triggered by the @c
   /// 'calculate' smart callback of the box's smart class.
   ///
   /// @param cb The new layout function to set on @p o.
   /// @param data Data pointer to be passed to @p cb.
   /// @param free_data Function to free @p data, if need be.
   ///
   void layout_set(Evas_Object_Box_Layout cb_, const void * data_, Eina_Free_Cb free_data_) const;

   /// A callback was added.
   template <typename F>
   ::efl::eo::signal_connection
   callback_callback_add_add(F && callback_,
                        ::efl::eo::callback_priority priority_ =
                        ::efl::eo::callback_priorities::default_)
   {
      typedef typename std::remove_reference<F>::type function_type;
      ::std::unique_ptr<function_type> f ( new function_type(std::forward<F>(callback_)) );
      eo_do(_concrete_eo_ptr(),
            eo_event_callback_priority_add
            (EO_BASE_EVENT_CALLBACK_ADD, priority_,
            &::efl::eo::_detail::event_callback<::evas::box, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _concrete_eo_ptr(), &::efl::eo::_detail::event_callback<::evas::box, function_type>,
         EO_BASE_EVENT_CALLBACK_ADD );
   }

   /// A callback was added.
   template <typename T>
   void
   callback_callback_add_call(T* info)
   {
      eo_do(_concrete_eo_ptr(), eo_event_callback_call
            (EO_BASE_EVENT_CALLBACK_ADD, info));
   }

   /// A callback was deleted.
   template <typename F>
   ::efl::eo::signal_connection
   callback_callback_del_add(F && callback_,
                        ::efl::eo::callback_priority priority_ =
                        ::efl::eo::callback_priorities::default_)
   {
      typedef typename std::remove_reference<F>::type function_type;
      ::std::unique_ptr<function_type> f ( new function_type(std::forward<F>(callback_)) );
      eo_do(_concrete_eo_ptr(),
            eo_event_callback_priority_add
            (EO_BASE_EVENT_CALLBACK_DEL, priority_,
            &::efl::eo::_detail::event_callback<::evas::box, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _concrete_eo_ptr(), &::efl::eo::_detail::event_callback<::evas::box, function_type>,
         EO_BASE_EVENT_CALLBACK_DEL );
   }

   /// A callback was deleted.
   template <typename T>
   void
   callback_callback_del_call(T* info)
   {
      eo_do(_concrete_eo_ptr(), eo_event_callback_call
            (EO_BASE_EVENT_CALLBACK_DEL, info));
   }

   /// Size hints changed event
   template <typename F>
   ::efl::eo::signal_connection
   callback_changed_size_hints_add(F && callback_,
                        ::efl::eo::callback_priority priority_ =
                        ::efl::eo::callback_priorities::default_)
   {
      typedef typename std::remove_reference<F>::type function_type;
      ::std::unique_ptr<function_type> f ( new function_type(std::forward<F>(callback_)) );
      eo_do(_concrete_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_CHANGED_SIZE_HINTS, priority_,
            &::efl::eo::_detail::event_callback<::evas::box, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _concrete_eo_ptr(), &::efl::eo::_detail::event_callback<::evas::box, function_type>,
         EVAS_OBJECT_EVENT_CHANGED_SIZE_HINTS );
   }

   /// Size hints changed event
   template <typename T>
   void
   callback_changed_size_hints_call(T* info)
   {
      eo_do(_concrete_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_CHANGED_SIZE_HINTS, info));
   }

   template <typename F>
   ::efl::eo::signal_connection
   callback_child_added_add(F && callback_,
                        ::efl::eo::callback_priority priority_ =
                        ::efl::eo::callback_priorities::default_)
   {
      typedef typename std::remove_reference<F>::type function_type;
      ::std::unique_ptr<function_type> f ( new function_type(std::forward<F>(callback_)) );
      eo_do(_concrete_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_BOX_EVENT_CHILD_ADDED, priority_,
            &::efl::eo::_detail::event_callback<::evas::box, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _concrete_eo_ptr(), &::efl::eo::_detail::event_callback<::evas::box, function_type>,
         EVAS_BOX_EVENT_CHILD_ADDED );
   }

   template <typename T>
   void
   callback_child_added_call(T* info)
   {
      eo_do(_concrete_eo_ptr(), eo_event_callback_call
            (EVAS_BOX_EVENT_CHILD_ADDED, info));
   }

   template <typename F>
   ::efl::eo::signal_connection
   callback_child_removed_add(F && callback_,
                        ::efl::eo::callback_priority priority_ =
                        ::efl::eo::callback_priorities::default_)
   {
      typedef typename std::remove_reference<F>::type function_type;
      ::std::unique_ptr<function_type> f ( new function_type(std::forward<F>(callback_)) );
      eo_do(_concrete_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_BOX_EVENT_CHILD_REMOVED, priority_,
            &::efl::eo::_detail::event_callback<::evas::box, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _concrete_eo_ptr(), &::efl::eo::_detail::event_callback<::evas::box, function_type>,
         EVAS_BOX_EVENT_CHILD_REMOVED );
   }

   template <typename T>
   void
   callback_child_removed_call(T* info)
   {
      eo_do(_concrete_eo_ptr(), eo_event_callback_call
            (EVAS_BOX_EVENT_CHILD_REMOVED, info));
   }

   /// Focus In Event
   template <typename F>
   ::efl::eo::signal_connection
   callback_focus_in_add(F && callback_,
                        ::efl::eo::callback_priority priority_ =
                        ::efl::eo::callback_priorities::default_)
   {
      typedef typename std::remove_reference<F>::type function_type;
      ::std::unique_ptr<function_type> f ( new function_type(std::forward<F>(callback_)) );
      eo_do(_concrete_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_FOCUS_IN, priority_,
            &::efl::eo::_detail::event_callback<::evas::box, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _concrete_eo_ptr(), &::efl::eo::_detail::event_callback<::evas::box, function_type>,
         EVAS_OBJECT_EVENT_FOCUS_IN );
   }

   /// Focus In Event
   template <typename T>
   void
   callback_focus_in_call(T* info)
   {
      eo_do(_concrete_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_FOCUS_IN, info));
   }

   /// Focus Out Event
   template <typename F>
   ::efl::eo::signal_connection
   callback_focus_out_add(F && callback_,
                        ::efl::eo::callback_priority priority_ =
                        ::efl::eo::callback_priorities::default_)
   {
      typedef typename std::remove_reference<F>::type function_type;
      ::std::unique_ptr<function_type> f ( new function_type(std::forward<F>(callback_)) );
      eo_do(_concrete_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_FOCUS_OUT, priority_,
            &::efl::eo::_detail::event_callback<::evas::box, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _concrete_eo_ptr(), &::efl::eo::_detail::event_callback<::evas::box, function_type>,
         EVAS_OBJECT_EVENT_FOCUS_OUT );
   }

   /// Focus Out Event
   template <typename T>
   void
   callback_focus_out_call(T* info)
   {
      eo_do(_concrete_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_FOCUS_OUT, info));
   }

   /// Object Being Freed (Called after Del)
   template <typename F>
   ::efl::eo::signal_connection
   callback_free_add(F && callback_,
                        ::efl::eo::callback_priority priority_ =
                        ::efl::eo::callback_priorities::default_)
   {
      typedef typename std::remove_reference<F>::type function_type;
      ::std::unique_ptr<function_type> f ( new function_type(std::forward<F>(callback_)) );
      eo_do(_concrete_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_FREE, priority_,
            &::efl::eo::_detail::event_callback<::evas::box, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _concrete_eo_ptr(), &::efl::eo::_detail::event_callback<::evas::box, function_type>,
         EVAS_OBJECT_EVENT_FREE );
   }

   /// Object Being Freed (Called after Del)
   template <typename T>
   void
   callback_free_call(T* info)
   {
      eo_do(_concrete_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_FREE, info));
   }

   /// Hide Event
   template <typename F>
   ::efl::eo::signal_connection
   callback_hide_add(F && callback_,
                        ::efl::eo::callback_priority priority_ =
                        ::efl::eo::callback_priorities::default_)
   {
      typedef typename std::remove_reference<F>::type function_type;
      ::std::unique_ptr<function_type> f ( new function_type(std::forward<F>(callback_)) );
      eo_do(_concrete_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_HIDE, priority_,
            &::efl::eo::_detail::event_callback<::evas::box, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _concrete_eo_ptr(), &::efl::eo::_detail::event_callback<::evas::box, function_type>,
         EVAS_OBJECT_EVENT_HIDE );
   }

   /// Hide Event
   template <typename T>
   void
   callback_hide_call(T* info)
   {
      eo_do(_concrete_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_HIDE, info));
   }

   /// Events go on/off hold
   template <typename F>
   ::efl::eo::signal_connection
   callback_hold_add(F && callback_,
                        ::efl::eo::callback_priority priority_ =
                        ::efl::eo::callback_priorities::default_)
   {
      typedef typename std::remove_reference<F>::type function_type;
      ::std::unique_ptr<function_type> f ( new function_type(std::forward<F>(callback_)) );
      eo_do(_concrete_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_HOLD, priority_,
            &::efl::eo::_detail::event_callback<::evas::box, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _concrete_eo_ptr(), &::efl::eo::_detail::event_callback<::evas::box, function_type>,
         EVAS_OBJECT_EVENT_HOLD );
   }

   /// Events go on/off hold
   template <typename T>
   void
   callback_hold_call(T* info)
   {
      eo_do(_concrete_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_HOLD, info));
   }

   /// Image has been preloaded
   template <typename F>
   ::efl::eo::signal_connection
   callback_image_preloaded_add(F && callback_,
                        ::efl::eo::callback_priority priority_ =
                        ::efl::eo::callback_priorities::default_)
   {
      typedef typename std::remove_reference<F>::type function_type;
      ::std::unique_ptr<function_type> f ( new function_type(std::forward<F>(callback_)) );
      eo_do(_concrete_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_IMAGE_PRELOADED, priority_,
            &::efl::eo::_detail::event_callback<::evas::box, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _concrete_eo_ptr(), &::efl::eo::_detail::event_callback<::evas::box, function_type>,
         EVAS_OBJECT_EVENT_IMAGE_PRELOADED );
   }

   /// Image has been preloaded
   template <typename T>
   void
   callback_image_preloaded_call(T* info)
   {
      eo_do(_concrete_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_IMAGE_PRELOADED, info));
   }

   /// Image resize
   template <typename F>
   ::efl::eo::signal_connection
   callback_image_resize_add(F && callback_,
                        ::efl::eo::callback_priority priority_ =
                        ::efl::eo::callback_priorities::default_)
   {
      typedef typename std::remove_reference<F>::type function_type;
      ::std::unique_ptr<function_type> f ( new function_type(std::forward<F>(callback_)) );
      eo_do(_concrete_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_IMAGE_RESIZE, priority_,
            &::efl::eo::_detail::event_callback<::evas::box, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _concrete_eo_ptr(), &::efl::eo::_detail::event_callback<::evas::box, function_type>,
         EVAS_OBJECT_EVENT_IMAGE_RESIZE );
   }

   /// Image resize
   template <typename T>
   void
   callback_image_resize_call(T* info)
   {
      eo_do(_concrete_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_IMAGE_RESIZE, info));
   }

   /// Image data has been unloaded (by some mechanism in Evas that throw out original image data)
   template <typename F>
   ::efl::eo::signal_connection
   callback_image_unloaded_add(F && callback_,
                        ::efl::eo::callback_priority priority_ =
                        ::efl::eo::callback_priorities::default_)
   {
      typedef typename std::remove_reference<F>::type function_type;
      ::std::unique_ptr<function_type> f ( new function_type(std::forward<F>(callback_)) );
      eo_do(_concrete_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_IMAGE_UNLOADED, priority_,
            &::efl::eo::_detail::event_callback<::evas::box, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _concrete_eo_ptr(), &::efl::eo::_detail::event_callback<::evas::box, function_type>,
         EVAS_OBJECT_EVENT_IMAGE_UNLOADED );
   }

   /// Image data has been unloaded (by some mechanism in Evas that throw out original image data)
   template <typename T>
   void
   callback_image_unloaded_call(T* info)
   {
      eo_do(_concrete_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_IMAGE_UNLOADED, info));
   }

   /// Key Press Event
   template <typename F>
   ::efl::eo::signal_connection
   callback_key_down_add(F && callback_,
                        ::efl::eo::callback_priority priority_ =
                        ::efl::eo::callback_priorities::default_)
   {
      typedef typename std::remove_reference<F>::type function_type;
      ::std::unique_ptr<function_type> f ( new function_type(std::forward<F>(callback_)) );
      eo_do(_concrete_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_KEY_DOWN, priority_,
            &::efl::eo::_detail::event_callback<::evas::box, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _concrete_eo_ptr(), &::efl::eo::_detail::event_callback<::evas::box, function_type>,
         EVAS_OBJECT_EVENT_KEY_DOWN );
   }

   /// Key Press Event
   template <typename T>
   void
   callback_key_down_call(T* info)
   {
      eo_do(_concrete_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_KEY_DOWN, info));
   }

   /// Key Release Event
   template <typename F>
   ::efl::eo::signal_connection
   callback_key_up_add(F && callback_,
                        ::efl::eo::callback_priority priority_ =
                        ::efl::eo::callback_priorities::default_)
   {
      typedef typename std::remove_reference<F>::type function_type;
      ::std::unique_ptr<function_type> f ( new function_type(std::forward<F>(callback_)) );
      eo_do(_concrete_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_KEY_UP, priority_,
            &::efl::eo::_detail::event_callback<::evas::box, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _concrete_eo_ptr(), &::efl::eo::_detail::event_callback<::evas::box, function_type>,
         EVAS_OBJECT_EVENT_KEY_UP );
   }

   /// Key Release Event
   template <typename T>
   void
   callback_key_up_call(T* info)
   {
      eo_do(_concrete_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_KEY_UP, info));
   }

   /// Mouse Button Down Event
   template <typename F>
   ::efl::eo::signal_connection
   callback_mouse_down_add(F && callback_,
                        ::efl::eo::callback_priority priority_ =
                        ::efl::eo::callback_priorities::default_)
   {
      typedef typename std::remove_reference<F>::type function_type;
      ::std::unique_ptr<function_type> f ( new function_type(std::forward<F>(callback_)) );
      eo_do(_concrete_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_MOUSE_DOWN, priority_,
            &::efl::eo::_detail::event_callback<::evas::box, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _concrete_eo_ptr(), &::efl::eo::_detail::event_callback<::evas::box, function_type>,
         EVAS_OBJECT_EVENT_MOUSE_DOWN );
   }

   /// Mouse Button Down Event
   template <typename T>
   void
   callback_mouse_down_call(T* info)
   {
      eo_do(_concrete_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_MOUSE_DOWN, info));
   }

   /// Mouse In Event
   template <typename F>
   ::efl::eo::signal_connection
   callback_mouse_in_add(F && callback_,
                        ::efl::eo::callback_priority priority_ =
                        ::efl::eo::callback_priorities::default_)
   {
      typedef typename std::remove_reference<F>::type function_type;
      ::std::unique_ptr<function_type> f ( new function_type(std::forward<F>(callback_)) );
      eo_do(_concrete_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_MOUSE_IN, priority_,
            &::efl::eo::_detail::event_callback<::evas::box, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _concrete_eo_ptr(), &::efl::eo::_detail::event_callback<::evas::box, function_type>,
         EVAS_OBJECT_EVENT_MOUSE_IN );
   }

   /// Mouse In Event
   template <typename T>
   void
   callback_mouse_in_call(T* info)
   {
      eo_do(_concrete_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_MOUSE_IN, info));
   }

   /// Mouse Move Event
   template <typename F>
   ::efl::eo::signal_connection
   callback_mouse_move_add(F && callback_,
                        ::efl::eo::callback_priority priority_ =
                        ::efl::eo::callback_priorities::default_)
   {
      typedef typename std::remove_reference<F>::type function_type;
      ::std::unique_ptr<function_type> f ( new function_type(std::forward<F>(callback_)) );
      eo_do(_concrete_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_MOUSE_MOVE, priority_,
            &::efl::eo::_detail::event_callback<::evas::box, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _concrete_eo_ptr(), &::efl::eo::_detail::event_callback<::evas::box, function_type>,
         EVAS_OBJECT_EVENT_MOUSE_MOVE );
   }

   /// Mouse Move Event
   template <typename T>
   void
   callback_mouse_move_call(T* info)
   {
      eo_do(_concrete_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_MOUSE_MOVE, info));
   }

   /// Mouse Out Event
   template <typename F>
   ::efl::eo::signal_connection
   callback_mouse_out_add(F && callback_,
                        ::efl::eo::callback_priority priority_ =
                        ::efl::eo::callback_priorities::default_)
   {
      typedef typename std::remove_reference<F>::type function_type;
      ::std::unique_ptr<function_type> f ( new function_type(std::forward<F>(callback_)) );
      eo_do(_concrete_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_MOUSE_OUT, priority_,
            &::efl::eo::_detail::event_callback<::evas::box, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _concrete_eo_ptr(), &::efl::eo::_detail::event_callback<::evas::box, function_type>,
         EVAS_OBJECT_EVENT_MOUSE_OUT );
   }

   /// Mouse Out Event
   template <typename T>
   void
   callback_mouse_out_call(T* info)
   {
      eo_do(_concrete_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_MOUSE_OUT, info));
   }

   /// Mouse Button Up Event
   template <typename F>
   ::efl::eo::signal_connection
   callback_mouse_up_add(F && callback_,
                        ::efl::eo::callback_priority priority_ =
                        ::efl::eo::callback_priorities::default_)
   {
      typedef typename std::remove_reference<F>::type function_type;
      ::std::unique_ptr<function_type> f ( new function_type(std::forward<F>(callback_)) );
      eo_do(_concrete_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_MOUSE_UP, priority_,
            &::efl::eo::_detail::event_callback<::evas::box, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _concrete_eo_ptr(), &::efl::eo::_detail::event_callback<::evas::box, function_type>,
         EVAS_OBJECT_EVENT_MOUSE_UP );
   }

   /// Mouse Button Up Event
   template <typename T>
   void
   callback_mouse_up_call(T* info)
   {
      eo_do(_concrete_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_MOUSE_UP, info));
   }

   /// Mouse Wheel Event
   template <typename F>
   ::efl::eo::signal_connection
   callback_mouse_wheel_add(F && callback_,
                        ::efl::eo::callback_priority priority_ =
                        ::efl::eo::callback_priorities::default_)
   {
      typedef typename std::remove_reference<F>::type function_type;
      ::std::unique_ptr<function_type> f ( new function_type(std::forward<F>(callback_)) );
      eo_do(_concrete_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_MOUSE_WHEEL, priority_,
            &::efl::eo::_detail::event_callback<::evas::box, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _concrete_eo_ptr(), &::efl::eo::_detail::event_callback<::evas::box, function_type>,
         EVAS_OBJECT_EVENT_MOUSE_WHEEL );
   }

   /// Mouse Wheel Event
   template <typename T>
   void
   callback_mouse_wheel_call(T* info)
   {
      eo_do(_concrete_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_MOUSE_WHEEL, info));
   }

   /// Move Event
   template <typename F>
   ::efl::eo::signal_connection
   callback_move_add(F && callback_,
                        ::efl::eo::callback_priority priority_ =
                        ::efl::eo::callback_priorities::default_)
   {
      typedef typename std::remove_reference<F>::type function_type;
      ::std::unique_ptr<function_type> f ( new function_type(std::forward<F>(callback_)) );
      eo_do(_concrete_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_MOVE, priority_,
            &::efl::eo::_detail::event_callback<::evas::box, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _concrete_eo_ptr(), &::efl::eo::_detail::event_callback<::evas::box, function_type>,
         EVAS_OBJECT_EVENT_MOVE );
   }

   /// Move Event
   template <typename T>
   void
   callback_move_call(T* info)
   {
      eo_do(_concrete_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_MOVE, info));
   }

   /// Mouse-touch Down Event
   template <typename F>
   ::efl::eo::signal_connection
   callback_multi_down_add(F && callback_,
                        ::efl::eo::callback_priority priority_ =
                        ::efl::eo::callback_priorities::default_)
   {
      typedef typename std::remove_reference<F>::type function_type;
      ::std::unique_ptr<function_type> f ( new function_type(std::forward<F>(callback_)) );
      eo_do(_concrete_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_MULTI_DOWN, priority_,
            &::efl::eo::_detail::event_callback<::evas::box, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _concrete_eo_ptr(), &::efl::eo::_detail::event_callback<::evas::box, function_type>,
         EVAS_OBJECT_EVENT_MULTI_DOWN );
   }

   /// Mouse-touch Down Event
   template <typename T>
   void
   callback_multi_down_call(T* info)
   {
      eo_do(_concrete_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_MULTI_DOWN, info));
   }

   /// Multi-touch Move Event
   template <typename F>
   ::efl::eo::signal_connection
   callback_multi_move_add(F && callback_,
                        ::efl::eo::callback_priority priority_ =
                        ::efl::eo::callback_priorities::default_)
   {
      typedef typename std::remove_reference<F>::type function_type;
      ::std::unique_ptr<function_type> f ( new function_type(std::forward<F>(callback_)) );
      eo_do(_concrete_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_MULTI_MOVE, priority_,
            &::efl::eo::_detail::event_callback<::evas::box, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _concrete_eo_ptr(), &::efl::eo::_detail::event_callback<::evas::box, function_type>,
         EVAS_OBJECT_EVENT_MULTI_MOVE );
   }

   /// Multi-touch Move Event
   template <typename T>
   void
   callback_multi_move_call(T* info)
   {
      eo_do(_concrete_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_MULTI_MOVE, info));
   }

   /// Mouse-touch Up Event
   template <typename F>
   ::efl::eo::signal_connection
   callback_multi_up_add(F && callback_,
                        ::efl::eo::callback_priority priority_ =
                        ::efl::eo::callback_priorities::default_)
   {
      typedef typename std::remove_reference<F>::type function_type;
      ::std::unique_ptr<function_type> f ( new function_type(std::forward<F>(callback_)) );
      eo_do(_concrete_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_MULTI_UP, priority_,
            &::efl::eo::_detail::event_callback<::evas::box, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _concrete_eo_ptr(), &::efl::eo::_detail::event_callback<::evas::box, function_type>,
         EVAS_OBJECT_EVENT_MULTI_UP );
   }

   /// Mouse-touch Up Event
   template <typename T>
   void
   callback_multi_up_call(T* info)
   {
      eo_do(_concrete_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_MULTI_UP, info));
   }

   /// Resize Event
   template <typename F>
   ::efl::eo::signal_connection
   callback_resize_add(F && callback_,
                        ::efl::eo::callback_priority priority_ =
                        ::efl::eo::callback_priorities::default_)
   {
      typedef typename std::remove_reference<F>::type function_type;
      ::std::unique_ptr<function_type> f ( new function_type(std::forward<F>(callback_)) );
      eo_do(_concrete_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_RESIZE, priority_,
            &::efl::eo::_detail::event_callback<::evas::box, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _concrete_eo_ptr(), &::efl::eo::_detail::event_callback<::evas::box, function_type>,
         EVAS_OBJECT_EVENT_RESIZE );
   }

   /// Resize Event
   template <typename T>
   void
   callback_resize_call(T* info)
   {
      eo_do(_concrete_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_RESIZE, info));
   }

   /// Restack Event
   template <typename F>
   ::efl::eo::signal_connection
   callback_restack_add(F && callback_,
                        ::efl::eo::callback_priority priority_ =
                        ::efl::eo::callback_priorities::default_)
   {
      typedef typename std::remove_reference<F>::type function_type;
      ::std::unique_ptr<function_type> f ( new function_type(std::forward<F>(callback_)) );
      eo_do(_concrete_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_RESTACK, priority_,
            &::efl::eo::_detail::event_callback<::evas::box, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _concrete_eo_ptr(), &::efl::eo::_detail::event_callback<::evas::box, function_type>,
         EVAS_OBJECT_EVENT_RESTACK );
   }

   /// Restack Event
   template <typename T>
   void
   callback_restack_call(T* info)
   {
      eo_do(_concrete_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_RESTACK, info));
   }

   /// Show Event
   template <typename F>
   ::efl::eo::signal_connection
   callback_show_add(F && callback_,
                        ::efl::eo::callback_priority priority_ =
                        ::efl::eo::callback_priorities::default_)
   {
      typedef typename std::remove_reference<F>::type function_type;
      ::std::unique_ptr<function_type> f ( new function_type(std::forward<F>(callback_)) );
      eo_do(_concrete_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_SHOW, priority_,
            &::efl::eo::_detail::event_callback<::evas::box, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _concrete_eo_ptr(), &::efl::eo::_detail::event_callback<::evas::box, function_type>,
         EVAS_OBJECT_EVENT_SHOW );
   }

   /// Show Event
   template <typename T>
   void
   callback_show_call(T* info)
   {
      eo_do(_concrete_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_SHOW, info));
   }



   static Eo_Class const* _eo_class()
   {
      return(EVAS_BOX_CLASS);
   }

   /// @cond LOCAL
   struct address_of
      : ::eo_cxx::evas::box::address_of<address_of>
      , ::eo_cxx::efl::gfx::base::address_of<address_of>
      , ::eo_cxx::efl::gfx::stack::address_of<address_of>
      , ::eo_cxx::eo::base::address_of<address_of>
      , ::eo_cxx::evas::common_interface::address_of<address_of>
      , ::eo_cxx::evas::object::address_of<address_of>
      , ::eo_cxx::evas::object_smart::address_of<address_of>
      , ::eo_cxx::evas::signal_interface::address_of<address_of>
      , ::eo_cxx::evas::smart_clipped::address_of<address_of>
      , ::efl::eo::detail::concrete_address_of
   {
      explicit address_of(::evas::box* p)
         : ::efl::eo::detail::concrete_address_of(p)
      {}
   };
   address_of operator&() { return address_of(this); }

   struct address_const_of
      : ::eo_cxx::evas::box::address_const_of<address_const_of>
      , ::eo_cxx::efl::gfx::base::address_const_of<address_const_of>
      , ::eo_cxx::efl::gfx::stack::address_const_of<address_const_of>
      , ::eo_cxx::eo::base::address_const_of<address_const_of>
      , ::eo_cxx::evas::common_interface::address_const_of<address_const_of>
      , ::eo_cxx::evas::object::address_const_of<address_const_of>
      , ::eo_cxx::evas::object_smart::address_const_of<address_const_of>
      , ::eo_cxx::evas::signal_interface::address_const_of<address_const_of>
      , ::eo_cxx::evas::smart_clipped::address_const_of<address_const_of>
      , ::efl::eo::detail::concrete_address_const_of
   {
      explicit address_const_of(::evas::box const* p)
         : ::efl::eo::detail::concrete_address_const_of(p)
      {}
   };
   address_const_of operator&() const { return address_const_of(this); }

   /// @endcond

private:

   /// @internal
   static Eo* _ctors_call(::efl::eo::parent_type _p)
   {
      Eo* _ret_eo = eo_add_ref(EVAS_BOX_CLASS, _p._eo_raw);

      return _ret_eo;
   }

   /// @internal
   Eo* _concrete_eo_ptr() const { return _eo_ptr(); }
};

static_assert(sizeof(::evas::box) == sizeof(Eo*), "");
static_assert(std::is_standard_layout<::evas::box>::value, "");

}


#include "evas_box.eo.impl.hh"

#endif // EFL_GENERATED_EVAS_BOX_HH

