#ifndef EFL_GENERATED_EVAS_BOX_HH
#define EFL_GENERATED_EVAS_BOX_HH

#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
      : evas::smart_clipped
{
   /// @brief Eo Constructor.
   ///
   /// Constructs the object from an Eo* pointer stealing its ownership.
   ///
   /// @param eo The Eo object pointer.
   ///
   explicit box(Eo* eo)
      : evas::smart_clipped(eo)
   {}

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

   box(efl::eo::parent_type _p = (efl::eo::parent = nullptr))
      : box(_c0(_p))
   {}

   /// @brief Copy Constructor.
   ///
   box(box const& other)
      : evas::smart_clipped(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
   {
      eo_do(_eo_ptr(), ::evas_obj_box_layout_horizontal(priv_, data_));
   }

   /// @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
   {
      eo_do(_eo_ptr(), ::evas_obj_box_layout_vertical(priv_, data_));
   }

   /// @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
   {
      eo_do(_eo_ptr(), ::evas_obj_box_layout_homogeneous_max_size_horizontal(priv_, data_));
   }

   /// @brief No description supplied by the EAPI.
   ///
   /// @param child 
   ///
   evas::object internal_remove(evas::object child_) const
   {
      Evas_Object * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_box_internal_remove(efl::eolian::to_c(child_)));
      return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @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
   {
      eo_do(_eo_ptr(), ::evas_obj_box_layout_flow_vertical(priv_, data_));
   }

   /// @brief No description supplied by the EAPI.
   ///
   /// @param opt 
   ///
   void internal_option_free(Evas_Object_Box_Option * opt_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_box_internal_option_free(opt_));
   }

   /// @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
   {
      Evas_Object_Box_Option * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_box_insert_after(efl::eolian::to_c(child_), reference_));
      return _tmp_ret;
   }

   /// @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
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_box_remove_all(efl::eolian::to_c(clear_)));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @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
   {
      Eina_Iterator * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_box_iterator_new());
      return _tmp_ret;
   }

   /// @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
   {
      Evas_Object * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_box_add_to());
      return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @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
   {
      Evas_Object_Box_Option * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_box_append(efl::eolian::to_c(child_)));
      return _tmp_ret;
   }

   /// @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(std::string name_) const
   {
      int _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_box_option_property_id_get(efl::eolian::to_c(name_)));
      return _tmp_ret;
   }

   /// @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
   {
      Evas_Object_Box_Option * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_box_prepend(efl::eolian::to_c(child_)));
      return _tmp_ret;
   }

   /// @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
   {
      Eina_Accessor * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_box_accessor_new());
      return _tmp_ret;
   }

   /// @brief No description supplied by the EAPI.
   ///
   /// @param child 
   ///
   Evas_Object_Box_Option * internal_append(evas::object child_) const
   {
      Evas_Object_Box_Option * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_box_internal_append(efl::eolian::to_c(child_)));
      return _tmp_ret;
   }

   /// @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
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_box_option_property_vset(opt_, property_, args_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief No description supplied by the EAPI.
   ///
   /// @param pos 
   ///
   evas::object internal_remove_at(unsigned int pos_) const
   {
      Evas_Object * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_box_internal_remove_at(pos_));
      return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @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
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_box_remove_at(pos_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @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
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_box_option_property_vget(opt_, property_, args_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @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
   {
      Evas_Object_Box_Option * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_box_internal_insert_at(efl::eolian::to_c(child_), pos_));
      return _tmp_ret;
   }

   /// @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
   {
      Evas_Object_Box_Option * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_box_insert_before(efl::eolian::to_c(child_), reference_));
      return _tmp_ret;
   }

   /// @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
   ///
   std::string option_property_name_get(int property_) const
   {
      const char * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_box_option_property_name_get(property_));
      return efl::eolian::to_cxx<std::string>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @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
   {
      Evas_Object_Box_Option * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_box_internal_insert_before(efl::eolian::to_c(child_), reference_));
      return _tmp_ret;
   }

   /// @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
   {
      eo_do(_eo_ptr(), ::evas_obj_box_layout_homogeneous_horizontal(priv_, data_));
   }

   /// @brief No description supplied by the EAPI.
   ///
   /// @param child 
   ///
   Evas_Object_Box_Option * internal_option_new(evas::object child_) const
   {
      Evas_Object_Box_Option * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_box_internal_option_new(efl::eolian::to_c(child_)));
      return _tmp_ret;
   }

   /// @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
   {
      eo_do(_eo_ptr(), ::evas_obj_box_layout_homogeneous_max_size_vertical(priv_, data_));
   }

   /// @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
   {
      Evas_Object_Box_Option * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_box_internal_insert_after(efl::eolian::to_c(child_), reference_));
      return _tmp_ret;
   }

   /// @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
   {
      Evas_Object_Box_Option * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_box_insert_at(efl::eolian::to_c(child_), pos_));
      return _tmp_ret;
   }

   /// @brief No description supplied by the EAPI.
   ///
   /// @param child 
   ///
   Evas_Object_Box_Option * internal_prepend(evas::object child_) const
   {
      Evas_Object_Box_Option * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_box_internal_prepend(efl::eolian::to_c(child_)));
      return _tmp_ret;
   }

   /// @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
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_box_remove(efl::eolian::to_c(child_)));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @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
   {
      eo_do(_eo_ptr(), ::evas_obj_box_layout_stack(priv_, data_));
   }

   /// @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
   {
      eo_do(_eo_ptr(), ::evas_obj_box_layout_homogeneous_vertical(priv_, data_));
   }

   /// @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
   {
      eo_do(_eo_ptr(), ::evas_obj_box_layout_flow_horizontal(priv_, data_));
   }

   /// @param horizontal The horizontal alignment, in pixels
   /// @param vertical the vertical alignment, in pixels
   ///
   void align_get(double* horizontal_, double* vertical_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_box_align_get(horizontal_, vertical_));
   }

   /// @param horizontal The horizontal alignment, in pixels
   /// @param vertical the vertical alignment, in pixels
   ///
   void align_set(double horizontal_, double vertical_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_box_align_set(horizontal_, vertical_));
   }

   /// @param horizontal The horizontal padding, in pixels
   /// @param vertical the vertical padding, in pixels
   ///
   void padding_get(Evas_Coord* horizontal_, Evas_Coord* vertical_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_box_padding_get(horizontal_, vertical_));
   }

   /// @param horizontal The horizontal padding, in pixels
   /// @param vertical the vertical padding, in pixels
   ///
   void padding_set(Evas_Coord horizontal_, Evas_Coord vertical_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_box_padding_set(horizontal_, vertical_));
   }

   /// @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
   {
      eo_do(_eo_ptr(), ::evas_obj_box_layout_set(cb_, data_, free_data_));
   }

   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::move(callback_)) );
      eo_do(_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, _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(_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::move(callback_)) );
      eo_do(_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, _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(_eo_ptr(), eo_event_callback_call
            (EVAS_BOX_EVENT_CHILD_REMOVED, info));
   }
   static Eo_Class const* _eo_class()
   {
      return(EVAS_BOX_CLASS);
   }

private:
   static Eo* _c0(efl::eo::parent_type _p)
   {
      return eo_add_custom(EVAS_BOX_CLASS, _p._eo_raw, eo_constructor());
   }

};
} 

template <typename T>
void evas_box_layout_horizontal_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Object_Box_Data * priv_, void * data_)
{
   static_cast<T*>(self->this_)->layout_horizontal(priv_, data_);
}

template <typename T>
void evas_box_layout_vertical_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Object_Box_Data * priv_, void * data_)
{
   static_cast<T*>(self->this_)->layout_vertical(priv_, data_);
}

template <typename T>
void evas_box_layout_homogeneous_max_size_horizontal_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Object_Box_Data * priv_, void * data_)
{
   static_cast<T*>(self->this_)->layout_homogeneous_max_size_horizontal(priv_, data_);
}

template <typename T>
evas::object evas_box_internal_remove_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Object * child_)
{
   return static_cast<T*>(self->this_)->internal_remove(efl::eolian::to_cxx<evas::object>(child_, std::tuple<std::false_type>()));
}

template <typename T>
void evas_box_layout_flow_vertical_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Object_Box_Data * priv_, void * data_)
{
   static_cast<T*>(self->this_)->layout_flow_vertical(priv_, data_);
}

template <typename T>
void evas_box_internal_option_free_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Object_Box_Option * opt_)
{
   static_cast<T*>(self->this_)->internal_option_free(opt_);
}

template <typename T>
Evas_Object_Box_Option * evas_box_insert_after_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Object * child_, const Evas_Object * reference_)
{
   return static_cast<T*>(self->this_)->insert_after(efl::eolian::to_cxx<evas::object>(child_, std::tuple<std::false_type>()), reference_);
}

template <typename T>
bool evas_box_remove_all_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Eina_Bool clear_)
{
   return static_cast<T*>(self->this_)->remove_all(efl::eolian::to_cxx<bool>(clear_, std::tuple<std::false_type>()));
}

template <typename T>
Eina_Iterator * evas_box_iterator_new_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self)
{
   return static_cast<T*>(self->this_)->iterator_new();
}

template <typename T>
evas::object evas_box_add_to_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self)
{
   return static_cast<T*>(self->this_)->add_to();
}

template <typename T>
Evas_Object_Box_Option * evas_box_append_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Object * child_)
{
   return static_cast<T*>(self->this_)->append(efl::eolian::to_cxx<evas::object>(child_, std::tuple<std::false_type>()));
}

template <typename T>
int evas_box_option_property_id_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * name_)
{
   return static_cast<T*>(self->this_)->option_property_id_get(efl::eolian::to_cxx<std::string>(name_, std::tuple<std::false_type>()));
}

template <typename T>
Evas_Object_Box_Option * evas_box_prepend_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Object * child_)
{
   return static_cast<T*>(self->this_)->prepend(efl::eolian::to_cxx<evas::object>(child_, std::tuple<std::false_type>()));
}

template <typename T>
Eina_Accessor * evas_box_accessor_new_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self)
{
   return static_cast<T*>(self->this_)->accessor_new();
}

template <typename T>
Evas_Object_Box_Option * evas_box_internal_append_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Object * child_)
{
   return static_cast<T*>(self->this_)->internal_append(efl::eolian::to_cxx<evas::object>(child_, std::tuple<std::false_type>()));
}

template <typename T>
bool evas_box_option_property_vset_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Object_Box_Option * opt_, int property_, va_list * args_)
{
   return static_cast<T*>(self->this_)->option_property_vset(opt_, property_, args_);
}

template <typename T>
evas::object evas_box_internal_remove_at_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, unsigned int pos_)
{
   return static_cast<T*>(self->this_)->internal_remove_at(pos_);
}

template <typename T>
bool evas_box_remove_at_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, unsigned int pos_)
{
   return static_cast<T*>(self->this_)->remove_at(pos_);
}

template <typename T>
bool evas_box_option_property_vget_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Object_Box_Option * opt_, int property_, va_list * args_)
{
   return static_cast<T*>(self->this_)->option_property_vget(opt_, property_, args_);
}

template <typename T>
Evas_Object_Box_Option * evas_box_internal_insert_at_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Object * child_, unsigned int pos_)
{
   return static_cast<T*>(self->this_)->internal_insert_at(efl::eolian::to_cxx<evas::object>(child_, std::tuple<std::false_type>()), pos_);
}

template <typename T>
Evas_Object_Box_Option * evas_box_insert_before_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Object * child_, const Evas_Object * reference_)
{
   return static_cast<T*>(self->this_)->insert_before(efl::eolian::to_cxx<evas::object>(child_, std::tuple<std::false_type>()), reference_);
}

template <typename T>
std::string evas_box_option_property_name_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, int property_)
{
   return static_cast<T*>(self->this_)->option_property_name_get(property_);
}

template <typename T>
Evas_Object_Box_Option * evas_box_internal_insert_before_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Object * child_, const Evas_Object * reference_)
{
   return static_cast<T*>(self->this_)->internal_insert_before(efl::eolian::to_cxx<evas::object>(child_, std::tuple<std::false_type>()), reference_);
}

template <typename T>
void evas_box_layout_homogeneous_horizontal_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Object_Box_Data * priv_, void * data_)
{
   static_cast<T*>(self->this_)->layout_homogeneous_horizontal(priv_, data_);
}

template <typename T>
Evas_Object_Box_Option * evas_box_internal_option_new_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Object * child_)
{
   return static_cast<T*>(self->this_)->internal_option_new(efl::eolian::to_cxx<evas::object>(child_, std::tuple<std::false_type>()));
}

template <typename T>
void evas_box_layout_homogeneous_max_size_vertical_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Object_Box_Data * priv_, void * data_)
{
   static_cast<T*>(self->this_)->layout_homogeneous_max_size_vertical(priv_, data_);
}

template <typename T>
Evas_Object_Box_Option * evas_box_internal_insert_after_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Object * child_, const Evas_Object * reference_)
{
   return static_cast<T*>(self->this_)->internal_insert_after(efl::eolian::to_cxx<evas::object>(child_, std::tuple<std::false_type>()), reference_);
}

template <typename T>
Evas_Object_Box_Option * evas_box_insert_at_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Object * child_, unsigned int pos_)
{
   return static_cast<T*>(self->this_)->insert_at(efl::eolian::to_cxx<evas::object>(child_, std::tuple<std::false_type>()), pos_);
}

template <typename T>
Evas_Object_Box_Option * evas_box_internal_prepend_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Object * child_)
{
   return static_cast<T*>(self->this_)->internal_prepend(efl::eolian::to_cxx<evas::object>(child_, std::tuple<std::false_type>()));
}

template <typename T>
bool evas_box_remove_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Object * child_)
{
   return static_cast<T*>(self->this_)->remove(efl::eolian::to_cxx<evas::object>(child_, std::tuple<std::false_type>()));
}

template <typename T>
void evas_box_layout_stack_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Object_Box_Data * priv_, void * data_)
{
   static_cast<T*>(self->this_)->layout_stack(priv_, data_);
}

template <typename T>
void evas_box_layout_homogeneous_vertical_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Object_Box_Data * priv_, void * data_)
{
   static_cast<T*>(self->this_)->layout_homogeneous_vertical(priv_, data_);
}

template <typename T>
void evas_box_layout_flow_horizontal_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Object_Box_Data * priv_, void * data_)
{
   static_cast<T*>(self->this_)->layout_flow_horizontal(priv_, data_);
}

template <typename T>
void evas_box_align_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, double* horizontal_, double* vertical_)
{
   static_cast<T*>(self->this_)->align_get(horizontal_, vertical_);
}

template <typename T>
void evas_box_align_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, double horizontal_, double vertical_)
{
   static_cast<T*>(self->this_)->align_set(horizontal_, vertical_);
}

template <typename T>
void evas_box_padding_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Coord* horizontal_, Evas_Coord* vertical_)
{
   static_cast<T*>(self->this_)->padding_get(horizontal_, vertical_);
}

template <typename T>
void evas_box_padding_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Coord horizontal_, Evas_Coord vertical_)
{
   static_cast<T*>(self->this_)->padding_set(horizontal_, vertical_);
}

template <typename T>
void evas_box_layout_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Object_Box_Layout cb_, const void * data_, Eina_Free_Cb free_data_)
{
   static_cast<T*>(self->this_)->layout_set(cb_, data_, free_data_);
}

namespace efl { namespace eo { namespace detail {

template<>
struct operations< evas::box >
{
   template <typename T>
   struct type
   {
      virtual void layout_horizontal(Evas_Object_Box_Data * priv_, void * data_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_box_layout_horizontal(priv_, data_));
      }

      virtual void layout_vertical(Evas_Object_Box_Data * priv_, void * data_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_box_layout_vertical(priv_, data_));
      }

      virtual void layout_homogeneous_max_size_horizontal(Evas_Object_Box_Data * priv_, void * data_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_box_layout_homogeneous_max_size_horizontal(priv_, data_));
      }

      virtual evas::object internal_remove(evas::object child_)
      {
         Evas_Object * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_box_internal_remove(efl::eolian::to_c(child_)));
            return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void layout_flow_vertical(Evas_Object_Box_Data * priv_, void * data_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_box_layout_flow_vertical(priv_, data_));
      }

      virtual void internal_option_free(Evas_Object_Box_Option * opt_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_box_internal_option_free(opt_));
      }

      virtual Evas_Object_Box_Option * insert_after(evas::object child_, const Evas_Object * reference_)
      {
         Evas_Object_Box_Option * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_box_insert_after(efl::eolian::to_c(child_), reference_));
            return _tmp_ret;
      }

      virtual bool remove_all(bool clear_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_box_remove_all(efl::eolian::to_c(clear_)));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual Eina_Iterator * iterator_new()
      {
         Eina_Iterator * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_box_iterator_new());
            return _tmp_ret;
      }

      virtual evas::object add_to()
      {
         Evas_Object * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_box_add_to());
            return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual Evas_Object_Box_Option * append(evas::object child_)
      {
         Evas_Object_Box_Option * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_box_append(efl::eolian::to_c(child_)));
            return _tmp_ret;
      }

      virtual int option_property_id_get(std::string name_)
      {
         int _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_box_option_property_id_get(efl::eolian::to_c(name_)));
            return _tmp_ret;
      }

      virtual Evas_Object_Box_Option * prepend(evas::object child_)
      {
         Evas_Object_Box_Option * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_box_prepend(efl::eolian::to_c(child_)));
            return _tmp_ret;
      }

      virtual Eina_Accessor * accessor_new()
      {
         Eina_Accessor * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_box_accessor_new());
            return _tmp_ret;
      }

      virtual Evas_Object_Box_Option * internal_append(evas::object child_)
      {
         Evas_Object_Box_Option * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_box_internal_append(efl::eolian::to_c(child_)));
            return _tmp_ret;
      }

      virtual bool option_property_vset(Evas_Object_Box_Option * opt_, int property_, va_list * args_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_box_option_property_vset(opt_, property_, args_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual evas::object internal_remove_at(unsigned int pos_)
      {
         Evas_Object * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_box_internal_remove_at(pos_));
            return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual bool remove_at(unsigned int pos_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_box_remove_at(pos_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual bool option_property_vget(Evas_Object_Box_Option * opt_, int property_, va_list * args_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_box_option_property_vget(opt_, property_, args_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual Evas_Object_Box_Option * internal_insert_at(evas::object child_, unsigned int pos_)
      {
         Evas_Object_Box_Option * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_box_internal_insert_at(efl::eolian::to_c(child_), pos_));
            return _tmp_ret;
      }

      virtual Evas_Object_Box_Option * insert_before(evas::object child_, const Evas_Object * reference_)
      {
         Evas_Object_Box_Option * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_box_insert_before(efl::eolian::to_c(child_), reference_));
            return _tmp_ret;
      }

      virtual std::string option_property_name_get(int property_)
      {
         const char * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_box_option_property_name_get(property_));
            return efl::eolian::to_cxx<std::string>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual Evas_Object_Box_Option * internal_insert_before(evas::object child_, const Evas_Object * reference_)
      {
         Evas_Object_Box_Option * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_box_internal_insert_before(efl::eolian::to_c(child_), reference_));
            return _tmp_ret;
      }

      virtual void layout_homogeneous_horizontal(Evas_Object_Box_Data * priv_, void * data_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_box_layout_homogeneous_horizontal(priv_, data_));
      }

      virtual Evas_Object_Box_Option * internal_option_new(evas::object child_)
      {
         Evas_Object_Box_Option * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_box_internal_option_new(efl::eolian::to_c(child_)));
            return _tmp_ret;
      }

      virtual void layout_homogeneous_max_size_vertical(Evas_Object_Box_Data * priv_, void * data_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_box_layout_homogeneous_max_size_vertical(priv_, data_));
      }

      virtual Evas_Object_Box_Option * internal_insert_after(evas::object child_, const Evas_Object * reference_)
      {
         Evas_Object_Box_Option * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_box_internal_insert_after(efl::eolian::to_c(child_), reference_));
            return _tmp_ret;
      }

      virtual Evas_Object_Box_Option * insert_at(evas::object child_, unsigned int pos_)
      {
         Evas_Object_Box_Option * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_box_insert_at(efl::eolian::to_c(child_), pos_));
            return _tmp_ret;
      }

      virtual Evas_Object_Box_Option * internal_prepend(evas::object child_)
      {
         Evas_Object_Box_Option * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_box_internal_prepend(efl::eolian::to_c(child_)));
            return _tmp_ret;
      }

      virtual bool remove(evas::object child_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_box_remove(efl::eolian::to_c(child_)));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void layout_stack(Evas_Object_Box_Data * priv_, void * data_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_box_layout_stack(priv_, data_));
      }

      virtual void layout_homogeneous_vertical(Evas_Object_Box_Data * priv_, void * data_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_box_layout_homogeneous_vertical(priv_, data_));
      }

      virtual void layout_flow_horizontal(Evas_Object_Box_Data * priv_, void * data_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_box_layout_flow_horizontal(priv_, data_));
      }

      virtual void align_get(double* horizontal_, double* vertical_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_box_align_get(horizontal_, vertical_));
      }

      virtual void align_set(double horizontal_, double vertical_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_box_align_set(horizontal_, vertical_));
      }

      virtual void padding_get(Evas_Coord* horizontal_, Evas_Coord* vertical_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_box_padding_get(horizontal_, vertical_));
      }

      virtual void padding_set(Evas_Coord horizontal_, Evas_Coord vertical_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_box_padding_set(horizontal_, vertical_));
      }

      virtual void layout_set(Evas_Object_Box_Layout cb_, const void * data_, Eina_Free_Cb free_data_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_box_layout_set(cb_, data_, free_data_));
      }

   };
};


template<>
struct operation_description_class_size< evas::box >
{
   static const int value = 38;
};

template <typename T>
int initialize_operation_description(efl::eo::detail::tag<evas::box>
                                 , Eo_Op_Description* ops)
{
   (void)ops;
   ops[0].func = reinterpret_cast<void*>(& ::evas_box_layout_horizontal_wrapper<T>);
   ops[0].api_func = reinterpret_cast<void*>(& ::evas_obj_box_layout_horizontal);
   ops[0].op = EO_OP_OVERRIDE;
   ops[0].op_type = EO_OP_TYPE_REGULAR;
   ops[0].doc = NULL;

   ops[1].func = reinterpret_cast<void*>(& ::evas_box_layout_vertical_wrapper<T>);
   ops[1].api_func = reinterpret_cast<void*>(& ::evas_obj_box_layout_vertical);
   ops[1].op = EO_OP_OVERRIDE;
   ops[1].op_type = EO_OP_TYPE_REGULAR;
   ops[1].doc = NULL;

   ops[2].func = reinterpret_cast<void*>(& ::evas_box_layout_homogeneous_max_size_horizontal_wrapper<T>);
   ops[2].api_func = reinterpret_cast<void*>(& ::evas_obj_box_layout_homogeneous_max_size_horizontal);
   ops[2].op = EO_OP_OVERRIDE;
   ops[2].op_type = EO_OP_TYPE_REGULAR;
   ops[2].doc = NULL;

   ops[3].func = reinterpret_cast<void*>(& ::evas_box_internal_remove_wrapper<T>);
   ops[3].api_func = reinterpret_cast<void*>(& ::evas_obj_box_internal_remove);
   ops[3].op = EO_OP_OVERRIDE;
   ops[3].op_type = EO_OP_TYPE_REGULAR;
   ops[3].doc = NULL;

   ops[4].func = reinterpret_cast<void*>(& ::evas_box_layout_flow_vertical_wrapper<T>);
   ops[4].api_func = reinterpret_cast<void*>(& ::evas_obj_box_layout_flow_vertical);
   ops[4].op = EO_OP_OVERRIDE;
   ops[4].op_type = EO_OP_TYPE_REGULAR;
   ops[4].doc = NULL;

   ops[5].func = reinterpret_cast<void*>(& ::evas_box_internal_option_free_wrapper<T>);
   ops[5].api_func = reinterpret_cast<void*>(& ::evas_obj_box_internal_option_free);
   ops[5].op = EO_OP_OVERRIDE;
   ops[5].op_type = EO_OP_TYPE_REGULAR;
   ops[5].doc = NULL;

   ops[6].func = reinterpret_cast<void*>(& ::evas_box_insert_after_wrapper<T>);
   ops[6].api_func = reinterpret_cast<void*>(& ::evas_obj_box_insert_after);
   ops[6].op = EO_OP_OVERRIDE;
   ops[6].op_type = EO_OP_TYPE_REGULAR;
   ops[6].doc = NULL;

   ops[7].func = reinterpret_cast<void*>(& ::evas_box_remove_all_wrapper<T>);
   ops[7].api_func = reinterpret_cast<void*>(& ::evas_obj_box_remove_all);
   ops[7].op = EO_OP_OVERRIDE;
   ops[7].op_type = EO_OP_TYPE_REGULAR;
   ops[7].doc = NULL;

   ops[8].func = reinterpret_cast<void*>(& ::evas_box_iterator_new_wrapper<T>);
   ops[8].api_func = reinterpret_cast<void*>(& ::evas_obj_box_iterator_new);
   ops[8].op = EO_OP_OVERRIDE;
   ops[8].op_type = EO_OP_TYPE_REGULAR;
   ops[8].doc = NULL;

   ops[9].func = reinterpret_cast<void*>(& ::evas_box_add_to_wrapper<T>);
   ops[9].api_func = reinterpret_cast<void*>(& ::evas_obj_box_add_to);
   ops[9].op = EO_OP_OVERRIDE;
   ops[9].op_type = EO_OP_TYPE_REGULAR;
   ops[9].doc = NULL;

   ops[10].func = reinterpret_cast<void*>(& ::evas_box_append_wrapper<T>);
   ops[10].api_func = reinterpret_cast<void*>(& ::evas_obj_box_append);
   ops[10].op = EO_OP_OVERRIDE;
   ops[10].op_type = EO_OP_TYPE_REGULAR;
   ops[10].doc = NULL;

   ops[11].func = reinterpret_cast<void*>(& ::evas_box_option_property_id_get_wrapper<T>);
   ops[11].api_func = reinterpret_cast<void*>(& ::evas_obj_box_option_property_id_get);
   ops[11].op = EO_OP_OVERRIDE;
   ops[11].op_type = EO_OP_TYPE_REGULAR;
   ops[11].doc = NULL;

   ops[12].func = reinterpret_cast<void*>(& ::evas_box_prepend_wrapper<T>);
   ops[12].api_func = reinterpret_cast<void*>(& ::evas_obj_box_prepend);
   ops[12].op = EO_OP_OVERRIDE;
   ops[12].op_type = EO_OP_TYPE_REGULAR;
   ops[12].doc = NULL;

   ops[13].func = reinterpret_cast<void*>(& ::evas_box_accessor_new_wrapper<T>);
   ops[13].api_func = reinterpret_cast<void*>(& ::evas_obj_box_accessor_new);
   ops[13].op = EO_OP_OVERRIDE;
   ops[13].op_type = EO_OP_TYPE_REGULAR;
   ops[13].doc = NULL;

   ops[14].func = reinterpret_cast<void*>(& ::evas_box_internal_append_wrapper<T>);
   ops[14].api_func = reinterpret_cast<void*>(& ::evas_obj_box_internal_append);
   ops[14].op = EO_OP_OVERRIDE;
   ops[14].op_type = EO_OP_TYPE_REGULAR;
   ops[14].doc = NULL;

   ops[15].func = reinterpret_cast<void*>(& ::evas_box_option_property_vset_wrapper<T>);
   ops[15].api_func = reinterpret_cast<void*>(& ::evas_obj_box_option_property_vset);
   ops[15].op = EO_OP_OVERRIDE;
   ops[15].op_type = EO_OP_TYPE_REGULAR;
   ops[15].doc = NULL;

   ops[16].func = reinterpret_cast<void*>(& ::evas_box_internal_remove_at_wrapper<T>);
   ops[16].api_func = reinterpret_cast<void*>(& ::evas_obj_box_internal_remove_at);
   ops[16].op = EO_OP_OVERRIDE;
   ops[16].op_type = EO_OP_TYPE_REGULAR;
   ops[16].doc = NULL;

   ops[17].func = reinterpret_cast<void*>(& ::evas_box_remove_at_wrapper<T>);
   ops[17].api_func = reinterpret_cast<void*>(& ::evas_obj_box_remove_at);
   ops[17].op = EO_OP_OVERRIDE;
   ops[17].op_type = EO_OP_TYPE_REGULAR;
   ops[17].doc = NULL;

   ops[18].func = reinterpret_cast<void*>(& ::evas_box_option_property_vget_wrapper<T>);
   ops[18].api_func = reinterpret_cast<void*>(& ::evas_obj_box_option_property_vget);
   ops[18].op = EO_OP_OVERRIDE;
   ops[18].op_type = EO_OP_TYPE_REGULAR;
   ops[18].doc = NULL;

   ops[19].func = reinterpret_cast<void*>(& ::evas_box_internal_insert_at_wrapper<T>);
   ops[19].api_func = reinterpret_cast<void*>(& ::evas_obj_box_internal_insert_at);
   ops[19].op = EO_OP_OVERRIDE;
   ops[19].op_type = EO_OP_TYPE_REGULAR;
   ops[19].doc = NULL;

   ops[20].func = reinterpret_cast<void*>(& ::evas_box_insert_before_wrapper<T>);
   ops[20].api_func = reinterpret_cast<void*>(& ::evas_obj_box_insert_before);
   ops[20].op = EO_OP_OVERRIDE;
   ops[20].op_type = EO_OP_TYPE_REGULAR;
   ops[20].doc = NULL;

   ops[21].func = reinterpret_cast<void*>(& ::evas_box_option_property_name_get_wrapper<T>);
   ops[21].api_func = reinterpret_cast<void*>(& ::evas_obj_box_option_property_name_get);
   ops[21].op = EO_OP_OVERRIDE;
   ops[21].op_type = EO_OP_TYPE_REGULAR;
   ops[21].doc = NULL;

   ops[22].func = reinterpret_cast<void*>(& ::evas_box_internal_insert_before_wrapper<T>);
   ops[22].api_func = reinterpret_cast<void*>(& ::evas_obj_box_internal_insert_before);
   ops[22].op = EO_OP_OVERRIDE;
   ops[22].op_type = EO_OP_TYPE_REGULAR;
   ops[22].doc = NULL;

   ops[23].func = reinterpret_cast<void*>(& ::evas_box_layout_homogeneous_horizontal_wrapper<T>);
   ops[23].api_func = reinterpret_cast<void*>(& ::evas_obj_box_layout_homogeneous_horizontal);
   ops[23].op = EO_OP_OVERRIDE;
   ops[23].op_type = EO_OP_TYPE_REGULAR;
   ops[23].doc = NULL;

   ops[24].func = reinterpret_cast<void*>(& ::evas_box_internal_option_new_wrapper<T>);
   ops[24].api_func = reinterpret_cast<void*>(& ::evas_obj_box_internal_option_new);
   ops[24].op = EO_OP_OVERRIDE;
   ops[24].op_type = EO_OP_TYPE_REGULAR;
   ops[24].doc = NULL;

   ops[25].func = reinterpret_cast<void*>(& ::evas_box_layout_homogeneous_max_size_vertical_wrapper<T>);
   ops[25].api_func = reinterpret_cast<void*>(& ::evas_obj_box_layout_homogeneous_max_size_vertical);
   ops[25].op = EO_OP_OVERRIDE;
   ops[25].op_type = EO_OP_TYPE_REGULAR;
   ops[25].doc = NULL;

   ops[26].func = reinterpret_cast<void*>(& ::evas_box_internal_insert_after_wrapper<T>);
   ops[26].api_func = reinterpret_cast<void*>(& ::evas_obj_box_internal_insert_after);
   ops[26].op = EO_OP_OVERRIDE;
   ops[26].op_type = EO_OP_TYPE_REGULAR;
   ops[26].doc = NULL;

   ops[27].func = reinterpret_cast<void*>(& ::evas_box_insert_at_wrapper<T>);
   ops[27].api_func = reinterpret_cast<void*>(& ::evas_obj_box_insert_at);
   ops[27].op = EO_OP_OVERRIDE;
   ops[27].op_type = EO_OP_TYPE_REGULAR;
   ops[27].doc = NULL;

   ops[28].func = reinterpret_cast<void*>(& ::evas_box_internal_prepend_wrapper<T>);
   ops[28].api_func = reinterpret_cast<void*>(& ::evas_obj_box_internal_prepend);
   ops[28].op = EO_OP_OVERRIDE;
   ops[28].op_type = EO_OP_TYPE_REGULAR;
   ops[28].doc = NULL;

   ops[29].func = reinterpret_cast<void*>(& ::evas_box_remove_wrapper<T>);
   ops[29].api_func = reinterpret_cast<void*>(& ::evas_obj_box_remove);
   ops[29].op = EO_OP_OVERRIDE;
   ops[29].op_type = EO_OP_TYPE_REGULAR;
   ops[29].doc = NULL;

   ops[30].func = reinterpret_cast<void*>(& ::evas_box_layout_stack_wrapper<T>);
   ops[30].api_func = reinterpret_cast<void*>(& ::evas_obj_box_layout_stack);
   ops[30].op = EO_OP_OVERRIDE;
   ops[30].op_type = EO_OP_TYPE_REGULAR;
   ops[30].doc = NULL;

   ops[31].func = reinterpret_cast<void*>(& ::evas_box_layout_homogeneous_vertical_wrapper<T>);
   ops[31].api_func = reinterpret_cast<void*>(& ::evas_obj_box_layout_homogeneous_vertical);
   ops[31].op = EO_OP_OVERRIDE;
   ops[31].op_type = EO_OP_TYPE_REGULAR;
   ops[31].doc = NULL;

   ops[32].func = reinterpret_cast<void*>(& ::evas_box_layout_flow_horizontal_wrapper<T>);
   ops[32].api_func = reinterpret_cast<void*>(& ::evas_obj_box_layout_flow_horizontal);
   ops[32].op = EO_OP_OVERRIDE;
   ops[32].op_type = EO_OP_TYPE_REGULAR;
   ops[32].doc = NULL;

   ops[33].func = reinterpret_cast<void*>(& ::evas_box_align_get_wrapper<T>);
   ops[33].api_func = reinterpret_cast<void*>(& ::evas_obj_box_align_get);
   ops[33].op = EO_OP_OVERRIDE;
   ops[33].op_type = EO_OP_TYPE_REGULAR;
   ops[33].doc = NULL;

   ops[34].func = reinterpret_cast<void*>(& ::evas_box_align_set_wrapper<T>);
   ops[34].api_func = reinterpret_cast<void*>(& ::evas_obj_box_align_set);
   ops[34].op = EO_OP_OVERRIDE;
   ops[34].op_type = EO_OP_TYPE_REGULAR;
   ops[34].doc = NULL;

   ops[35].func = reinterpret_cast<void*>(& ::evas_box_padding_get_wrapper<T>);
   ops[35].api_func = reinterpret_cast<void*>(& ::evas_obj_box_padding_get);
   ops[35].op = EO_OP_OVERRIDE;
   ops[35].op_type = EO_OP_TYPE_REGULAR;
   ops[35].doc = NULL;

   ops[36].func = reinterpret_cast<void*>(& ::evas_box_padding_set_wrapper<T>);
   ops[36].api_func = reinterpret_cast<void*>(& ::evas_obj_box_padding_set);
   ops[36].op = EO_OP_OVERRIDE;
   ops[36].op_type = EO_OP_TYPE_REGULAR;
   ops[36].doc = NULL;

   ops[37].func = reinterpret_cast<void*>(& ::evas_box_layout_set_wrapper<T>);
   ops[37].api_func = reinterpret_cast<void*>(& ::evas_obj_box_layout_set);
   ops[37].op = EO_OP_OVERRIDE;
   ops[37].op_type = EO_OP_TYPE_REGULAR;
   ops[37].doc = NULL;

   return 0;
}
inline void
call_constructor(tag< evas::box >
               , Eo* eo, Eo_Class const* cls EINA_UNUSED,
               args_class<evas::box, ::std::tuple<> > const& args)
{
   (void)args;
   eo_do_super(eo, cls, ::eo_constructor());
}

inline void
call_constructor(tag< evas::box >
               , Eo* eo, Eo_Class const* cls EINA_UNUSED,
               args_class<evas::box, ::std::tuple<efl::eo::parent_type> > const& args)
{
   eo_do_super(eo, cls, ::eo_constructor());
   eo_do(eo, ::eo_parent_set(args.get<0>()._eo_raw));
}

template<>
struct extension_inheritance< evas::box>
{
   template <typename U>
   struct type
   {
      operator evas::box() const
      {
         return evas::box(eo_ref(static_cast<U const*>(this)->_eo_ptr()));
      }

      void layout_horizontal(Evas_Object_Box_Data * priv_, void * data_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_box_layout_horizontal(priv_, data_));
      }

      void layout_vertical(Evas_Object_Box_Data * priv_, void * data_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_box_layout_vertical(priv_, data_));
      }

      void layout_homogeneous_max_size_horizontal(Evas_Object_Box_Data * priv_, void * data_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_box_layout_homogeneous_max_size_horizontal(priv_, data_));
      }

      evas::object internal_remove(evas::object child_)
      {
         Evas_Object * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_box_internal_remove(efl::eolian::to_c(child_)));
            return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }

      void layout_flow_vertical(Evas_Object_Box_Data * priv_, void * data_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_box_layout_flow_vertical(priv_, data_));
      }

      void internal_option_free(Evas_Object_Box_Option * opt_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_box_internal_option_free(opt_));
      }

      Evas_Object_Box_Option * insert_after(evas::object child_, const Evas_Object * reference_)
      {
         Evas_Object_Box_Option * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_box_insert_after(efl::eolian::to_c(child_), reference_));
            return _tmp_ret;
      }

      bool remove_all(bool clear_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_box_remove_all(efl::eolian::to_c(clear_)));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      Eina_Iterator * iterator_new()
      {
         Eina_Iterator * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_box_iterator_new());
            return _tmp_ret;
      }

      evas::object add_to()
      {
         Evas_Object * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_box_add_to());
            return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }

      Evas_Object_Box_Option * append(evas::object child_)
      {
         Evas_Object_Box_Option * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_box_append(efl::eolian::to_c(child_)));
            return _tmp_ret;
      }

      int option_property_id_get(std::string name_)
      {
         int _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_box_option_property_id_get(efl::eolian::to_c(name_)));
            return _tmp_ret;
      }

      Evas_Object_Box_Option * prepend(evas::object child_)
      {
         Evas_Object_Box_Option * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_box_prepend(efl::eolian::to_c(child_)));
            return _tmp_ret;
      }

      Eina_Accessor * accessor_new()
      {
         Eina_Accessor * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_box_accessor_new());
            return _tmp_ret;
      }

      Evas_Object_Box_Option * internal_append(evas::object child_)
      {
         Evas_Object_Box_Option * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_box_internal_append(efl::eolian::to_c(child_)));
            return _tmp_ret;
      }

      bool option_property_vset(Evas_Object_Box_Option * opt_, int property_, va_list * args_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_box_option_property_vset(opt_, property_, args_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      evas::object internal_remove_at(unsigned int pos_)
      {
         Evas_Object * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_box_internal_remove_at(pos_));
            return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }

      bool remove_at(unsigned int pos_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_box_remove_at(pos_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      bool option_property_vget(Evas_Object_Box_Option * opt_, int property_, va_list * args_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_box_option_property_vget(opt_, property_, args_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      Evas_Object_Box_Option * internal_insert_at(evas::object child_, unsigned int pos_)
      {
         Evas_Object_Box_Option * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_box_internal_insert_at(efl::eolian::to_c(child_), pos_));
            return _tmp_ret;
      }

      Evas_Object_Box_Option * insert_before(evas::object child_, const Evas_Object * reference_)
      {
         Evas_Object_Box_Option * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_box_insert_before(efl::eolian::to_c(child_), reference_));
            return _tmp_ret;
      }

      std::string option_property_name_get(int property_)
      {
         const char * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_box_option_property_name_get(property_));
            return efl::eolian::to_cxx<std::string>(_tmp_ret, std::tuple<std::false_type>());
      }

      Evas_Object_Box_Option * internal_insert_before(evas::object child_, const Evas_Object * reference_)
      {
         Evas_Object_Box_Option * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_box_internal_insert_before(efl::eolian::to_c(child_), reference_));
            return _tmp_ret;
      }

      void layout_homogeneous_horizontal(Evas_Object_Box_Data * priv_, void * data_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_box_layout_homogeneous_horizontal(priv_, data_));
      }

      Evas_Object_Box_Option * internal_option_new(evas::object child_)
      {
         Evas_Object_Box_Option * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_box_internal_option_new(efl::eolian::to_c(child_)));
            return _tmp_ret;
      }

      void layout_homogeneous_max_size_vertical(Evas_Object_Box_Data * priv_, void * data_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_box_layout_homogeneous_max_size_vertical(priv_, data_));
      }

      Evas_Object_Box_Option * internal_insert_after(evas::object child_, const Evas_Object * reference_)
      {
         Evas_Object_Box_Option * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_box_internal_insert_after(efl::eolian::to_c(child_), reference_));
            return _tmp_ret;
      }

      Evas_Object_Box_Option * insert_at(evas::object child_, unsigned int pos_)
      {
         Evas_Object_Box_Option * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_box_insert_at(efl::eolian::to_c(child_), pos_));
            return _tmp_ret;
      }

      Evas_Object_Box_Option * internal_prepend(evas::object child_)
      {
         Evas_Object_Box_Option * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_box_internal_prepend(efl::eolian::to_c(child_)));
            return _tmp_ret;
      }

      bool remove(evas::object child_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_box_remove(efl::eolian::to_c(child_)));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      void layout_stack(Evas_Object_Box_Data * priv_, void * data_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_box_layout_stack(priv_, data_));
      }

      void layout_homogeneous_vertical(Evas_Object_Box_Data * priv_, void * data_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_box_layout_homogeneous_vertical(priv_, data_));
      }

      void layout_flow_horizontal(Evas_Object_Box_Data * priv_, void * data_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_box_layout_flow_horizontal(priv_, data_));
      }

      void align_get(double* horizontal_, double* vertical_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_box_align_get(horizontal_, vertical_));
      }

      void align_set(double horizontal_, double vertical_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_box_align_set(horizontal_, vertical_));
      }

      void padding_get(Evas_Coord* horizontal_, Evas_Coord* vertical_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_box_padding_get(horizontal_, vertical_));
      }

      void padding_set(Evas_Coord horizontal_, Evas_Coord vertical_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_box_padding_set(horizontal_, vertical_));
      }

      void layout_set(Evas_Object_Box_Layout cb_, const void * data_, Eina_Free_Cb free_data_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_box_layout_set(cb_, data_, free_data_));
      }

   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::move(callback_)) );
      eo_do(static_cast<U*>(this)->_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, static_cast<U*>(this)->_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(static_cast<U*>(this)->_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::move(callback_)) );
      eo_do(static_cast<U*>(this)->_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, static_cast<U*>(this)->_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(static_cast<U*>(this)->_eo_ptr(), eo_event_callback_call
            (EVAS_BOX_EVENT_CHILD_REMOVED, info));
   }
   };
};

inline Eo_Class const* get_eo_class(tag<evas::box>)
{
   return (EVAS_BOX_CLASS);
}

} } }
#endif // EFL_GENERATED_EVAS_BOX_HH

