#ifndef EFL_GENERATED_EVAS_OBJECT_HH
#define EFL_GENERATED_EVAS_OBJECT_HH

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

#include <eo_cxx_interop.hh>

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

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

namespace evas {

struct object
      : efl::eo::base,
      efl::eo::detail::extension_inheritance<evas::common_interface>::template type< ::evas::object>

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

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

   /// @brief Call the object's constructor.
   /// Should not be used with #eo_do. Only use it with #eo_do_super.
   ///
   object(efl::eo::parent_type _p = (efl::eo::parent = nullptr))
      : object(_c0(_p))
   {}

   /// @brief Copy Constructor.
   ///
   object(object const& other)
      : efl::eo::base(eo_ref(other._eo_ptr()))
   {}

   ~object() {}

   /// @brief Get dbg information from the object.
   ///
   /// @param root_node node of the tree
   ///
   void dbg_info_get(Eo_Dbg_Info * root_node_) const
   {
      eo_do(_eo_ptr(), ::eo_dbg_info_get(root_node_));
   }

   /// @brief No description supplied by the EAPI.
   ///
   /// @param ret 
   ///
   Evas * evas_get() const
   {
      Evas * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_common_evas_get());
      return _tmp_ret;
   }

   /// @brief Retrieves the hints for an object's maximum size.
   ///
   /// These are hints on the maximum sizes @p obj should have. This is
   /// not a size enforcement in any way, it's just a hint that should be
   /// used whenever appropriate.
   ///
   /// @note Use @c NULL pointers on the hint components you're not
   /// interested in: they'll be ignored by the function.
   ///
   /// @see evas_object_size_hint_max_set()
   ///
   /// @param w Integer to use as the maximum width hint.
   /// @param h Integer to use as the maximum height hint.
   ///
   void size_hint_max_get(Evas_Coord* w_, Evas_Coord* h_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_size_hint_max_get(w_, h_));
   }

   /// @brief Sets the hints for an object's maximum size.
   ///
   /// This is not a size enforcement in any way, it's just a hint that
   /// should be used whenever appropriate.
   ///
   /// Values @c -1 will be treated as unset hint components, when queried
   /// by managers.
   ///
   /// Example:
   /// @dontinclude evas-hints.c
   /// @skip evas_object_size_hint_max_set
   /// @until return
   ///
   /// In this example the maximum size hints change the behavior of an
   /// Evas box when layouting its children. See the full @ref
   /// Example_Evas_Size_Hints "example".
   ///
   /// @see evas_object_size_hint_max_get()
   ///
   /// @param w Integer to use as the maximum width hint.
   /// @param h Integer to use as the maximum height hint.
   ///
   void size_hint_max_set(Evas_Coord w_, Evas_Coord h_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_size_hint_max_set(w_, h_));
   }

   /// @brief Retrieves the hints for an object's optimum size.
   ///
   /// These are hints on the optimum sizes @p obj should have. This is
   /// not a size enforcement in any way, it's just a hint that should be
   /// used whenever appropriate.
   ///
   /// @note Use @c NULL pointers on the hint components you're not
   /// interested in: they'll be ignored by the function.
   ///
   /// @see evas_object_size_hint_request_set()
   ///
   /// @param w Integer to use as the preferred width hint.
   /// @param h Integer to use as the preferred height hint.
   ///
   void size_hint_request_get(Evas_Coord* w_, Evas_Coord* h_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_size_hint_request_get(w_, h_));
   }

   /// @brief Sets the hints for an object's optimum size.
   ///
   /// This is not a size enforcement in any way, it's just a hint that
   /// should be used whenever appropriate.
   ///
   /// Values @c 0 will be treated as unset hint components, when queried
   /// by managers.
   ///
   /// @see evas_object_size_hint_request_get()
   ///
   /// @param w Integer to use as the preferred width hint.
   /// @param h Integer to use as the preferred height hint.
   ///
   void size_hint_request_set(Evas_Coord w_, Evas_Coord h_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_size_hint_request_set(w_, h_));
   }

   /// @brief Retrieves whether or not the given Evas object is visible.
   ///
   /// @param v @c EINA_TRUE if to make the object visible, @c EINA_FALSE otherwise
   ///
   bool visibility_get() const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_visibility_get());
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Makes the given Evas object visible or invisible.
   ///
   /// @param v @c EINA_TRUE if to make the object visible, @c EINA_FALSE otherwise
   ///
   void visibility_set(bool v_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_visibility_set(efl::eolian::to_c(v_)));
   }

   /// @brief Retrieves the type of the given Evas object.
   ///
   /// @return The type of the object.
   ///
   /// For Evas' builtin types, the return strings will be one of:
   /// - <c>"rectangle"</c>,
   /// - <c>"line"</c>,
   /// - <c>"polygon"</c>,
   /// - <c>"text"</c>,
   /// - <c>"textblock"</c> and
   /// - <c>"image"</c>.
   ///
   /// For Evas smart objects (see @ref Evas_Smart_Group), the name of the
   /// smart class itself is returned on this call. For the built-in smart
   /// objects, these names are:
   /// - <c>"EvasObjectSmartClipped"</c>, for the clipped smart object
   /// - <c>"Evas_Object_Box"</c>, for the box object and
   /// - <c>"Evas_Object_Table"</c>, for the table object.
   ///
   /// Example:
   /// @dontinclude evas-object-manipulation.c
   /// @skip d.img = evas_object_image_filled_add(d.canvas);
   /// @until border on the
   ///
   /// See the full @ref Example_Evas_Object_Manipulation "example".
   ///
   /// @param type in
   ///
   std::string type_get() const
   {
      const char * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_type_get());
      return efl::eolian::to_cxx<std::string>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Sets the type of the given Evas object.
   ///
   /// @param type in
   ///
   void type_set(std::string type_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_type_set(efl::eolian::to_c(type_)));
   }

   /// @brief Retrieves the hints for an object's minimum size.
   ///
   /// These are hints on the minimum sizes @p obj should have. This is
   /// not a size enforcement in any way, it's just a hint that should be
   /// used whenever appropriate.
   ///
   /// @note Use @c NULL pointers on the hint components you're not
   /// interested in: they'll be ignored by the function.
   ///
   /// @see evas_object_size_hint_min_set() for an example
   ///
   /// @param w Integer to use as the minimum width hint.
   /// @param h Integer to use as the minimum height hint.
   ///
   void size_hint_min_get(Evas_Coord* w_, Evas_Coord* h_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_size_hint_min_get(w_, h_));
   }

   /// @brief Sets the hints for an object's minimum size.
   ///
   /// This is not a size enforcement in any way, it's just a hint that
   /// should be used whenever appropriate.
   ///
   /// Values @c 0 will be treated as unset hint components, when queried
   /// by managers.
   ///
   /// Example:
   /// @dontinclude evas-hints.c
   /// @skip evas_object_size_hint_min_set
   /// @until return
   ///
   /// In this example the minimum size hints change the behavior of an
   /// Evas box when layouting its children. See the full @ref
   /// Example_Evas_Size_Hints "example".
   ///
   /// @see evas_object_size_hint_min_get()
   ///
   /// @param w Integer to use as the minimum width hint.
   /// @param h Integer to use as the minimum height hint.
   ///
   void size_hint_min_set(Evas_Coord w_, Evas_Coord h_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_size_hint_min_set(w_, h_));
   }

   /// @brief Determine how pointer will behave.
   /// @return pointer behavior.
   /// @ingroup Evas_Object_Group_Extras
   ///
   /// @param pointer_mode desired behavior.
   ///
   Evas_Object_Pointer_Mode pointer_mode_get() const
   {
      Evas_Object_Pointer_Mode _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_pointer_mode_get());
      return _tmp_ret;
   }

   /// @brief Set pointer behavior.
   ///
   /// This function has direct effect on event callbacks related to
   /// mouse.
   ///
   /// If @p setting is EVAS_OBJECT_POINTER_MODE_AUTOGRAB, then when mouse
   /// is down at this object, events will be restricted to it as source,
   /// mouse moves, for example, will be emitted even if outside this
   /// object area.
   ///
   /// If @p setting is EVAS_OBJECT_POINTER_MODE_NOGRAB, then events will
   /// be emitted just when inside this object area.
   ///
   /// The default value is EVAS_OBJECT_POINTER_MODE_AUTOGRAB.
   ///
   /// @ingroup Evas_Object_Group_Extras
   ///
   /// @param pointer_mode desired behavior.
   ///
   void pointer_mode_set(Evas_Object_Pointer_Mode pointer_mode_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_pointer_mode_set(pointer_mode_));
   }

   /// @brief Retrieves the current value of the operation used for rendering the Evas object.
   /// @return  one of the enumerated values in Evas_Render_Op.
   /// @ingroup Evas_Object_Group_Extras
   ///
   /// @param render_op one of the Evas_Render_Op values.
   ///
   Evas_Render_Op render_op_get() const
   {
      Evas_Render_Op _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_render_op_get());
      return _tmp_ret;
   }

   /// @brief Sets the render_op to be used for rendering the Evas object.
   /// @ingroup Evas_Object_Group_Extras
   ///
   /// @param render_op one of the Evas_Render_Op values.
   ///
   void render_op_set(Evas_Render_Op render_op_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_render_op_set(render_op_));
   }

   /// @brief Determine whether an object is set to freeze (discard) events.
   ///
   /// @return freeze whether @p obj is set to freeze events (@c EINA_TRUE) or
   /// not (@c EINA_FALSE)
   ///
   /// @see evas_object_freeze_events_set()
   /// @see evas_object_pass_events_get()
   /// @see evas_object_repeat_events_get()
   /// @see evas_object_propagate_events_get()
   /// @since 1.1
   ///
   /// @param freeze pass whether @p obj is to freeze events (@c EINA_TRUE) or not
   /// (@c EINA_FALSE)
   ///
   bool freeze_events_get() const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_freeze_events_get());
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Set whether an Evas object is to freeze (discard) events.
   ///
   /// If @p freeze is @c EINA_TRUE, it will make events on @p obj to be @b
   /// discarded. Unlike evas_object_pass_events_set(), events will not be
   /// passed to @b next lower object. This API can be used for blocking
   /// events while @p obj is on transiting.
   ///
   /// If @p freeze is @c EINA_FALSE, events will be processed on that
   /// object as normal.
   ///
   /// @warning If you block only key/mouse up events with this API, we won't
   /// guarantee the state of the object, that only had key/mouse down
   /// events, will be.
   ///
   /// @see evas_object_freeze_events_get()
   /// @see evas_object_pass_events_set()
   /// @see evas_object_repeat_events_set()
   /// @see evas_object_propagate_events_set()
   /// @since 1.1
   ///
   /// @param freeze pass whether @p obj is to freeze events (@c EINA_TRUE) or not
   /// (@c EINA_FALSE)
   ///
   void freeze_events_set(bool freeze_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_freeze_events_set(efl::eolian::to_c(freeze_)));
   }

   /// @brief Get current object transformation map.
   ///
   /// This returns the current internal map set on the indicated object. It is
   /// intended for read-only access and is only valid as long as the object is
   /// not deleted or the map on the object is not changed. If you wish to modify
   /// the map and set it back do the following:
   ///
   /// @code
   /// const Evas_Map *m = evas_object_map_get(obj);
   /// Evas_Map *m2 = evas_map_dup(m);
   /// evas_map_util_rotate(m2, 30.0, 0, 0);
   /// evas_object_map_set(obj, m2);
   /// evas_map_free(m2);
   /// @endcode
   ///
   /// @return map reference to map in use. This is an internal data structure, so
   /// do not modify it.
   ///
   /// @see evas_object_map_set()
   ///
   /// @param map new map to use
   ///
   const Evas_Map * map_get() const
   {
      const Evas_Map * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_map_get());
      return _tmp_ret;
   }

   /// @brief Set current object transformation map.
   ///
   /// This sets the map on a given object. It is copied from the @p map pointer,
   /// so there is no need to keep the @p map object if you don't need it anymore.
   ///
   /// A map is a set of 4 points which have canvas x, y coordinates per point,
   /// with an optional z point value as a hint for perspective correction, if it
   /// is available. As well each point has u and v coordinates. These are like
   /// "texture coordinates" in OpenGL in that they define a point in the source
   /// image that is mapped to that map vertex/point. The u corresponds to the x
   /// coordinate of this mapped point and v, the y coordinate. Note that these
   /// coordinates describe a bounding region to sample. If you have a 200x100
   /// source image and want to display it at 200x100 with proper pixel
   /// precision, then do:
   ///
   /// @code
   /// Evas_Map *m = evas_map_new(4);
   /// evas_map_point_coord_set(m, 0,   0,   0, 0);
   /// evas_map_point_coord_set(m, 1, 200,   0, 0);
   /// evas_map_point_coord_set(m, 2, 200, 100, 0);
   /// evas_map_point_coord_set(m, 3,   0, 100, 0);
   /// evas_map_point_image_uv_set(m, 0,   0,   0);
   /// evas_map_point_image_uv_set(m, 1, 200,   0);
   /// evas_map_point_image_uv_set(m, 2, 200, 100);
   /// evas_map_point_image_uv_set(m, 3,   0, 100);
   /// evas_object_map_set(obj, m);
   /// evas_map_free(m);
   /// @endcode
   ///
   /// Note that the map points a uv coordinates match the image geometry. If
   /// the @p map parameter is NULL, the stored map will be freed and geometry
   /// prior to enabling/setting a map will be restored.
   ///
   /// @see evas_map_new()
   ///
   /// @param map new map to use
   ///
   void map_set(const Evas_Map * map_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_map_set(map_));
   }

   /// @brief Retrieves the hints for an object's aspect ratio.
   ///
   /// The different aspect ratio policies are documented in the
   /// #Evas_Aspect_Control type. A container respecting these size hints
   /// would @b resize its children accordingly to those policies.
   ///
   /// For any policy, if any of the given aspect ratio terms are @c 0,
   /// the object's container should ignore the aspect and scale @p obj to
   /// occupy the whole available area. If they are both positive
   /// integers, that proportion will be respected, under each scaling
   /// policy.
   ///
   /// These images illustrate some of the #Evas_Aspect_Control policies:
   ///
   /// @image html any-policy.png
   /// @image rtf any-policy.png
   /// @image latex any-policy.eps
   ///
   /// @image html aspect-control-none-neither.png
   /// @image rtf aspect-control-none-neither.png
   /// @image latex aspect-control-none-neither.eps
   ///
   /// @image html aspect-control-both.png
   /// @image rtf aspect-control-both.png
   /// @image latex aspect-control-both.eps
   ///
   /// @image html aspect-control-horizontal.png
   /// @image rtf aspect-control-horizontal.png
   /// @image latex aspect-control-horizontal.eps
   ///
   /// This is not a size enforcement in any way, it's just a hint that
   /// should be used whenever appropriate.
   ///
   /// @note Use @c NULL pointers on the hint components you're not
   /// interested in: they'll be ignored by the function.
   ///
   /// Example:
   /// @dontinclude evas-aspect-hints.c
   /// @skip if (strcmp(ev->key, "c") == 0)
   /// @until }
   ///
   /// See the full @ref Example_Evas_Aspect_Hints "example".
   ///
   /// @see evas_object_size_hint_aspect_set()
   ///
   /// @param aspect The policy/type of aspect ratio to apply to @p obj.
   /// @param w Integer to use as aspect width ratio term.
   /// @param h Integer to use as aspect height ratio term.
   ///
   void size_hint_aspect_get(Evas_Aspect_Control* aspect_, Evas_Coord* w_, Evas_Coord* h_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_size_hint_aspect_get(aspect_, w_, h_));
   }

   /// @brief Sets the hints for an object's aspect ratio.
   ///
   /// This is not a size enforcement in any way, it's just a hint that should
   /// be used whenever appropriate.
   ///
   /// If any of the given aspect ratio terms are @c 0,
   /// the object's container will ignore the aspect and scale @p obj to
   /// occupy the whole available area, for any given policy.
   ///
   /// @see evas_object_size_hint_aspect_get() for more information.
   ///
   /// @param aspect The policy/type of aspect ratio to apply to @p obj.
   /// @param w Integer to use as aspect width ratio term.
   /// @param h Integer to use as aspect height ratio term.
   ///
   void size_hint_aspect_set(Evas_Aspect_Control aspect_, Evas_Coord w_, Evas_Coord h_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_size_hint_aspect_set(aspect_, w_, h_));
   }

   /// @brief Retrieves the layer of its canvas that the given object is part of.
   ///
   /// @return  Number of its layer
   ///
   /// @see evas_object_layer_set()
   ///
   /// @param l The number of the layer to place the object on.
   /// Must be between #EVAS_LAYER_MIN and #EVAS_LAYER_MAX.
   ///
   short layer_get() const
   {
      short _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_layer_get());
      return _tmp_ret;
   }

   /// @brief Sets the layer of its canvas that the given object will be part of.
   ///
   /// If you don't use this function, you'll be dealing with an @b unique
   /// layer of objects, the default one. Additional layers are handy when
   /// you don't want a set of objects to interfere with another set with
   /// regard to @b stacking. Two layers are completely disjoint in that
   /// matter.
   ///
   /// This is a low-level function, which you'd be using when something
   /// should be always on top, for example.
   ///
   /// @warning Be careful, it doesn't make sense to change the layer of
   /// smart objects' children. Smart objects have a layer of their own,
   /// which should contain all their children objects.
   ///
   /// @see evas_object_layer_get()
   ///
   /// @param l The number of the layer to place the object on.
   /// Must be between #EVAS_LAYER_MIN and #EVAS_LAYER_MAX.
   ///
   void layer_set(short l_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_layer_set(l_));
   }

   /// @brief Get the object clipping @p obj (if any).
   ///
   /// This function returns the object clipping @p obj. If @p obj is
   /// not being clipped at all, @c NULL is returned. The object @p obj
   /// must be a valid .Evas_Object.
   ///
   /// See also evas_object_clip_set(), evas_object_clip_unset() and
   /// evas_object_clipees_get().
   ///
   /// Example:
   /// @dontinclude evas-object-manipulation.c
   /// @skip if (evas_object_clip_get(d.img) == d.clipper)
   /// @until return
   ///
   /// See the full @ref Example_Evas_Object_Manipulation "example".
   ///
   /// @param clip The object to clip @p obj by
   ///
   evas::object clip_get() const
   {
      Evas_Object * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_clip_get());
      return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Clip one object to another.
   ///
   /// This function will clip the object @p obj to the area occupied by
   /// the object @p clip. This means the object @p obj will only be
   /// visible within the area occupied by the clipping object (@p clip).
   ///
   /// The color of the object being clipped will be multiplied by the
   /// color of the clipping one, so the resulting color for the former
   /// will be <code>RESULT = (OBJ * CLIP) / (255 * 255)</code>, per color
   /// element (red, green, blue and alpha).
   ///
   /// Clipping is recursive, so clipping objects may be clipped by
   /// others, and their color will in term be multiplied. You may @b not
   /// set up circular clipping lists (i.e. object 1 clips object 2, which
   /// clips object 1): the behavior of Evas is undefined in this case.
   ///
   /// Objects which do not clip others are visible in the canvas as
   /// normal; <b>those that clip one or more objects become invisible
   /// themselves</b>, only affecting what they clip. If an object ceases
   /// to have other objects being clipped by it, it will become visible
   /// again.
   ///
   /// The visibility of an object affects the objects that are clipped by
   /// it, so if the object clipping others is not shown (as in
   /// evas_object_show()), the objects clipped by it will not be shown
   /// either.
   ///
   /// If @p obj was being clipped by another object when this function is
   /// called, it gets implicitly removed from the old clipper's domain
   /// and is made now to be clipped by its new clipper.
   ///
   /// The following figure illustrates some clipping in Evas:
   ///
   /// @image html clipping.png
   /// @image rtf clipping.png
   /// @image latex clipping.eps
   ///
   /// @note At the moment the <b>only objects that can validly be used to
   /// clip other objects are rectangle objects</b>. All other object
   /// types are invalid and the result of using them is undefined. The
   /// clip object @p clip must be a valid object, but can also be @c
   /// NULL, in which case the effect of this function is the same as
   /// calling evas_object_clip_unset() on the @p obj object.
   ///
   /// Example:
   /// @dontinclude evas-object-manipulation.c
   /// @skip solid white clipper (note that it's the default color for a
   /// @until evas_object_show(d.clipper);
   ///
   /// See the full @ref Example_Evas_Object_Manipulation "example".
   ///
   /// @param clip The object to clip @p obj by
   ///
   void clip_set(evas::object clip_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_clip_set(efl::eolian::to_c(clip_)));
   }

   /// @brief Retrieves the hints for an object's padding space.
   ///
   /// Padding is extra space an object takes on each of its delimiting
   /// rectangle sides, in canvas units. This space will be rendered
   /// transparent, naturally, as in the following figure:
   ///
   /// @image html padding-hints.png
   /// @image rtf padding-hints.png
   /// @image latex padding-hints.eps
   ///
   /// This is not a size enforcement in any way, it's just a hint that
   /// should be used whenever appropriate.
   ///
   /// @note Use @c NULL pointers on the hint components you're not
   /// interested in: they'll be ignored by the function.
   ///
   /// Example:
   /// @dontinclude evas-hints.c
   /// @skip evas_object_size_hint_padding_set
   /// @until return
   ///
   /// In this example the padding hints change the behavior of an Evas box
   /// when layouting its children. See the full @ref
   /// Example_Evas_Size_Hints "example".
   ///
   /// @see evas_object_size_hint_padding_set()
   ///
   /// @param l Integer to specify left padding.
   /// @param r Integer to specify right padding.
   /// @param t Integer to specify top padding.
   /// @param b Integer to specify bottom padding.
   ///
   void size_hint_padding_get(Evas_Coord* l_, Evas_Coord* r_, Evas_Coord* t_, Evas_Coord* b_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_size_hint_padding_get(l_, r_, t_, b_));
   }

   /// @brief Sets the hints for an object's padding space.
   ///
   /// This is not a size enforcement in any way, it's just a hint that
   /// should be used whenever appropriate.
   ///
   /// @see evas_object_size_hint_padding_get() for more information
   ///
   /// @param l Integer to specify left padding.
   /// @param r Integer to specify right padding.
   /// @param t Integer to specify top padding.
   /// @param b Integer to specify bottom padding.
   ///
   void size_hint_padding_set(Evas_Coord l_, Evas_Coord r_, Evas_Coord t_, Evas_Coord b_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_size_hint_padding_set(l_, r_, t_, b_));
   }

   /// @brief Determine whether an object is set to repeat events.
   ///
   /// @return whether @p obj is set to repeat events (@c EINA_TRUE)
   /// or not (@c EINA_FALSE)
   ///
   /// @see evas_object_repeat_events_set() for an example
   /// @see evas_object_pass_events_get()
   /// @see evas_object_propagate_events_get()
   /// @see evas_object_freeze_events_get()
   ///
   /// @param repeat whether @p obj is to repeat events (@c EINA_TRUE) or not
   /// (@c EINA_FALSE)
   ///
   bool repeat_events_get() const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_repeat_events_get());
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Set whether an Evas object is to repeat events.
   ///
   /// If @p repeat is @c EINA_TRUE, it will make events on @p obj to also
   /// be repeated for the @b next lower object in the objects' stack (see
   /// see evas_object_below_get()).
   ///
   /// If @p repeat is @c EINA_FALSE, events occurring on @p obj will be
   /// processed only on it.
   ///
   /// Example:
   /// @dontinclude evas-stacking.c
   /// @skip if (strcmp(ev->key, "r") == 0)
   /// @until }
   ///
   /// See the full @ref Example_Evas_Stacking "example".
   ///
   /// @see evas_object_repeat_events_get()
   /// @see evas_object_pass_events_set()
   /// @see evas_object_propagate_events_set()
   /// @see evas_object_freeze_events_set()
   ///
   /// @param repeat whether @p obj is to repeat events (@c EINA_TRUE) or not
   /// (@c EINA_FALSE)
   ///
   void repeat_events_set(bool repeat_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_repeat_events_set(efl::eolian::to_c(repeat_)));
   }

   /// @brief Retrieves the hints for an object's weight.
   ///
   /// Accepted values are zero or positive values. Some users might use
   /// this hint as a boolean, but some might consider it as a @b
   /// proportion, see documentation of possible users, which in Evas are
   /// the @ref Evas_Object_Box "box" and @ref Evas_Object_Table "table"
   /// smart objects.
   ///
   /// This is not a size enforcement in any way, it's just a hint that
   /// should be used whenever appropriate.
   ///
   /// @note Use @c NULL pointers on the hint components you're not
   /// interested in: they'll be ignored by the function.
   /// @note If @c obj is invalid, then the hint components will be set with 0.0
   ///
   /// @see evas_object_size_hint_weight_set() for an example
   ///
   /// @param x Nonnegative double value to use as horizontal weight hint.
   /// @param y Nonnegative double value to use as vertical weight hint.
   ///
   void size_hint_weight_get(double* x_, double* y_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_size_hint_weight_get(x_, y_));
   }

   /// @brief Sets the hints for an object's weight.
   ///
   /// This is not a size enforcement in any way, it's just a hint that
   /// should be used whenever appropriate.
   ///
   /// This is a hint on how a container object should @b resize a given
   /// child within its area. Containers may adhere to the simpler logic
   /// of just expanding the child object's dimensions to fit its own (see
   /// the #EVAS_HINT_EXPAND helper weight macro) or the complete one of
   /// taking each child's weight hint as real @b weights to how much of
   /// its size to allocate for them in each axis. A container is supposed
   /// to, after @b normalizing the weights of its children (with weight
   /// hints), distribute the space it has to layout them by those factors
   /// -- most weighted children get larger in this process than the least
   /// ones.
   ///
   /// Example:
   /// @dontinclude evas-hints.c
   /// @skip evas_object_size_hint_weight_set
   /// @until return
   ///
   /// In this example the weight hints change the behavior of an Evas box
   /// when layouting its children. See the full @ref
   /// Example_Evas_Size_Hints "example".
   ///
   /// @note Default weight hint values are 0.0, for both axis.
   ///
   /// @see evas_object_size_hint_weight_get() for more information
   ///
   /// @param x Nonnegative double value to use as horizontal weight hint.
   /// @param y Nonnegative double value to use as vertical weight hint.
   ///
   void size_hint_weight_set(double x_, double y_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_size_hint_weight_set(x_, y_));
   }

   /// @brief Retrieves the name of the given Evas object.
   ///
   /// @return  The name of the object or @c NULL, if no name has been given
   /// to it.
   ///
   /// Example:
   /// @dontinclude evas-events.c
   /// @skip fprintf(stdout, "An object got focused: %s\n",
   /// @until evas_focus_get
   ///
   /// See the full @ref Example_Evas_Events "example".
   ///
   /// @param name The given name.
   ///
   std::string name_get() const
   {
      const char * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_name_get());
      return efl::eolian::to_cxx<std::string>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Sets the name of the given Evas object to the given name.
   ///
   /// There might be occasions where one would like to name his/her
   /// objects.
   ///
   /// Example:
   /// @dontinclude evas-events.c
   /// @skip d.bg = evas_object_rectangle_add(d.canvas);
   /// @until evas_object_name_set(d.bg, "our dear rectangle");
   ///
   /// See the full @ref Example_Evas_Events "example".
   ///
   /// @param name The given name.
   ///
   void name_set(std::string name_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_name_set(efl::eolian::to_c(name_)));
   }

   /// @brief Retrieves the scaling factor for the given Evas object.
   ///
   /// @return  The scaling factor.
   ///
   /// @ingroup Evas_Object_Group_Extras
   ///
   /// @see evas_object_scale_set()
   ///
   /// @param scale The scaling factor. <c>1.0</c> means no scaling,
   /// default size.
   ///
   double scale_get() const
   {
      double _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_scale_get());
      return _tmp_ret;
   }

   /// @brief Sets the scaling factor for an Evas object. Does not affect all
   /// objects.
   ///
   /// This will multiply the object's dimension by the given factor, thus
   /// altering its geometry (width and height). Useful when you want
   /// scalable UI elements, possibly at run time.
   ///
   /// @note Only text and textblock objects have scaling change
   /// handlers. Other objects won't change visually on this call.
   ///
   /// @see evas_object_scale_get()
   ///
   /// @ingroup Evas_Object_Group_Extras
   ///
   /// @param scale The scaling factor. <c>1.0</c> means no scaling,
   /// default size.
   ///
   void scale_set(double scale_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_scale_set(scale_));
   }

   /// @brief Get the "static clipper" hint flag for a given Evas object.
   ///
   /// @return @c EINA_TRUE if it's set as a static clipper,
   /// @c EINA_FALSE otherwise.
   ///
   /// @see evas_object_static_clip_set() for more details
   ///
   /// @ingroup Evas_Object_Group_Extras
   ///
   /// @param is_static_clip @c EINA_TRUE if it's to be used as a static
   /// clipper, @c EINA_FALSE otherwise.
   ///
   bool static_clip_get() const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_static_clip_get());
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Set a hint flag on the given Evas object that it's used as a "static
   /// clipper".
   ///
   /// This is a hint to Evas that this object is used as a big static
   /// clipper and shouldn't be moved with children and otherwise
   /// considered specially. The default value for new objects is
   /// @c EINA_FALSE.
   ///
   /// @see evas_object_static_clip_get()
   ///
   /// @ingroup Evas_Object_Group_Extras
   ///
   /// @param is_static_clip @c EINA_TRUE if it's to be used as a static
   /// clipper, @c EINA_FALSE otherwise.
   ///
   void static_clip_set(bool is_static_clip_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_static_clip_set(efl::eolian::to_c(is_static_clip_)));
   }

   /// @brief Retrieves the (rectangular) size of the given Evas object.
   ///
   /// @param w in
   /// @param h in
   ///
   void size_get(Evas_Coord* w_, Evas_Coord* h_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_size_get(w_, h_));
   }

   /// @brief Changes the size of the given Evas object.
   ///
   /// @param w in
   /// @param h in
   ///
   void size_set(Evas_Coord w_, Evas_Coord h_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_size_set(w_, h_));
   }

   /// @brief Retrieve whether an object has the focus.
   ///
   /// @return @c EINA_TRUE if the object has the focus, @c EINA_FALSE otherwise.
   ///
   /// If the passed object is the currently focused one, @c EINA_TRUE is
   /// returned. @c EINA_FALSE is returned, otherwise.
   ///
   /// Example:
   /// @dontinclude evas-events.c
   /// @skip And again
   /// @until something is bad
   ///
   /// See the full example @ref Example_Evas_Events "here".
   ///
   /// @see evas_object_focus_set
   /// @see evas_focus_get
   /// @see evas_object_key_grab
   /// @see evas_object_key_ungrab
   ///
   /// @param focus @c EINA_TRUE, to set it as focused or @c EINA_FALSE,
   /// to take away the focus from it.
   ///
   bool focus_get() const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_focus_get());
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Sets or unsets a given object as the currently focused one on its
   /// canvas.
   ///
   /// Changing focus only affects where (key) input events go. There can
   /// be only one object focused at any time. If @p focus is @c EINA_TRUE,
   /// @p obj will be set as the currently focused object and it will
   /// receive all keyboard events that are not exclusive key grabs on
   /// other objects.
   ///
   /// Example:
   /// @dontinclude evas-events.c
   /// @skip evas_object_focus_set
   /// @until evas_object_focus_set
   ///
   /// See the full example @ref Example_Evas_Events "here".
   ///
   /// @see evas_object_focus_get
   /// @see evas_focus_get
   /// @see evas_object_key_grab
   /// @see evas_object_key_ungrab
   ///
   /// @param focus @c EINA_TRUE, to set it as focused or @c EINA_FALSE,
   /// to take away the focus from it.
   ///
   void focus_set(bool focus_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_focus_set(efl::eolian::to_c(focus_)));
   }

   /// @brief @since 1.2
   ///
   /// @param is_frame in
   ///
   bool is_frame_object_get() const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_is_frame_object_get());
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @since 1.2
   ///
   /// @param is_frame in
   ///
   void is_frame_object_set(bool is_frame_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_is_frame_object_set(efl::eolian::to_c(is_frame_)));
   }

   /// @brief Get the map enabled state
   ///
   /// This returns the currently enabled state of the map on the object indicated.
   /// The default map enable state is off. You can enable and disable it with
   /// evas_object_map_enable_set().
   ///
   /// @return the map enabled state
   ///
   /// @param enabled enabled state
   ///
   bool map_enable_get() const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_map_enable_get());
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Enable or disable the map that is set.
   ///
   /// Enable or disable the use of map for the object @p obj.
   /// On enable, the object geometry will be saved, and the new geometry will
   /// change (position and size) to reflect the map geometry set.
   ///
   /// If the object doesn't have a map set (with evas_object_map_set()), the
   /// initial geometry will be undefined. It is advised to always set a map
   /// to the object first, and then call this function to enable its use.
   ///
   /// @param enabled enabled state
   ///
   void map_enable_set(bool enabled_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_map_enable_set(efl::eolian::to_c(enabled_)));
   }

   /// @brief Determine whether an object is set to use precise point collision
   /// detection.
   ///
   /// @return whether @p obj is set to use precise point collision
   /// detection or not The default value is false.
   ///
   /// @see evas_object_precise_is_inside_set() for an example
   ///
   /// @ingroup Evas_Object_Group_Extras
   ///
   /// @param precise Whether to use precise point collision detection or
   /// not. The default value is false.
   ///
   bool precise_is_inside_get() const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_precise_is_inside_get());
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Set whether to use precise (usually expensive) point collision
   /// detection for a given Evas object.
   ///
   /// Use this function to make Evas treat objects' transparent areas as
   /// @b not belonging to it with regard to mouse pointer events. By
   /// default, all of the object's boundary rectangle will be taken in
   /// account for them.
   ///
   /// @warning By using precise point collision detection you'll be
   /// making Evas more resource intensive.
   ///
   /// Example code follows.
   /// @dontinclude evas-events.c
   /// @skip if (strcmp(ev->key, "p") == 0)
   /// @until }
   ///
   /// See the full example @ref Example_Evas_Events "here".
   ///
   /// @see evas_object_precise_is_inside_get()
   /// @ingroup Evas_Object_Group_Extras
   ///
   /// @param precise Whether to use precise point collision detection or
   /// not. The default value is false.
   ///
   void precise_is_inside_set(bool precise_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_precise_is_inside_set(efl::eolian::to_c(precise_)));
   }

   /// @brief Retrieves the hints for on object's alignment.
   ///
   /// This is not a size enforcement in any way, it's just a hint that
   /// should be used whenever appropriate.
   ///
   /// @note Use @c NULL pointers on the hint components you're not
   /// interested in: they'll be ignored by the function.
   /// @note If @c obj is invalid, then the hint components will be set with 0.5
   ///
   /// @see evas_object_size_hint_align_set() for more information
   ///
   /// @param x Double, ranging from @c 0.0 to @c 1.0 or with the
   /// special value #EVAS_HINT_FILL, to use as horizontal alignment hint.
   /// @param y Double, ranging from @c 0.0 to @c 1.0 or with the
   /// special value #EVAS_HINT_FILL, to use as vertical alignment hint.
   ///
   void size_hint_align_get(double* x_, double* y_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_size_hint_align_get(x_, y_));
   }

   /// @brief Sets the hints for an object's alignment.
   ///
   /// These are hints on how to align an object <b>inside the boundaries
   /// of a container/manager</b>. Accepted values are in the @c 0.0 to @c
   /// 1.0 range, with the special value #EVAS_HINT_FILL used to specify
   /// "justify" or "fill" by some users. In this case, maximum size hints
   /// should be enforced with higher priority, if they are set. Also, any
   /// padding hint set on objects should add up to the alignment space on
   /// the final scene composition.
   ///
   /// See documentation of possible users: in Evas, they are the @ref
   /// Evas_Object_Box "box" and @ref Evas_Object_Table "table" smart
   /// objects.
   ///
   /// For the horizontal component, @c 0.0 means to the left, @c 1.0
   /// means to the right. Analogously, for the vertical component, @c 0.0
   /// to the top, @c 1.0 means to the bottom.
   ///
   /// See the following figure:
   ///
   /// @image html alignment-hints.png
   /// @image rtf alignment-hints.png
   /// @image latex alignment-hints.eps
   ///
   /// This is not a size enforcement in any way, it's just a hint that
   /// should be used whenever appropriate.
   ///
   /// @note Default alignment hint values are 0.5, for both axis.
   ///
   /// Example:
   /// @dontinclude evas-hints.c
   /// @skip evas_object_size_hint_align_set
   /// @until return
   ///
   /// In this example the alignment hints change the behavior of an Evas
   /// box when layouting its children. See the full @ref
   /// Example_Evas_Size_Hints "example".
   ///
   /// @see evas_object_size_hint_align_get()
   /// @see evas_object_size_hint_max_set()
   /// @see evas_object_size_hint_padding_set()
   ///
   /// @param x Double, ranging from @c 0.0 to @c 1.0 or with the
   /// special value #EVAS_HINT_FILL, to use as horizontal alignment hint.
   /// @param y Double, ranging from @c 0.0 to @c 1.0 or with the
   /// special value #EVAS_HINT_FILL, to use as vertical alignment hint.
   ///
   void size_hint_align_set(double x_, double y_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_size_hint_align_set(x_, y_));
   }

   /// @brief Retrieve whether an Evas object is set to propagate events.
   ///
   /// @return whether @p obj is set to propagate events (@c EINA_TRUE)
   /// or not (@c EINA_FALSE)
   ///
   /// @see evas_object_propagate_events_set()
   /// @see evas_object_repeat_events_get()
   /// @see evas_object_pass_events_get()
   /// @see evas_object_freeze_events_get()
   ///
   /// @param propagate whether to propagate events (@c EINA_TRUE) or not
   /// (@c EINA_FALSE)
   ///
   bool propagate_events_get() const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_propagate_events_get());
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Set whether events on a smart object's member should get propagated
   /// up to its parent.
   ///
   /// This function has @b no effect if @p obj is not a member of a smart
   /// object.
   ///
   /// If @p prop is @c EINA_TRUE, events occurring on this object will be
   /// propagated on to the smart object of which @p obj is a member.  If
   /// @p prop is @c EINA_FALSE, events occurring on this object will @b
   /// not be propagated on to the smart object of which @p obj is a
   /// member.  The default value is @c EINA_TRUE.
   ///
   /// @see evas_object_propagate_events_get()
   /// @see evas_object_repeat_events_set()
   /// @see evas_object_pass_events_set()
   /// @see evas_object_freeze_events_set()
   ///
   /// @param propagate whether to propagate events (@c EINA_TRUE) or not
   /// (@c EINA_FALSE)
   ///
   void propagate_events_set(bool propagate_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_propagate_events_set(efl::eolian::to_c(propagate_)));
   }

   /// @brief Determine whether an object is set to pass (ignore) events.
   ///
   /// @return pass whether @p obj is set to pass events (@c EINA_TRUE) or not
   /// (@c EINA_FALSE)
   ///
   /// Example:
   /// @dontinclude evas-stacking.c
   /// @skip if (strcmp(ev->key, "p") == 0)
   /// @until }
   ///
   /// See the full @ref Example_Evas_Stacking "example".
   ///
   /// @see evas_object_pass_events_set()
   /// @see evas_object_repeat_events_get()
   /// @see evas_object_propagate_events_get()
   /// @see evas_object_freeze_events_get()
   ///
   /// @param pass whether @p obj is to pass events (@c EINA_TRUE) or not
   /// (@c EINA_FALSE)
   ///
   bool pass_events_get() const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_pass_events_get());
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Set whether an Evas object is to pass (ignore) events.
   ///
   /// If @p pass is @c EINA_TRUE, it will make events on @p obj to be @b
   /// ignored. They will be triggered on the @b next lower object (that
   /// is not set to pass events), instead (see evas_object_below_get()).
   ///
   /// If @p pass is @c EINA_FALSE, events will be processed on that
   /// object as normal.
   ///
   /// @see evas_object_pass_events_get() for an example
   /// @see evas_object_repeat_events_set()
   /// @see evas_object_propagate_events_set()
   /// @see evas_object_freeze_events_set()
   ///
   /// @param pass whether @p obj is to pass events (@c EINA_TRUE) or not
   /// (@c EINA_FALSE)
   ///
   void pass_events_set(bool pass_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_pass_events_set(efl::eolian::to_c(pass_)));
   }

   /// @brief Retrieves the position of the given Evas object.
   ///
   /// @param x in
   /// @param y in
   ///
   void position_get(Evas_Coord* x_, Evas_Coord* y_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_position_get(x_, y_));
   }

   /// @brief Move the given Evas object to the given location inside its canvas' viewport.
   ///
   /// @param x in
   /// @param y in
   ///
   void position_set(Evas_Coord x_, Evas_Coord y_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_position_set(x_, y_));
   }

   /// @brief Retrieves whether or not the given Evas object is to be drawn anti_aliased.
   /// @return  (@c EINA_TRUE) if the object is to be anti_aliased.  (@c EINA_FALSE) otherwise.
   /// @ingroup Evas_Object_Group_Extras
   ///
   /// @param anti_alias (@c EINA_TRUE) if the object is to be anti_aliased, (@c EINA_FALSE) otherwise.
   ///
   bool anti_alias_get() const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_anti_alias_get());
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Sets whether or not the given Evas object is to be drawn anti-aliased.
   ///
   /// @ingroup Evas_Object_Group_Extras
   ///
   /// @param anti_alias (@c EINA_TRUE) if the object is to be anti_aliased, (@c EINA_FALSE) otherwise.
   ///
   void anti_alias_set(bool anti_alias_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_anti_alias_set(efl::eolian::to_c(anti_alias_)));
   }

   /// @brief Retrieves the general/main color of the given Evas object.
   ///
   /// Retrieves the “main” color's RGB component (and alpha channel)
   /// values, <b>which range from 0 to 255</b>. For the alpha channel,
   /// which defines the object's transparency level, 0 means totally
   /// transparent, while 255 means opaque. These color values are
   /// premultiplied by the alpha value.
   ///
   /// Usually you’ll use this attribute for text and rectangle objects,
   /// where the “main” color is their unique one. If set for objects
   /// which themselves have colors, like the images one, those colors get
   /// modulated by this one.
   ///
   /// @note All newly created Evas rectangles get the default color
   /// values of <code>255 255 255 255</code> (opaque white).
   ///
   /// @note Use @c NULL pointers on the components you're not interested
   /// in: they'll be ignored by the function.
   ///
   /// Example:
   /// @dontinclude evas-object-manipulation.c
   /// @skip int alpha, r, g, b;
   /// @until return
   ///
   /// See the full @ref Example_Evas_Object_Manipulation "example".
   ///
   /// @ingroup Evas_Object_Group_Basic
   ///
   /// @param r The red component of the given color.
   /// @param g The green component of the given color.
   /// @param b The blue component of the given color.
   /// @param a The alpha component of the given color.
   ///
   void color_get(int* r_, int* g_, int* b_, int* a_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_color_get(r_, g_, b_, a_));
   }

   /// @brief Sets the general/main color of the given Evas object to the given
   /// one.
   ///
   /// @see evas_object_color_get() (for an example)
   /// @note These color values are expected to be premultiplied by @p a.
   ///
   /// @ingroup Evas_Object_Group_Basic
   ///
   /// @param r The red component of the given color.
   /// @param g The green component of the given color.
   /// @param b The blue component of the given color.
   /// @param a The alpha component of the given color.
   ///
   void color_set(int r_, int g_, int b_, int a_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_color_set(r_, g_, b_, a_));
   }

   /// @brief Retrieve user data stored on a given smart object.
   ///
   /// @return A pointer to data stored using
   /// evas_object_smart_data_set(), or @c NULL, if none has been
   /// set.
   ///
   /// @see evas_object_smart_data_set()
   ///
   /// @ingroup Evas_Smart_Object_Group
   ///
   void * smart_data_get() const
   {
      void * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_smart_data_get());
      return _tmp_ret;
   }

   /// @brief Get the clipper object for the given clipped smart object.
   ///
   /// @return the clipper object.
   ///
   /// Use this function if you want to change any of this clipper's
   /// properties, like colors.
   ///
   /// @see evas_object_smart_clipped_smart_add()
   ///
   evas::object smart_clipped_clipper_get() const
   {
      Evas_Object * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_smart_clipped_clipper_get());
      return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Get the Evas object stacked right below @p obj
   ///
   /// @return the #Evas_Object directly below @p obj, if any, or @c NULL,
   /// if none
   ///
   /// This function will traverse layers in its search, if there are
   /// objects on layers below the one @p obj is placed at.
   ///
   /// @see evas_object_layer_get()
   /// @see evas_object_layer_set()
   /// @see evas_object_below_get()
   ///
   evas::object below_get() const
   {
      Evas_Object * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_below_get());
      return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Return a list of objects currently clipped by @p obj.
   ///
   /// @return a list of objects being clipped by @p obj
   ///
   /// This returns the internal list handle that contains all objects
   /// clipped by the object @p obj. If none are clipped by it, the call
   /// returns @c NULL. This list is only valid until the clip list is
   /// changed and should be fetched again with another call to
   /// evas_object_clipees_get() if any objects being clipped by this
   /// object are unclipped, clipped by a new object, deleted or get the
   /// clipper deleted. These operations will invalidate the list
   /// returned, so it should not be used anymore after that point. Any
   /// use of the list after this may have undefined results, possibly
   /// leading to crashes. The object @p obj must be a valid
   /// .Evas_Object.
   ///
   /// See also evas_object_clip_set(), evas_object_clip_unset() and
   /// evas_object_clip_get().
   ///
   /// Example:
   /// @code
   /// extern Evas_Object *obj;
   /// Evas_Object *clipper;
   ///
   /// clipper = evas_object_clip_get(obj);
   /// if (clipper)
   /// {
   /// Eina_List *clippees, *l;
   /// Evas_Object *obj_tmp;
   ///
   /// clippees = evas_object_clipees_get(clipper);
   /// printf("Clipper clips %i objects\n", eina_list_count(clippees));
   /// EINA_LIST_FOREACH(clippees, l, obj_tmp)
   /// evas_object_show(obj_tmp);
   /// }
   /// @endcode
   ///
   efl::eina::crange_list< evas::object > clipees_get() const
   {
      const Eina_List * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_clipees_get());
      return efl::eolian::to_cxx<efl::eina::crange_list< evas::object >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
   }

   /// @brief Gets the parent smart object of a given Evas object, if it has one.
   ///
   /// @return Returns the parent smart object of @a obj or @c NULL, if @a
   /// obj is not a smart member of any
   ///
   /// @ingroup Evas_Smart_Object_Group
   ///
   evas::object smart_parent_get() const
   {
      Evas_Object * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_smart_parent_get());
      return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Get the Evas object stacked right above @p obj
   ///
   /// @return the #Evas_Object directly above @p obj, if any, or @c NULL,
   /// if none
   ///
   /// This function will traverse layers in its search, if there are
   /// objects on layers above the one @p obj is placed at.
   ///
   /// @see evas_object_layer_get()
   /// @see evas_object_layer_set()
   /// @see evas_object_below_get()
   ///
   evas::object above_get() const
   {
      Evas_Object * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_above_get());
      return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Retrieves the hints for an object's display mode
   ///
   /// These are hints on the display mode @p obj. This is
   /// not a size enforcement in any way, it's just a hint that can be
   /// used whenever appropriate.
   /// This mode can be used object's display mode like commpress or expand
   ///
   /// @param dispmode display mode hint
   ///
   Evas_Display_Mode size_hint_display_mode_get() const
   {
      Evas_Display_Mode _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_size_hint_display_mode_get());
      return _tmp_ret;
   }

   /// @brief Sets the hints for an object's disply mode
   ///
   /// This is not a size enforcement in any way, it's just a hint that
   /// can be used whenever appropriate.
   ///
   /// @param dispmode display mode hint
   ///
   void size_hint_display_mode_set(Evas_Display_Mode dispmode_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_size_hint_display_mode_set(dispmode_));
   }

   /// @brief Test if any object is clipped by @p obj.
   ///
   /// @return EINA_TRUE if @p obj clip any object.
   /// @since 1.8
   ///
   bool clipees_has() const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_clipees_has());
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Requests @p keyname key events be directed to @p obj.
   ///
   /// @return @c EINA_TRUE, if the call succeeded, @c EINA_FALSE otherwise.
   ///
   /// Key grabs allow one or more objects to receive key events for
   /// specific key strokes even if other objects have focus. Whenever a
   /// key is grabbed, only the objects grabbing it will get the events
   /// for the given keys.
   ///
   /// @p keyname is a platform dependent symbolic name for the key
   /// pressed (see @ref Evas_Keys for more information).
   ///
   /// @p modifiers and @p not_modifiers are bit masks of all the
   /// modifiers that must and mustn't, respectively, be pressed along
   /// with @p keyname key in order to trigger this new key
   /// grab. Modifiers can be things such as Shift and Ctrl as well as
   /// user defined types via evas_key_modifier_add(). Retrieve them with
   /// evas_key_modifier_mask_get() or use @c 0 for empty masks.
   ///
   /// @p exclusive will make the given object the only one permitted to
   /// grab the given key. If given @c EINA_TRUE, subsequent calls on this
   /// function with different @p obj arguments will fail, unless the key
   /// is ungrabbed again.
   ///
   /// Example code follows.
   /// @dontinclude evas-events.c
   /// @skip if (d.focus)
   /// @until else
   ///
   /// See the full example @ref Example_Evas_Events "here".
   ///
   /// @warning Providing impossible modifier sets creates undefined behavior
   ///
   /// @see evas_object_key_ungrab
   /// @see evas_object_focus_set
   /// @see evas_object_focus_get
   /// @see evas_focus_get
   /// @see evas_key_modifier_add
   ///
   /// @param keyname the key to request events for.
   /// @param modifiers a mask of modifiers that must be present to
   /// trigger the event.
   /// @param not_modifiers a mask of modifiers that must @b not be present
   /// to trigger the event.
   /// @param exclusive request that the @p obj is the only object
   /// receiving the @p keyname events.
   ///
   bool key_grab(std::string keyname_, Evas_Modifier_Mask modifiers_, Evas_Modifier_Mask not_modifiers_, bool exclusive_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_key_grab(efl::eolian::to_c(keyname_), modifiers_, not_modifiers_, efl::eolian::to_c(exclusive_)));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Stack @p obj immediately below @p below
   ///
   /// Objects, in a given canvas, are stacked in the order they get added
   /// to it.  This means that, if they overlap, the highest ones will
   /// cover the lowest ones, in that order. This function is a way to
   /// change the stacking order for the objects.
   ///
   /// This function is intended to be used with <b>objects belonging to
   /// the same layer</b> in a given canvas, otherwise it will fail (and
   /// accomplish nothing).
   ///
   /// If you have smart objects on your canvas and @p obj is a member of
   /// one of them, then @p below must also be a member of the same
   /// smart object.
   ///
   /// Similarly, if @p obj is not a member of a smart object, @p below
   /// must not be either.
   ///
   /// @see evas_object_layer_get()
   /// @see evas_object_layer_set()
   /// @see evas_object_stack_below()
   ///
   /// @param below the object below which to stack
   ///
   void stack_below(evas::object below_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_stack_below(efl::eolian::to_c(below_)));
   }

   /// @brief Raise @p obj to the top of its layer.
   ///
   /// @p obj will, then, be the highest one in the layer it belongs
   /// to. Object on other layers won't get touched.
   ///
   /// @see evas_object_stack_above()
   /// @see evas_object_stack_below()
   /// @see evas_object_lower()
   ///
   void raise() const
   {
      eo_do(_eo_ptr(), ::evas_obj_raise());
   }

   /// @brief Stack @p obj immediately above @p above
   ///
   /// Objects, in a given canvas, are stacked in the order they get added
   /// to it.  This means that, if they overlap, the highest ones will
   /// cover the lowest ones, in that order. This function is a way to
   /// change the stacking order for the objects.
   ///
   /// This function is intended to be used with <b>objects belonging to
   /// the same layer</b> in a given canvas, otherwise it will fail (and
   /// accomplish nothing).
   ///
   /// If you have smart objects on your canvas and @p obj is a member of
   /// one of them, then @p above must also be a member of the same
   /// smart object.
   ///
   /// Similarly, if @p obj is not a member of a smart object, @p above
   /// must not be either.
   ///
   /// @see evas_object_layer_get()
   /// @see evas_object_layer_set()
   /// @see evas_object_stack_below()
   ///
   /// @param above the object above which to stack
   ///
   void stack_above(evas::object above_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_stack_above(efl::eolian::to_c(above_)));
   }

   /// @brief Checks whether a given smart object or any of its smart object
   /// parents is of a given smart class.
   ///
   /// @return @c EINA_TRUE, if @a obj or any of its parents is of type @a
   /// type, @c EINA_FALSE otherwise
   ///
   /// If @p obj is not a smart object, this call will fail
   /// immediately.
   ///
   /// This function supports Eo and legacy inheritance mechanisms. However,
   /// it is recommended to use eo_isa instead if your object is using Eo from
   /// top to bottom.
   ///
   /// The checks use smart classes names and <b>string
   /// comparison</b>. There is a version of this same check using
   /// <b>pointer comparison</b>, since a smart class' name is a single
   /// string in Evas.
   ///
   /// @see evas_object_smart_type_check_ptr()
   /// @see eo_isa
   ///
   /// @ingroup Evas_Smart_Object_Group
   ///
   /// @param type The @b name (type) of the smart class to check for
   ///
   bool smart_type_check(std::string type_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_smart_type_check(efl::eolian::to_c(type_)));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Retrieves the object from children of the given object with the given name.
   /// @return  If successful, the Evas object with the given name.  Otherwise,
   /// @c NULL.
   ///
   /// This looks for the evas object given a name by evas_object_name_set(), but
   /// it ONLY looks at the children of the object *p obj, and will only recurse
   /// into those children if @p recurse is greater than 0. If the name is not
   /// unique within immediate children (or the whole child tree) then it is not
   /// defined which child object will be returned. If @p recurse is set to -1 then
   /// it will recurse without limit.
   ///
   /// @since 1.2
   ///
   /// @ingroup Evas_Object_Group_Find
   ///
   /// @param name The given name.
   /// @param recurse Set to the number of child levels to recurse (0 == don't recurse, 1 == only look at the children of @p obj or their immediate children, but no further etc.).
   ///
   evas::object name_child_find(std::string name_, int recurse_) const
   {
      Evas_Object * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_name_child_find(efl::eolian::to_c(name_), recurse_));
      return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Removes the grab on @p keyname key events by @p obj.
   ///
   /// Removes a key grab on @p obj if @p keyname, @p modifiers, and @p
   /// not_modifiers match.
   ///
   /// Example code follows.
   /// @dontinclude evas-events.c
   /// @skip got here by key grabs
   /// @until }
   ///
   /// See the full example @ref Example_Evas_Events "here".
   ///
   /// @see evas_object_key_grab
   /// @see evas_object_focus_set
   /// @see evas_object_focus_get
   /// @see evas_focus_get
   ///
   /// @param keyname the key the grab is set for.
   /// @param modifiers a mask of modifiers that must be present to
   /// trigger the event.
   /// @param not_modifiers a mask of modifiers that must not not be
   /// present to trigger the event.
   ///
   void key_ungrab(std::string keyname_, Evas_Modifier_Mask modifiers_, Evas_Modifier_Mask not_modifiers_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_key_ungrab(efl::eolian::to_c(keyname_), modifiers_, not_modifiers_));
   }

   /// @brief Lower @p obj to the bottom of its layer.
   ///
   /// @p obj will, then, be the lowest one in the layer it belongs
   /// to. Objects on other layers won't get touched.
   ///
   /// @see evas_object_stack_above()
   /// @see evas_object_stack_below()
   /// @see evas_object_raise()
   ///
   void lower() const
   {
      eo_do(_eo_ptr(), ::evas_obj_lower());
   }

   /// @brief Disable/cease clipping on a clipped @p obj object.
   ///
   /// This function disables clipping for the object @p obj, if it was
   /// already clipped, i.e., its visibility and color get detached from
   /// the previous clipper. If it wasn't, this has no effect. The object
   /// @p obj must be a valid .Evas_Object.
   ///
   /// See also evas_object_clip_set() (for an example),
   /// evas_object_clipees_get() and evas_object_clip_get().
   ///
   void clip_unset() const
   {
      eo_do(_eo_ptr(), ::evas_obj_clip_unset());
   }

   /// @brief Moves all children objects of a given smart object relative to a
   /// given offset.
   ///
   /// This will make each of @p obj object's children to move, from where
   /// they before, with those delta values (offsets) on both directions.
   ///
   /// @note This is most useful on custom smart @c move() functions.
   ///
   /// @note Clipped smart objects already make use of this function on
   /// their @c move() smart function definition.
   ///
   /// @param dx horizontal offset (delta).
   /// @param dy vertical offset (delta).
   ///
   void smart_move_children_relative(Evas_Coord dx_, Evas_Coord dy_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_smart_move_children_relative(dx_, dy_));
   }

   /// @brief Checks whether a given smart object or any of its smart object
   /// parents is of a given smart class, <b>using pointer comparison</b>.
   ///
   /// @return @c EINA_TRUE, if @a obj or any of its parents is of type @a
   /// type, @c EINA_FALSE otherwise
   ///
   /// @see evas_object_smart_type_check() for more details
   /// @see eo_isa
   ///
   /// @ingroup Evas_Smart_Object_Group
   ///
   /// @param type The type (name string) to check for. Must be the name
   ///
   bool smart_type_check_ptr(std::string type_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_smart_type_check_ptr(efl::eolian::to_c(type_)));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   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::move(callback_)) );
      eo_do(_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_MOUSE_IN, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_MOUSE_IN );
   }

   template <typename T>
   void
   callback_mouse_in_call(T* info)
   {
      eo_do(_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_MOUSE_IN, info));
   }
   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::move(callback_)) );
      eo_do(_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_MOUSE_OUT, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_MOUSE_OUT );
   }

   template <typename T>
   void
   callback_mouse_out_call(T* info)
   {
      eo_do(_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_MOUSE_OUT, info));
   }
   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::move(callback_)) );
      eo_do(_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_MOUSE_DOWN, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_MOUSE_DOWN );
   }

   template <typename T>
   void
   callback_mouse_down_call(T* info)
   {
      eo_do(_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_MOUSE_DOWN, info));
   }
   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::move(callback_)) );
      eo_do(_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_MOUSE_UP, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_MOUSE_UP );
   }

   template <typename T>
   void
   callback_mouse_up_call(T* info)
   {
      eo_do(_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_MOUSE_UP, info));
   }
   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::move(callback_)) );
      eo_do(_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_MOUSE_MOVE, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_MOUSE_MOVE );
   }

   template <typename T>
   void
   callback_mouse_move_call(T* info)
   {
      eo_do(_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_MOUSE_MOVE, info));
   }
   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::move(callback_)) );
      eo_do(_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_MOUSE_WHEEL, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_MOUSE_WHEEL );
   }

   template <typename T>
   void
   callback_mouse_wheel_call(T* info)
   {
      eo_do(_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_MOUSE_WHEEL, info));
   }
   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::move(callback_)) );
      eo_do(_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_MULTI_DOWN, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_MULTI_DOWN );
   }

   template <typename T>
   void
   callback_multi_down_call(T* info)
   {
      eo_do(_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_MULTI_DOWN, info));
   }
   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::move(callback_)) );
      eo_do(_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_MULTI_UP, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_MULTI_UP );
   }

   template <typename T>
   void
   callback_multi_up_call(T* info)
   {
      eo_do(_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_MULTI_UP, info));
   }
   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::move(callback_)) );
      eo_do(_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_MULTI_MOVE, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_MULTI_MOVE );
   }

   template <typename T>
   void
   callback_multi_move_call(T* info)
   {
      eo_do(_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_MULTI_MOVE, info));
   }
   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::move(callback_)) );
      eo_do(_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_FREE, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_FREE );
   }

   template <typename T>
   void
   callback_free_call(T* info)
   {
      eo_do(_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_FREE, info));
   }
   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::move(callback_)) );
      eo_do(_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_KEY_DOWN, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_KEY_DOWN );
   }

   template <typename T>
   void
   callback_key_down_call(T* info)
   {
      eo_do(_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_KEY_DOWN, info));
   }
   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::move(callback_)) );
      eo_do(_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_KEY_UP, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_KEY_UP );
   }

   template <typename T>
   void
   callback_key_up_call(T* info)
   {
      eo_do(_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_KEY_UP, info));
   }
   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::move(callback_)) );
      eo_do(_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_FOCUS_IN, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_FOCUS_IN );
   }

   template <typename T>
   void
   callback_focus_in_call(T* info)
   {
      eo_do(_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_FOCUS_IN, info));
   }
   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::move(callback_)) );
      eo_do(_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_FOCUS_OUT, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_FOCUS_OUT );
   }

   template <typename T>
   void
   callback_focus_out_call(T* info)
   {
      eo_do(_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_FOCUS_OUT, info));
   }
   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::move(callback_)) );
      eo_do(_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_SHOW, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_SHOW );
   }

   template <typename T>
   void
   callback_show_call(T* info)
   {
      eo_do(_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_SHOW, info));
   }
   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::move(callback_)) );
      eo_do(_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_HIDE, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_HIDE );
   }

   template <typename T>
   void
   callback_hide_call(T* info)
   {
      eo_do(_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_HIDE, info));
   }
   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::move(callback_)) );
      eo_do(_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_MOVE, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_MOVE );
   }

   template <typename T>
   void
   callback_move_call(T* info)
   {
      eo_do(_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_MOVE, info));
   }
   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::move(callback_)) );
      eo_do(_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_RESIZE, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_RESIZE );
   }

   template <typename T>
   void
   callback_resize_call(T* info)
   {
      eo_do(_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_RESIZE, info));
   }
   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::move(callback_)) );
      eo_do(_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_RESTACK, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_RESTACK );
   }

   template <typename T>
   void
   callback_restack_call(T* info)
   {
      eo_do(_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_RESTACK, info));
   }
   template <typename F>
   ::efl::eo::signal_connection
   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::move(callback_)) );
      eo_do(_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_DEL, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_DEL );
   }

   template <typename T>
   void
   callback_del_call(T* info)
   {
      eo_do(_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_DEL, info));
   }
   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::move(callback_)) );
      eo_do(_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_HOLD, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_HOLD );
   }

   template <typename T>
   void
   callback_hold_call(T* info)
   {
      eo_do(_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_HOLD, info));
   }
   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::move(callback_)) );
      eo_do(_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_CHANGED_SIZE_HINTS, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_CHANGED_SIZE_HINTS );
   }

   template <typename T>
   void
   callback_changed_size_hints_call(T* info)
   {
      eo_do(_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_CHANGED_SIZE_HINTS, info));
   }
   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::move(callback_)) );
      eo_do(_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_IMAGE_PRELOADED, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_IMAGE_PRELOADED );
   }

   template <typename T>
   void
   callback_image_preloaded_call(T* info)
   {
      eo_do(_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_IMAGE_PRELOADED, info));
   }
   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::move(callback_)) );
      eo_do(_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_IMAGE_RESIZE, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_IMAGE_RESIZE );
   }

   template <typename T>
   void
   callback_image_resize_call(T* info)
   {
      eo_do(_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_IMAGE_RESIZE, info));
   }
   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::move(callback_)) );
      eo_do(_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_IMAGE_UNLOADED, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, _eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_IMAGE_UNLOADED );
   }

   template <typename T>
   void
   callback_image_unloaded_call(T* info)
   {
      eo_do(_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_IMAGE_UNLOADED, info));
   }
   static Eo_Class const* _eo_class()
   {
      return(EVAS_OBJECT_CLASS);
   }

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

};
} 

template <typename T>
void evas_object_dbg_info_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Eo_Dbg_Info * root_node_)
{
   static_cast<T*>(self->this_)->dbg_info_get(root_node_);
}

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

template <typename T>
void evas_object_size_hint_max_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Coord* w_, Evas_Coord* h_)
{
   static_cast<T*>(self->this_)->size_hint_max_get(w_, h_);
}

template <typename T>
void evas_object_size_hint_max_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Coord w_, Evas_Coord h_)
{
   static_cast<T*>(self->this_)->size_hint_max_set(w_, h_);
}

template <typename T>
void evas_object_size_hint_request_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Coord* w_, Evas_Coord* h_)
{
   static_cast<T*>(self->this_)->size_hint_request_get(w_, h_);
}

template <typename T>
void evas_object_size_hint_request_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Coord w_, Evas_Coord h_)
{
   static_cast<T*>(self->this_)->size_hint_request_set(w_, h_);
}

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

template <typename T>
void evas_object_visibility_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Eina_Bool v_)
{
   static_cast<T*>(self->this_)->visibility_set(efl::eolian::to_cxx<bool>(v_, std::tuple<std::false_type>()));
}

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

template <typename T>
void evas_object_type_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * type_)
{
   static_cast<T*>(self->this_)->type_set(efl::eolian::to_cxx<std::string>(type_, std::tuple<std::false_type>()));
}

template <typename T>
void evas_object_size_hint_min_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Coord* w_, Evas_Coord* h_)
{
   static_cast<T*>(self->this_)->size_hint_min_get(w_, h_);
}

template <typename T>
void evas_object_size_hint_min_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Coord w_, Evas_Coord h_)
{
   static_cast<T*>(self->this_)->size_hint_min_set(w_, h_);
}

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

template <typename T>
void evas_object_pointer_mode_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Object_Pointer_Mode pointer_mode_)
{
   static_cast<T*>(self->this_)->pointer_mode_set(pointer_mode_);
}

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

template <typename T>
void evas_object_render_op_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Render_Op render_op_)
{
   static_cast<T*>(self->this_)->render_op_set(render_op_);
}

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

template <typename T>
void evas_object_freeze_events_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Eina_Bool freeze_)
{
   static_cast<T*>(self->this_)->freeze_events_set(efl::eolian::to_cxx<bool>(freeze_, std::tuple<std::false_type>()));
}

template <typename T>
const Evas_Map * evas_object_map_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self)
{
   return static_cast<T*>(self->this_)->map_get();
}

template <typename T>
void evas_object_map_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const Evas_Map * map_)
{
   static_cast<T*>(self->this_)->map_set(map_);
}

template <typename T>
void evas_object_size_hint_aspect_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Aspect_Control* aspect_, Evas_Coord* w_, Evas_Coord* h_)
{
   static_cast<T*>(self->this_)->size_hint_aspect_get(aspect_, w_, h_);
}

template <typename T>
void evas_object_size_hint_aspect_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Aspect_Control aspect_, Evas_Coord w_, Evas_Coord h_)
{
   static_cast<T*>(self->this_)->size_hint_aspect_set(aspect_, w_, h_);
}

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

template <typename T>
void evas_object_layer_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, short l_)
{
   static_cast<T*>(self->this_)->layer_set(l_);
}

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

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

template <typename T>
void evas_object_size_hint_padding_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Coord* l_, Evas_Coord* r_, Evas_Coord* t_, Evas_Coord* b_)
{
   static_cast<T*>(self->this_)->size_hint_padding_get(l_, r_, t_, b_);
}

template <typename T>
void evas_object_size_hint_padding_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Coord l_, Evas_Coord r_, Evas_Coord t_, Evas_Coord b_)
{
   static_cast<T*>(self->this_)->size_hint_padding_set(l_, r_, t_, b_);
}

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

template <typename T>
void evas_object_repeat_events_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Eina_Bool repeat_)
{
   static_cast<T*>(self->this_)->repeat_events_set(efl::eolian::to_cxx<bool>(repeat_, std::tuple<std::false_type>()));
}

template <typename T>
void evas_object_size_hint_weight_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, double* x_, double* y_)
{
   static_cast<T*>(self->this_)->size_hint_weight_get(x_, y_);
}

template <typename T>
void evas_object_size_hint_weight_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, double x_, double y_)
{
   static_cast<T*>(self->this_)->size_hint_weight_set(x_, y_);
}

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

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

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

template <typename T>
void evas_object_scale_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, double scale_)
{
   static_cast<T*>(self->this_)->scale_set(scale_);
}

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

template <typename T>
void evas_object_static_clip_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Eina_Bool is_static_clip_)
{
   static_cast<T*>(self->this_)->static_clip_set(efl::eolian::to_cxx<bool>(is_static_clip_, std::tuple<std::false_type>()));
}

template <typename T>
void evas_object_size_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Coord* w_, Evas_Coord* h_)
{
   static_cast<T*>(self->this_)->size_get(w_, h_);
}

template <typename T>
void evas_object_size_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Coord w_, Evas_Coord h_)
{
   static_cast<T*>(self->this_)->size_set(w_, h_);
}

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

template <typename T>
void evas_object_focus_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Eina_Bool focus_)
{
   static_cast<T*>(self->this_)->focus_set(efl::eolian::to_cxx<bool>(focus_, std::tuple<std::false_type>()));
}

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

template <typename T>
void evas_object_is_frame_object_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Eina_Bool is_frame_)
{
   static_cast<T*>(self->this_)->is_frame_object_set(efl::eolian::to_cxx<bool>(is_frame_, std::tuple<std::false_type>()));
}

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

template <typename T>
void evas_object_map_enable_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Eina_Bool enabled_)
{
   static_cast<T*>(self->this_)->map_enable_set(efl::eolian::to_cxx<bool>(enabled_, std::tuple<std::false_type>()));
}

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

template <typename T>
void evas_object_precise_is_inside_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Eina_Bool precise_)
{
   static_cast<T*>(self->this_)->precise_is_inside_set(efl::eolian::to_cxx<bool>(precise_, std::tuple<std::false_type>()));
}

template <typename T>
void evas_object_size_hint_align_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, double* x_, double* y_)
{
   static_cast<T*>(self->this_)->size_hint_align_get(x_, y_);
}

template <typename T>
void evas_object_size_hint_align_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, double x_, double y_)
{
   static_cast<T*>(self->this_)->size_hint_align_set(x_, y_);
}

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

template <typename T>
void evas_object_propagate_events_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Eina_Bool propagate_)
{
   static_cast<T*>(self->this_)->propagate_events_set(efl::eolian::to_cxx<bool>(propagate_, std::tuple<std::false_type>()));
}

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

template <typename T>
void evas_object_pass_events_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Eina_Bool pass_)
{
   static_cast<T*>(self->this_)->pass_events_set(efl::eolian::to_cxx<bool>(pass_, std::tuple<std::false_type>()));
}

template <typename T>
void evas_object_position_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Coord* x_, Evas_Coord* y_)
{
   static_cast<T*>(self->this_)->position_get(x_, y_);
}

template <typename T>
void evas_object_position_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Coord x_, Evas_Coord y_)
{
   static_cast<T*>(self->this_)->position_set(x_, y_);
}

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

template <typename T>
void evas_object_anti_alias_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Eina_Bool anti_alias_)
{
   static_cast<T*>(self->this_)->anti_alias_set(efl::eolian::to_cxx<bool>(anti_alias_, std::tuple<std::false_type>()));
}

template <typename T>
void evas_object_color_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, int* r_, int* g_, int* b_, int* a_)
{
   static_cast<T*>(self->this_)->color_get(r_, g_, b_, a_);
}

template <typename T>
void evas_object_color_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, int r_, int g_, int b_, int a_)
{
   static_cast<T*>(self->this_)->color_set(r_, g_, b_, a_);
}

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

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

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

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

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

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

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

template <typename T>
void evas_object_size_hint_display_mode_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Display_Mode dispmode_)
{
   static_cast<T*>(self->this_)->size_hint_display_mode_set(dispmode_);
}

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

template <typename T>
bool evas_object_key_grab_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * keyname_, Evas_Modifier_Mask modifiers_, Evas_Modifier_Mask not_modifiers_, Eina_Bool exclusive_)
{
   return static_cast<T*>(self->this_)->key_grab(efl::eolian::to_cxx<std::string>(keyname_, std::tuple<std::false_type>()), modifiers_, not_modifiers_, efl::eolian::to_cxx<bool>(exclusive_, std::tuple<std::false_type>()));
}

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

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

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

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

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

template <typename T>
void evas_object_key_ungrab_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * keyname_, Evas_Modifier_Mask modifiers_, Evas_Modifier_Mask not_modifiers_)
{
   static_cast<T*>(self->this_)->key_ungrab(efl::eolian::to_cxx<std::string>(keyname_, std::tuple<std::false_type>()), modifiers_, not_modifiers_);
}

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

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

template <typename T>
void evas_object_smart_move_children_relative_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Coord dx_, Evas_Coord dy_)
{
   static_cast<T*>(self->this_)->smart_move_children_relative(dx_, dy_);
}

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

namespace efl { namespace eo { namespace detail {

template<>
struct operations< evas::object >
{
   template <typename T>
   struct type
   {
      virtual void dbg_info_get(Eo_Dbg_Info * root_node_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::eo_dbg_info_get(root_node_));
      }

      virtual Evas * evas_get()
      {
         Evas * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_common_evas_get());
            return _tmp_ret;
      }

      virtual void size_hint_max_get(Evas_Coord* w_, Evas_Coord* h_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_size_hint_max_get(w_, h_));
      }

      virtual void size_hint_max_set(Evas_Coord w_, Evas_Coord h_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_size_hint_max_set(w_, h_));
      }

      virtual void size_hint_request_get(Evas_Coord* w_, Evas_Coord* h_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_size_hint_request_get(w_, h_));
      }

      virtual void size_hint_request_set(Evas_Coord w_, Evas_Coord h_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_size_hint_request_set(w_, h_));
      }

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

      virtual void visibility_set(bool v_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_visibility_set(efl::eolian::to_c(v_)));
      }

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

      virtual void type_set(std::string type_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_type_set(efl::eolian::to_c(type_)));
      }

      virtual void size_hint_min_get(Evas_Coord* w_, Evas_Coord* h_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_size_hint_min_get(w_, h_));
      }

      virtual void size_hint_min_set(Evas_Coord w_, Evas_Coord h_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_size_hint_min_set(w_, h_));
      }

      virtual Evas_Object_Pointer_Mode pointer_mode_get()
      {
         Evas_Object_Pointer_Mode _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_pointer_mode_get());
            return _tmp_ret;
      }

      virtual void pointer_mode_set(Evas_Object_Pointer_Mode pointer_mode_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_pointer_mode_set(pointer_mode_));
      }

      virtual Evas_Render_Op render_op_get()
      {
         Evas_Render_Op _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_render_op_get());
            return _tmp_ret;
      }

      virtual void render_op_set(Evas_Render_Op render_op_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_render_op_set(render_op_));
      }

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

      virtual void freeze_events_set(bool freeze_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_freeze_events_set(efl::eolian::to_c(freeze_)));
      }

      virtual const Evas_Map * map_get()
      {
         const Evas_Map * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_map_get());
            return _tmp_ret;
      }

      virtual void map_set(const Evas_Map * map_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_map_set(map_));
      }

      virtual void size_hint_aspect_get(Evas_Aspect_Control* aspect_, Evas_Coord* w_, Evas_Coord* h_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_size_hint_aspect_get(aspect_, w_, h_));
      }

      virtual void size_hint_aspect_set(Evas_Aspect_Control aspect_, Evas_Coord w_, Evas_Coord h_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_size_hint_aspect_set(aspect_, w_, h_));
      }

      virtual short layer_get()
      {
         short _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_layer_get());
            return _tmp_ret;
      }

      virtual void layer_set(short l_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_layer_set(l_));
      }

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

      virtual void clip_set(evas::object clip_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_clip_set(efl::eolian::to_c(clip_)));
      }

      virtual void size_hint_padding_get(Evas_Coord* l_, Evas_Coord* r_, Evas_Coord* t_, Evas_Coord* b_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_size_hint_padding_get(l_, r_, t_, b_));
      }

      virtual void size_hint_padding_set(Evas_Coord l_, Evas_Coord r_, Evas_Coord t_, Evas_Coord b_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_size_hint_padding_set(l_, r_, t_, b_));
      }

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

      virtual void repeat_events_set(bool repeat_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_repeat_events_set(efl::eolian::to_c(repeat_)));
      }

      virtual void size_hint_weight_get(double* x_, double* y_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_size_hint_weight_get(x_, y_));
      }

      virtual void size_hint_weight_set(double x_, double y_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_size_hint_weight_set(x_, y_));
      }

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

      virtual void name_set(std::string name_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_name_set(efl::eolian::to_c(name_)));
      }

      virtual double scale_get()
      {
         double _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_scale_get());
            return _tmp_ret;
      }

      virtual void scale_set(double scale_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_scale_set(scale_));
      }

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

      virtual void static_clip_set(bool is_static_clip_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_static_clip_set(efl::eolian::to_c(is_static_clip_)));
      }

      virtual void size_get(Evas_Coord* w_, Evas_Coord* h_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_size_get(w_, h_));
      }

      virtual void size_set(Evas_Coord w_, Evas_Coord h_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_size_set(w_, h_));
      }

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

      virtual void focus_set(bool focus_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_focus_set(efl::eolian::to_c(focus_)));
      }

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

      virtual void is_frame_object_set(bool is_frame_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_is_frame_object_set(efl::eolian::to_c(is_frame_)));
      }

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

      virtual void map_enable_set(bool enabled_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_map_enable_set(efl::eolian::to_c(enabled_)));
      }

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

      virtual void precise_is_inside_set(bool precise_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_precise_is_inside_set(efl::eolian::to_c(precise_)));
      }

      virtual void size_hint_align_get(double* x_, double* y_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_size_hint_align_get(x_, y_));
      }

      virtual void size_hint_align_set(double x_, double y_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_size_hint_align_set(x_, y_));
      }

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

      virtual void propagate_events_set(bool propagate_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_propagate_events_set(efl::eolian::to_c(propagate_)));
      }

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

      virtual void pass_events_set(bool pass_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_pass_events_set(efl::eolian::to_c(pass_)));
      }

      virtual void position_get(Evas_Coord* x_, Evas_Coord* y_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_position_get(x_, y_));
      }

      virtual void position_set(Evas_Coord x_, Evas_Coord y_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_position_set(x_, y_));
      }

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

      virtual void anti_alias_set(bool anti_alias_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_anti_alias_set(efl::eolian::to_c(anti_alias_)));
      }

      virtual void color_get(int* r_, int* g_, int* b_, int* a_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_color_get(r_, g_, b_, a_));
      }

      virtual void color_set(int r_, int g_, int b_, int a_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_color_set(r_, g_, b_, a_));
      }

      virtual void * smart_data_get()
      {
         void * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_smart_data_get());
            return _tmp_ret;
      }

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

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

      virtual efl::eina::crange_list< evas::object > clipees_get()
      {
         const Eina_List * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_clipees_get());
            return efl::eolian::to_cxx<efl::eina::crange_list< evas::object >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
      }

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

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

      virtual Evas_Display_Mode size_hint_display_mode_get()
      {
         Evas_Display_Mode _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_size_hint_display_mode_get());
            return _tmp_ret;
      }

      virtual void size_hint_display_mode_set(Evas_Display_Mode dispmode_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_size_hint_display_mode_set(dispmode_));
      }

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

      virtual bool key_grab(std::string keyname_, Evas_Modifier_Mask modifiers_, Evas_Modifier_Mask not_modifiers_, bool exclusive_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_key_grab(efl::eolian::to_c(keyname_), modifiers_, not_modifiers_, efl::eolian::to_c(exclusive_)));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void stack_below(evas::object below_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_stack_below(efl::eolian::to_c(below_)));
      }

      virtual void raise()
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_raise());
      }

      virtual void stack_above(evas::object above_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_stack_above(efl::eolian::to_c(above_)));
      }

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

      virtual evas::object name_child_find(std::string name_, int recurse_)
      {
         Evas_Object * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_name_child_find(efl::eolian::to_c(name_), recurse_));
            return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void key_ungrab(std::string keyname_, Evas_Modifier_Mask modifiers_, Evas_Modifier_Mask not_modifiers_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_key_ungrab(efl::eolian::to_c(keyname_), modifiers_, not_modifiers_));
      }

      virtual void lower()
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_lower());
      }

      virtual void clip_unset()
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_clip_unset());
      }

      virtual void smart_move_children_relative(Evas_Coord dx_, Evas_Coord dy_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_smart_move_children_relative(dx_, dy_));
      }

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

   };
};


template<>
struct operation_description_class_size< evas::object >
{
   static const int value = 80;
};

template <typename T>
int initialize_operation_description(efl::eo::detail::tag<evas::object>
                                 , Eo_Op_Description* ops)
{
   (void)ops;
   ops[0].func = reinterpret_cast<void*>(& ::evas_object_dbg_info_get_wrapper<T>);
   ops[0].api_func = reinterpret_cast<void*>(& ::eo_dbg_info_get);
   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_object_evas_get_wrapper<T>);
   ops[1].api_func = reinterpret_cast<void*>(& ::evas_common_evas_get);
   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_object_size_hint_max_get_wrapper<T>);
   ops[2].api_func = reinterpret_cast<void*>(& ::evas_obj_size_hint_max_get);
   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_object_size_hint_max_set_wrapper<T>);
   ops[3].api_func = reinterpret_cast<void*>(& ::evas_obj_size_hint_max_set);
   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_object_size_hint_request_get_wrapper<T>);
   ops[4].api_func = reinterpret_cast<void*>(& ::evas_obj_size_hint_request_get);
   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_object_size_hint_request_set_wrapper<T>);
   ops[5].api_func = reinterpret_cast<void*>(& ::evas_obj_size_hint_request_set);
   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_object_visibility_get_wrapper<T>);
   ops[6].api_func = reinterpret_cast<void*>(& ::evas_obj_visibility_get);
   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_object_visibility_set_wrapper<T>);
   ops[7].api_func = reinterpret_cast<void*>(& ::evas_obj_visibility_set);
   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_object_type_get_wrapper<T>);
   ops[8].api_func = reinterpret_cast<void*>(& ::evas_obj_type_get);
   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_object_type_set_wrapper<T>);
   ops[9].api_func = reinterpret_cast<void*>(& ::evas_obj_type_set);
   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_object_size_hint_min_get_wrapper<T>);
   ops[10].api_func = reinterpret_cast<void*>(& ::evas_obj_size_hint_min_get);
   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_object_size_hint_min_set_wrapper<T>);
   ops[11].api_func = reinterpret_cast<void*>(& ::evas_obj_size_hint_min_set);
   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_object_pointer_mode_get_wrapper<T>);
   ops[12].api_func = reinterpret_cast<void*>(& ::evas_obj_pointer_mode_get);
   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_object_pointer_mode_set_wrapper<T>);
   ops[13].api_func = reinterpret_cast<void*>(& ::evas_obj_pointer_mode_set);
   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_object_render_op_get_wrapper<T>);
   ops[14].api_func = reinterpret_cast<void*>(& ::evas_obj_render_op_get);
   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_object_render_op_set_wrapper<T>);
   ops[15].api_func = reinterpret_cast<void*>(& ::evas_obj_render_op_set);
   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_object_freeze_events_get_wrapper<T>);
   ops[16].api_func = reinterpret_cast<void*>(& ::evas_obj_freeze_events_get);
   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_object_freeze_events_set_wrapper<T>);
   ops[17].api_func = reinterpret_cast<void*>(& ::evas_obj_freeze_events_set);
   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_object_map_get_wrapper<T>);
   ops[18].api_func = reinterpret_cast<void*>(& ::evas_obj_map_get);
   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_object_map_set_wrapper<T>);
   ops[19].api_func = reinterpret_cast<void*>(& ::evas_obj_map_set);
   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_object_size_hint_aspect_get_wrapper<T>);
   ops[20].api_func = reinterpret_cast<void*>(& ::evas_obj_size_hint_aspect_get);
   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_object_size_hint_aspect_set_wrapper<T>);
   ops[21].api_func = reinterpret_cast<void*>(& ::evas_obj_size_hint_aspect_set);
   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_object_layer_get_wrapper<T>);
   ops[22].api_func = reinterpret_cast<void*>(& ::evas_obj_layer_get);
   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_object_layer_set_wrapper<T>);
   ops[23].api_func = reinterpret_cast<void*>(& ::evas_obj_layer_set);
   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_object_clip_get_wrapper<T>);
   ops[24].api_func = reinterpret_cast<void*>(& ::evas_obj_clip_get);
   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_object_clip_set_wrapper<T>);
   ops[25].api_func = reinterpret_cast<void*>(& ::evas_obj_clip_set);
   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_object_size_hint_padding_get_wrapper<T>);
   ops[26].api_func = reinterpret_cast<void*>(& ::evas_obj_size_hint_padding_get);
   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_object_size_hint_padding_set_wrapper<T>);
   ops[27].api_func = reinterpret_cast<void*>(& ::evas_obj_size_hint_padding_set);
   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_object_repeat_events_get_wrapper<T>);
   ops[28].api_func = reinterpret_cast<void*>(& ::evas_obj_repeat_events_get);
   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_object_repeat_events_set_wrapper<T>);
   ops[29].api_func = reinterpret_cast<void*>(& ::evas_obj_repeat_events_set);
   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_object_size_hint_weight_get_wrapper<T>);
   ops[30].api_func = reinterpret_cast<void*>(& ::evas_obj_size_hint_weight_get);
   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_object_size_hint_weight_set_wrapper<T>);
   ops[31].api_func = reinterpret_cast<void*>(& ::evas_obj_size_hint_weight_set);
   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_object_name_get_wrapper<T>);
   ops[32].api_func = reinterpret_cast<void*>(& ::evas_obj_name_get);
   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_object_name_set_wrapper<T>);
   ops[33].api_func = reinterpret_cast<void*>(& ::evas_obj_name_set);
   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_object_scale_get_wrapper<T>);
   ops[34].api_func = reinterpret_cast<void*>(& ::evas_obj_scale_get);
   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_object_scale_set_wrapper<T>);
   ops[35].api_func = reinterpret_cast<void*>(& ::evas_obj_scale_set);
   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_object_static_clip_get_wrapper<T>);
   ops[36].api_func = reinterpret_cast<void*>(& ::evas_obj_static_clip_get);
   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_object_static_clip_set_wrapper<T>);
   ops[37].api_func = reinterpret_cast<void*>(& ::evas_obj_static_clip_set);
   ops[37].op = EO_OP_OVERRIDE;
   ops[37].op_type = EO_OP_TYPE_REGULAR;
   ops[37].doc = NULL;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

inline void
call_constructor(tag< evas::object >
               , Eo* eo, Eo_Class const* cls EINA_UNUSED,
               args_class<evas::object, ::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::object>
{
   template <typename U>
   struct type
   {
      operator evas::object() const
      {
         return evas::object(eo_ref(static_cast<U const*>(this)->_eo_ptr()));
      }

      void dbg_info_get(Eo_Dbg_Info * root_node_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::eo_dbg_info_get(root_node_));
      }

      Evas * evas_get()
      {
         Evas * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_common_evas_get());
            return _tmp_ret;
      }

      void size_hint_max_get(Evas_Coord* w_, Evas_Coord* h_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_size_hint_max_get(w_, h_));
      }

      void size_hint_max_set(Evas_Coord w_, Evas_Coord h_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_size_hint_max_set(w_, h_));
      }

      void size_hint_request_get(Evas_Coord* w_, Evas_Coord* h_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_size_hint_request_get(w_, h_));
      }

      void size_hint_request_set(Evas_Coord w_, Evas_Coord h_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_size_hint_request_set(w_, h_));
      }

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

      void visibility_set(bool v_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_visibility_set(efl::eolian::to_c(v_)));
      }

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

      void type_set(std::string type_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_type_set(efl::eolian::to_c(type_)));
      }

      void size_hint_min_get(Evas_Coord* w_, Evas_Coord* h_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_size_hint_min_get(w_, h_));
      }

      void size_hint_min_set(Evas_Coord w_, Evas_Coord h_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_size_hint_min_set(w_, h_));
      }

      Evas_Object_Pointer_Mode pointer_mode_get()
      {
         Evas_Object_Pointer_Mode _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_pointer_mode_get());
            return _tmp_ret;
      }

      void pointer_mode_set(Evas_Object_Pointer_Mode pointer_mode_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_pointer_mode_set(pointer_mode_));
      }

      Evas_Render_Op render_op_get()
      {
         Evas_Render_Op _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_render_op_get());
            return _tmp_ret;
      }

      void render_op_set(Evas_Render_Op render_op_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_render_op_set(render_op_));
      }

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

      void freeze_events_set(bool freeze_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_freeze_events_set(efl::eolian::to_c(freeze_)));
      }

      const Evas_Map * map_get()
      {
         const Evas_Map * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_map_get());
            return _tmp_ret;
      }

      void map_set(const Evas_Map * map_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_map_set(map_));
      }

      void size_hint_aspect_get(Evas_Aspect_Control* aspect_, Evas_Coord* w_, Evas_Coord* h_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_size_hint_aspect_get(aspect_, w_, h_));
      }

      void size_hint_aspect_set(Evas_Aspect_Control aspect_, Evas_Coord w_, Evas_Coord h_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_size_hint_aspect_set(aspect_, w_, h_));
      }

      short layer_get()
      {
         short _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_layer_get());
            return _tmp_ret;
      }

      void layer_set(short l_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_layer_set(l_));
      }

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

      void clip_set(evas::object clip_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_clip_set(efl::eolian::to_c(clip_)));
      }

      void size_hint_padding_get(Evas_Coord* l_, Evas_Coord* r_, Evas_Coord* t_, Evas_Coord* b_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_size_hint_padding_get(l_, r_, t_, b_));
      }

      void size_hint_padding_set(Evas_Coord l_, Evas_Coord r_, Evas_Coord t_, Evas_Coord b_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_size_hint_padding_set(l_, r_, t_, b_));
      }

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

      void repeat_events_set(bool repeat_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_repeat_events_set(efl::eolian::to_c(repeat_)));
      }

      void size_hint_weight_get(double* x_, double* y_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_size_hint_weight_get(x_, y_));
      }

      void size_hint_weight_set(double x_, double y_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_size_hint_weight_set(x_, y_));
      }

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

      void name_set(std::string name_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_name_set(efl::eolian::to_c(name_)));
      }

      double scale_get()
      {
         double _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_scale_get());
            return _tmp_ret;
      }

      void scale_set(double scale_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_scale_set(scale_));
      }

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

      void static_clip_set(bool is_static_clip_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_static_clip_set(efl::eolian::to_c(is_static_clip_)));
      }

      void size_get(Evas_Coord* w_, Evas_Coord* h_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_size_get(w_, h_));
      }

      void size_set(Evas_Coord w_, Evas_Coord h_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_size_set(w_, h_));
      }

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

      void focus_set(bool focus_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_focus_set(efl::eolian::to_c(focus_)));
      }

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

      void is_frame_object_set(bool is_frame_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_is_frame_object_set(efl::eolian::to_c(is_frame_)));
      }

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

      void map_enable_set(bool enabled_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_map_enable_set(efl::eolian::to_c(enabled_)));
      }

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

      void precise_is_inside_set(bool precise_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_precise_is_inside_set(efl::eolian::to_c(precise_)));
      }

      void size_hint_align_get(double* x_, double* y_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_size_hint_align_get(x_, y_));
      }

      void size_hint_align_set(double x_, double y_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_size_hint_align_set(x_, y_));
      }

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

      void propagate_events_set(bool propagate_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_propagate_events_set(efl::eolian::to_c(propagate_)));
      }

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

      void pass_events_set(bool pass_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_pass_events_set(efl::eolian::to_c(pass_)));
      }

      void position_get(Evas_Coord* x_, Evas_Coord* y_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_position_get(x_, y_));
      }

      void position_set(Evas_Coord x_, Evas_Coord y_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_position_set(x_, y_));
      }

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

      void anti_alias_set(bool anti_alias_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_anti_alias_set(efl::eolian::to_c(anti_alias_)));
      }

      void color_get(int* r_, int* g_, int* b_, int* a_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_color_get(r_, g_, b_, a_));
      }

      void color_set(int r_, int g_, int b_, int a_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_color_set(r_, g_, b_, a_));
      }

      void * smart_data_get()
      {
         void * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_smart_data_get());
            return _tmp_ret;
      }

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

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

      efl::eina::crange_list< evas::object > clipees_get()
      {
         const Eina_List * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_clipees_get());
            return efl::eolian::to_cxx<efl::eina::crange_list< evas::object >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
      }

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

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

      Evas_Display_Mode size_hint_display_mode_get()
      {
         Evas_Display_Mode _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_size_hint_display_mode_get());
            return _tmp_ret;
      }

      void size_hint_display_mode_set(Evas_Display_Mode dispmode_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_size_hint_display_mode_set(dispmode_));
      }

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

      bool key_grab(std::string keyname_, Evas_Modifier_Mask modifiers_, Evas_Modifier_Mask not_modifiers_, bool exclusive_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_key_grab(efl::eolian::to_c(keyname_), modifiers_, not_modifiers_, efl::eolian::to_c(exclusive_)));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      void stack_below(evas::object below_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_stack_below(efl::eolian::to_c(below_)));
      }

      void raise()
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_raise());
      }

      void stack_above(evas::object above_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_stack_above(efl::eolian::to_c(above_)));
      }

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

      evas::object name_child_find(std::string name_, int recurse_)
      {
         Evas_Object * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_name_child_find(efl::eolian::to_c(name_), recurse_));
            return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }

      void key_ungrab(std::string keyname_, Evas_Modifier_Mask modifiers_, Evas_Modifier_Mask not_modifiers_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_key_ungrab(efl::eolian::to_c(keyname_), modifiers_, not_modifiers_));
      }

      void lower()
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_lower());
      }

      void clip_unset()
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_clip_unset());
      }

      void smart_move_children_relative(Evas_Coord dx_, Evas_Coord dy_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_smart_move_children_relative(dx_, dy_));
      }

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

   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::move(callback_)) );
      eo_do(static_cast<U*>(this)->_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_MOUSE_IN, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, static_cast<U*>(this)->_eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_MOUSE_IN );
   }

   template <typename T>
   void
   callback_mouse_in_call(T* info)
   {
      eo_do(static_cast<U*>(this)->_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_MOUSE_IN, info));
   }
   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::move(callback_)) );
      eo_do(static_cast<U*>(this)->_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_MOUSE_OUT, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, static_cast<U*>(this)->_eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_MOUSE_OUT );
   }

   template <typename T>
   void
   callback_mouse_out_call(T* info)
   {
      eo_do(static_cast<U*>(this)->_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_MOUSE_OUT, info));
   }
   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::move(callback_)) );
      eo_do(static_cast<U*>(this)->_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_MOUSE_DOWN, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, static_cast<U*>(this)->_eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_MOUSE_DOWN );
   }

   template <typename T>
   void
   callback_mouse_down_call(T* info)
   {
      eo_do(static_cast<U*>(this)->_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_MOUSE_DOWN, info));
   }
   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::move(callback_)) );
      eo_do(static_cast<U*>(this)->_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_MOUSE_UP, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, static_cast<U*>(this)->_eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_MOUSE_UP );
   }

   template <typename T>
   void
   callback_mouse_up_call(T* info)
   {
      eo_do(static_cast<U*>(this)->_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_MOUSE_UP, info));
   }
   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::move(callback_)) );
      eo_do(static_cast<U*>(this)->_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_MOUSE_MOVE, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, static_cast<U*>(this)->_eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_MOUSE_MOVE );
   }

   template <typename T>
   void
   callback_mouse_move_call(T* info)
   {
      eo_do(static_cast<U*>(this)->_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_MOUSE_MOVE, info));
   }
   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::move(callback_)) );
      eo_do(static_cast<U*>(this)->_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_MOUSE_WHEEL, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, static_cast<U*>(this)->_eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_MOUSE_WHEEL );
   }

   template <typename T>
   void
   callback_mouse_wheel_call(T* info)
   {
      eo_do(static_cast<U*>(this)->_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_MOUSE_WHEEL, info));
   }
   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::move(callback_)) );
      eo_do(static_cast<U*>(this)->_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_MULTI_DOWN, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, static_cast<U*>(this)->_eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_MULTI_DOWN );
   }

   template <typename T>
   void
   callback_multi_down_call(T* info)
   {
      eo_do(static_cast<U*>(this)->_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_MULTI_DOWN, info));
   }
   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::move(callback_)) );
      eo_do(static_cast<U*>(this)->_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_MULTI_UP, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, static_cast<U*>(this)->_eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_MULTI_UP );
   }

   template <typename T>
   void
   callback_multi_up_call(T* info)
   {
      eo_do(static_cast<U*>(this)->_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_MULTI_UP, info));
   }
   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::move(callback_)) );
      eo_do(static_cast<U*>(this)->_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_MULTI_MOVE, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, static_cast<U*>(this)->_eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_MULTI_MOVE );
   }

   template <typename T>
   void
   callback_multi_move_call(T* info)
   {
      eo_do(static_cast<U*>(this)->_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_MULTI_MOVE, info));
   }
   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::move(callback_)) );
      eo_do(static_cast<U*>(this)->_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_FREE, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, static_cast<U*>(this)->_eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_FREE );
   }

   template <typename T>
   void
   callback_free_call(T* info)
   {
      eo_do(static_cast<U*>(this)->_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_FREE, info));
   }
   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::move(callback_)) );
      eo_do(static_cast<U*>(this)->_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_KEY_DOWN, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, static_cast<U*>(this)->_eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_KEY_DOWN );
   }

   template <typename T>
   void
   callback_key_down_call(T* info)
   {
      eo_do(static_cast<U*>(this)->_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_KEY_DOWN, info));
   }
   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::move(callback_)) );
      eo_do(static_cast<U*>(this)->_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_KEY_UP, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, static_cast<U*>(this)->_eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_KEY_UP );
   }

   template <typename T>
   void
   callback_key_up_call(T* info)
   {
      eo_do(static_cast<U*>(this)->_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_KEY_UP, info));
   }
   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::move(callback_)) );
      eo_do(static_cast<U*>(this)->_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_FOCUS_IN, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, static_cast<U*>(this)->_eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_FOCUS_IN );
   }

   template <typename T>
   void
   callback_focus_in_call(T* info)
   {
      eo_do(static_cast<U*>(this)->_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_FOCUS_IN, info));
   }
   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::move(callback_)) );
      eo_do(static_cast<U*>(this)->_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_FOCUS_OUT, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, static_cast<U*>(this)->_eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_FOCUS_OUT );
   }

   template <typename T>
   void
   callback_focus_out_call(T* info)
   {
      eo_do(static_cast<U*>(this)->_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_FOCUS_OUT, info));
   }
   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::move(callback_)) );
      eo_do(static_cast<U*>(this)->_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_SHOW, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, static_cast<U*>(this)->_eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_SHOW );
   }

   template <typename T>
   void
   callback_show_call(T* info)
   {
      eo_do(static_cast<U*>(this)->_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_SHOW, info));
   }
   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::move(callback_)) );
      eo_do(static_cast<U*>(this)->_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_HIDE, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, static_cast<U*>(this)->_eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_HIDE );
   }

   template <typename T>
   void
   callback_hide_call(T* info)
   {
      eo_do(static_cast<U*>(this)->_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_HIDE, info));
   }
   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::move(callback_)) );
      eo_do(static_cast<U*>(this)->_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_MOVE, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, static_cast<U*>(this)->_eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_MOVE );
   }

   template <typename T>
   void
   callback_move_call(T* info)
   {
      eo_do(static_cast<U*>(this)->_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_MOVE, info));
   }
   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::move(callback_)) );
      eo_do(static_cast<U*>(this)->_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_RESIZE, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, static_cast<U*>(this)->_eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_RESIZE );
   }

   template <typename T>
   void
   callback_resize_call(T* info)
   {
      eo_do(static_cast<U*>(this)->_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_RESIZE, info));
   }
   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::move(callback_)) );
      eo_do(static_cast<U*>(this)->_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_RESTACK, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, static_cast<U*>(this)->_eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_RESTACK );
   }

   template <typename T>
   void
   callback_restack_call(T* info)
   {
      eo_do(static_cast<U*>(this)->_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_RESTACK, info));
   }
   template <typename F>
   ::efl::eo::signal_connection
   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::move(callback_)) );
      eo_do(static_cast<U*>(this)->_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_DEL, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, static_cast<U*>(this)->_eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_DEL );
   }

   template <typename T>
   void
   callback_del_call(T* info)
   {
      eo_do(static_cast<U*>(this)->_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_DEL, info));
   }
   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::move(callback_)) );
      eo_do(static_cast<U*>(this)->_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_HOLD, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, static_cast<U*>(this)->_eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_HOLD );
   }

   template <typename T>
   void
   callback_hold_call(T* info)
   {
      eo_do(static_cast<U*>(this)->_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_HOLD, info));
   }
   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::move(callback_)) );
      eo_do(static_cast<U*>(this)->_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_CHANGED_SIZE_HINTS, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, static_cast<U*>(this)->_eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_CHANGED_SIZE_HINTS );
   }

   template <typename T>
   void
   callback_changed_size_hints_call(T* info)
   {
      eo_do(static_cast<U*>(this)->_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_CHANGED_SIZE_HINTS, info));
   }
   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::move(callback_)) );
      eo_do(static_cast<U*>(this)->_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_IMAGE_PRELOADED, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, static_cast<U*>(this)->_eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_IMAGE_PRELOADED );
   }

   template <typename T>
   void
   callback_image_preloaded_call(T* info)
   {
      eo_do(static_cast<U*>(this)->_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_IMAGE_PRELOADED, info));
   }
   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::move(callback_)) );
      eo_do(static_cast<U*>(this)->_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_IMAGE_RESIZE, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, static_cast<U*>(this)->_eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_IMAGE_RESIZE );
   }

   template <typename T>
   void
   callback_image_resize_call(T* info)
   {
      eo_do(static_cast<U*>(this)->_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_IMAGE_RESIZE, info));
   }
   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::move(callback_)) );
      eo_do(static_cast<U*>(this)->_eo_ptr(),
            eo_event_callback_priority_add
            (EVAS_OBJECT_EVENT_IMAGE_UNLOADED, priority_,
            &efl::eo::_detail::event_callback<evas::object, function_type>, f.get()));
      return ::efl::eo::make_signal_connection
         (f, static_cast<U*>(this)->_eo_ptr(), &efl::eo::_detail::event_callback<evas::object, function_type>,
         EVAS_OBJECT_EVENT_IMAGE_UNLOADED );
   }

   template <typename T>
   void
   callback_image_unloaded_call(T* info)
   {
      eo_do(static_cast<U*>(this)->_eo_ptr(), eo_event_callback_call
            (EVAS_OBJECT_EVENT_IMAGE_UNLOADED, info));
   }
   };
};

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

} } }
#endif // EFL_GENERATED_EVAS_OBJECT_HH

