#ifndef EFL_GENERATED_EVAS_CANVAS_HH
#define EFL_GENERATED_EVAS_CANVAS_HH

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

#include <eo_cxx_interop.hh>

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

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

namespace evas {

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

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

   /// @brief nullptr_t Constructor.
   ///
   /// Constructs an empty (null) object.
   ///
   explicit canvas(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.
   ///
   canvas(efl::eo::parent_type _p = (efl::eo::parent = nullptr))
      : canvas(_c0(_p))
   {}

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

   ~canvas() {}

   /// @brief thaw events of object.
   /// Lets event callbacks be called for the object.
   ///
   void event_thaw() const
   {
      eo_do(_eo_ptr(), ::eo_event_thaw());
   }

   /// @brief freeze events of object.
   /// Prevents event callbacks from being called for the object.
   ///
   void event_freeze() const
   {
      eo_do(_eo_ptr(), ::eo_event_freeze());
   }

   /// @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 Get the render engine's output framespace co-ordinates in canvas units.
   ///
   /// @ingroup Evas_Output_Size
   /// @since 1.1
   ///
   /// @param x The left coordinate in output units, usually pixels.
   /// @param y The top coordinate in output units, usually pixels.
   /// @param w The width in output units, usually pixels.
   /// @param h The height in output units, usually pixels.
   ///
   void output_framespace_get(Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_output_framespace_get(x_, y_, w_, h_));
   }

   /// @brief Sets the output framespace size of the render engine of the given evas.
   ///
   /// The framespace size is used in the Wayland engines to denote space where
   /// the output is not drawn. This is mainly used in ecore_evas to draw borders
   ///
   /// The units used for @p w and @p h depend on the engine used by the
   /// evas.
   ///
   /// @ingroup Evas_Output_Size
   /// @since 1.1
   ///
   /// @param x The left coordinate in output units, usually pixels.
   /// @param y The top coordinate in output units, usually pixels.
   /// @param w The width in output units, usually pixels.
   /// @param h The height in output units, usually pixels.
   ///
   void output_framespace_set(Evas_Coord x_, Evas_Coord y_, Evas_Coord w_, Evas_Coord h_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_output_framespace_set(x_, y_, w_, h_));
   }

   /// @brief Get the render engine's output viewport co-ordinates in canvas units.
   /// Calling this function writes the current canvas output viewport
   /// size and location values into the variables pointed to by @p x, @p
   /// y, @p w and @p h.  On success the variables have the output
   /// location and size values written to them in canvas units. Any of @p
   /// x, @p y, @p w or @p h that are @c NULL will not be written to. If @p e
   /// is invalid, the results are undefined.
   ///
   /// Example:
   /// @code
   /// extern Evas *evas;
   /// Evas_Coord x, y, width, height;
   ///
   /// evas_output_viewport_get(evas, &x, &y, &w, &h);
   /// @endcode
   ///
   /// @param x The top-left corner x value of the viewport.
   /// @param y The top-left corner y value of the viewport.
   /// @param w The width of the viewport.  Must be greater than 0.
   /// @param h The height of the viewport.  Must be greater than 0.
   ///
   void output_viewport_get(Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_output_viewport_get(x_, y_, w_, h_));
   }

   /// @brief Sets the output viewport of the given evas in evas units.
   ///
   /// The output viewport is the area of the evas that will be visible to
   /// the viewer.  The viewport will be stretched to fit the output
   /// target of the evas when rendering is performed.
   ///
   /// @note The coordinate values do not have to map 1-to-1 with the output
   /// target.  However, it is generally advised that it is done for ease
   /// of use.
   ///
   /// @ingroup Evas_Output_Size
   ///
   /// @param x The top-left corner x value of the viewport.
   /// @param y The top-left corner y value of the viewport.
   /// @param w The width of the viewport.  Must be greater than 0.
   /// @param h The height of the viewport.  Must be greater than 0.
   ///
   void output_viewport_set(Evas_Coord x_, Evas_Coord y_, Evas_Coord w_, Evas_Coord h_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_output_viewport_set(x_, y_, w_, h_));
   }

   /// @brief Get the image cache
   ///
   /// This function returns the image cache size of canvas in bytes.
   ///
   /// @param size The cache size.
   ///
   int image_cache_get() const
   {
      int _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_image_cache_get());
      return _tmp_ret;
   }

   /// @brief Set the image cache.
   ///
   /// This function sets the image cache of canvas in bytes.
   ///
   /// @param size The cache size.
   ///
   void image_cache_set(int size_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_image_cache_set(size_));
   }

   /// @brief Get the default set of flags an event begins with
   ///
   /// @return The default event flags for that canvas
   ///
   /// This gets the default event flags events are produced with when fed in.
   ///
   /// @see evas_event_default_flags_set()
   /// @since 1.2
   ///
   /// @param flags The default flags to use
   ///
   Evas_Event_Flags event_default_flags_get() const
   {
      Evas_Event_Flags _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_event_default_flags_get());
      return _tmp_ret;
   }

   /// @brief Set the default set of flags an event begins with
   ///
   /// Events in evas can have an event_flags member. This starts out with
   /// and initial value (no flags). This lets you set the default flags that
   /// an event begins with to be @p flags
   ///
   /// @since 1.2
   ///
   /// @param flags The default flags to use
   ///
   void event_default_flags_set(Evas_Event_Flags flags_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_event_default_flags_set(flags_));
   }

   /// @brief Retrieves the number of the output engine used for the given evas.
   /// @return  The ID number of the output engine being used.  @c 0 is
   /// returned if there is an error.
   /// @ingroup Evas_Output_Method
   ///
   /// @param render_method The numeric engine value to use.
   ///
   int output_method_get() const
   {
      int _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_output_method_get());
      return _tmp_ret;
   }

   /// @brief Sets the output engine for the given evas.
   ///
   /// Once the output engine for an evas is set, any attempt to change it
   /// will be ignored.  The value for @p render_method can be found using
   /// @ref evas_render_method_lookup .
   ///
   /// @attention it is mandatory that one calls evas_init() before
   /// setting the output method.
   ///
   /// @ingroup Evas_Output_Method
   ///
   /// @param render_method The numeric engine value to use.
   ///
   void output_method_set(int render_method_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_output_method_set(render_method_));
   }

   /// @brief Changes the size of font cache of the given evas.
   ///
   /// @return The size, in bytes.
   ///
   /// @ingroup Evas_Font_Group
   ///
   /// @param size The size, in bytes.
   ///
   int font_cache_get() const
   {
      int _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_font_cache_get());
      return _tmp_ret;
   }

   /// @brief Changes the size of font cache of the given evas.
   ///
   /// @ingroup Evas_Font_Group
   ///
   /// @param size The size, in bytes.
   ///
   void font_cache_set(int size_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_font_cache_set(size_));
   }

   /// @brief Retrieve the output size of the render engine of the given evas.
   ///
   /// The output size is given in whatever the output units are for the
   /// engine.
   ///
   /// If either @p w or @p h is @c NULL, then it is ignored.  If @p e is
   /// invalid, the returned results are undefined.
   ///
   /// @ingroup Evas_Output_Size
   ///
   /// @param w The width in output units, usually pixels.
   /// @param h The height in output units, usually pixels.
   ///
   void output_size_get(int* w_, int* h_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_output_size_get(w_, h_));
   }

   /// @brief Sets the output size of the render engine of the given evas.
   ///
   /// The evas will render to a rectangle of the given size once this
   /// function is called.  The output size is independent of the viewport
   /// size.  The viewport will be stretched to fill the given rectangle.
   ///
   /// The units used for @p w and @p h depend on the engine used by the
   /// evas.
   ///
   /// @ingroup Evas_Output_Size
   ///
   /// @param w The width in output units, usually pixels.
   /// @param h The height in output units, usually pixels.
   ///
   void output_size_set(int w_, int h_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_output_size_set(w_, h_));
   }

   /// @brief Returns the pointer attached by evas_data_attach_set()
   ///
   /// @return The pointer attached
   /// @ingroup Evas_Canvas
   ///
   /// @param data The pointer to attach
   ///
   void * data_attach_get() const
   {
      void * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_data_attach_get());
      return _tmp_ret;
   }

   /// @brief Attaches a specific pointer to the evas for fetching later
   ///
   /// @ingroup Evas_Canvas
   ///
   /// @param data The pointer to attach
   ///
   void data_attach_set(void * data_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_data_attach_set(data_));
   }

   /// @brief Retrieves the font hinting used by the given evas.
   ///
   /// @return The hinting in use, one of #EVAS_FONT_HINTING_NONE,
   /// #EVAS_FONT_HINTING_AUTO, #EVAS_FONT_HINTING_BYTECODE.
   /// @ingroup Evas_Font_Group
   ///
   /// @param hinting The hinting to use, one of #EVAS_FONT_HINTING_NONE,
   ///
   Evas_Font_Hinting_Flags font_hinting_get() const
   {
      Evas_Font_Hinting_Flags _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_font_hinting_get());
      return _tmp_ret;
   }

   /// @brief Changes the font hinting for the given evas.
   ///
   /// #EVAS_FONT_HINTING_AUTO, #EVAS_FONT_HINTING_BYTECODE.
   /// @ingroup Evas_Font_Group
   ///
   /// @param hinting The hinting to use, one of #EVAS_FONT_HINTING_NONE,
   ///
   void font_hinting_set(Evas_Font_Hinting_Flags hinting_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_font_hinting_set(hinting_));
   }

   /// @brief Retrieves the current render engine info struct from the given evas.
   ///
   /// The returned structure is publicly modifiable.  The contents are
   /// valid until either @ref evas_engine_info_set or @ref evas_render
   /// are called.
   ///
   /// This structure does not need to be freed by the caller.
   ///
   /// @return  A pointer to the Engine Info structure.  @c NULL is returned if
   /// an engine has not yet been assigned.
   /// @ingroup Evas_Output_Method
   ///
   /// @param info The pointer to the Engine Info to use
   ///
   Evas_Engine_Info * engine_info_get() const
   {
      Evas_Engine_Info * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_engine_info_get());
      return _tmp_ret;
   }

   /// @brief Applies the engine settings for the given evas from the given @c
   /// Evas_Engine_Info structure.
   ///
   /// To get the Evas_Engine_Info structure to use, call @ref
   /// evas_engine_info_get .  Do not try to obtain a pointer to an
   /// @c Evas_Engine_Info structure in any other way.
   ///
   /// You will need to call this function at least once before you can
   /// create objects on an evas or render that evas.  Some engines allow
   /// their settings to be changed more than once.
   ///
   /// Once called, the @p info pointer should be considered invalid.
   ///
   /// @return  @c EINA_TRUE if no error occurred, @c EINA_FALSE otherwise.
   /// @ingroup Evas_Output_Method
   ///
   /// @param info The pointer to the Engine Info to use
   ///
   bool engine_info_set(Evas_Engine_Info * info_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_engine_info_set(info_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Retrieve the object that currently has focus.
   ///
   /// @return The object that has focus or @c NULL if there is not one.
   ///
   /// Evas can have (at most) one of its objects focused at a time.
   /// Focused objects will be the ones having <b>key events</b> delivered
   /// to, which the programmer can act upon by means of
   /// evas_object_event_callback_add() usage.
   ///
   /// @note Most users wouldn't be dealing directly with Evas' focused
   /// objects. Instead, they would be using a higher level library for
   /// that (like a toolkit, as Elementary) to handle focus and who's
   /// receiving input for them.
   ///
   /// This call returns the object that currently has focus on the canvas
   /// @p e or @c NULL, if none.
   ///
   /// @see evas_object_focus_set
   /// @see evas_object_focus_get
   /// @see evas_object_key_grab
   /// @see evas_object_key_ungrab
   ///
   /// Example:
   /// @dontinclude evas-events.c
   /// @skip evas_event_callback_add(d.canvas, EVAS_CALLBACK_CANVAS_OBJECT_FOCUS_IN,
   /// @until evas_object_focus_set(d.bg, EINA_TRUE);
   /// @dontinclude evas-events.c
   /// @skip called when our rectangle gets focus
   /// @until }
   ///
   /// In this example the @c event_info is exactly a pointer to that
   /// focused rectangle. See the full @ref Example_Evas_Events "example".
   ///
   /// @ingroup Evas_Object_Group_Find
   ///
   evas::object focus_get() const
   {
      Evas_Object * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_focus_get());
      return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Get the highest (stacked) Evas object on the canvas @p e.
   ///
   /// @return a pointer to the highest object on it, if any, or @c NULL,
   /// otherwise
   ///
   /// This function will take all populated layers in the canvas into
   /// account, getting the highest object for the highest layer,
   /// naturally.
   ///
   /// @see evas_object_layer_get()
   /// @see evas_object_layer_set()
   /// @see evas_object_below_get()
   /// @see evas_object_above_get()
   ///
   /// @warning This function will @b skip objects parented by smart
   /// objects, acting only on the ones at the "top level", with regard to
   /// object parenting.
   ///
   evas::object object_top_get() const
   {
      Evas_Object * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_object_top_get());
      return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Returns a handle to the list of lock keys registered in the canvas
   /// @p e. This is required to check for which locks are set at a given
   /// time with the evas_key_lock_is_set() function.
   ///
   /// @see evas_key_lock_add
   /// @see evas_key_lock_del
   /// @see evas_key_lock_on
   /// @see evas_key_lock_off
   /// @see evas_key_lock_is_set
   ///
   /// @return An .Evas_Lock handle to query Evas' keys subsystem with
   /// evas_key_lock_is_set(), or @c NULL on error.
   ///
   const Evas_Lock * key_lock_get() const
   {
      const Evas_Lock * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_key_lock_get());
      return _tmp_ret;
   }

   /// @brief This function returns the current known pointer co-ordinates
   ///
   /// This function returns the current known canvas unit co-ordinates of
   /// the mouse pointer and sets the contents of the Evas_Coords pointed
   /// to by @p x and @p y to contain these co-ordinates. If @p e is not a
   /// valid canvas the results of this function are undefined.
   ///
   /// Example:
   /// @code
   /// extern Evas *evas;
   /// Evas_Coord mouse_x, mouse_y;
   ///
   /// evas_pointer_output_xy_get(evas, &mouse_x, &mouse_y);
   /// printf("Mouse is at canvas position %d, %d\n", mouse_x, mouse_y);
   /// @endcode
   ///
   /// @param x The pointer to a Evas_Coord to be filled in
   /// @param y The pointer to a Evas_Coord to be filled in
   /// @ingroup Evas_Pointer_Group
   ///
   void pointer_canvas_xy_get(Evas_Coord* x_, Evas_Coord* y_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_pointer_canvas_xy_get(x_, y_));
   }

   /// @brief Get the number of mouse or multi presses currently active
   ///
   /// @p e The given canvas pointer.
   /// @return The number of presses (0 if none active).
   ///
   /// @since 1.2
   ///
   int event_down_count_get() const
   {
      int _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_event_down_count_get());
      return _tmp_ret;
   }

   /// @brief This gets the internal counter that counts the number of smart calculations
   ///
   /// Whenever evas performs smart object calculations on the whole canvas
   /// it increments a counter by 1. This is the smart object calculate counter
   /// that this function returns the value of. It starts at the value of 0 and
   /// will increase (and eventually wrap around to negative values and so on) by
   /// 1 every time objects are calculated. You can use this counter to ensure
   /// you don't re-do calculations withint the same calculation generation/run
   /// if the calculations maybe cause self-feeding effects.
   ///
   /// @ingroup Evas_Smart_Object_Group
   /// @since 1.1
   ///
   int smart_objects_calculate_count_get() const
   {
      int _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_smart_objects_calculate_count_get());
      return _tmp_ret;
   }

   /// @brief Get the focus state known by the given evas
   ///
   /// @return @c EINA_TRUE if it got the focus, @c EINA_FALSE otherwise.
   /// @ingroup Evas_Canvas
   ///
   bool focus_state_get() const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_focus_state_get());
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Get the changed marker for the canvas
   ///
   /// @return @c EINA_TRUE if something has been marked as changed, @c EINA_FALSE otherwise.
   /// @ingroup Evas_Canvas
   /// @since 1.11
   ///
   bool changed_get() const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_changed_get());
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief This function returns the current known pointer co-ordinates
   ///
   /// This function returns the current known screen/output co-ordinates
   /// of the mouse pointer and sets the contents of the integers pointed
   /// to by @p x and @p y to contain these co-ordinates. If @p e is not a
   /// valid canvas the results of this function are undefined.
   ///
   /// Example:
   /// @code
   /// extern Evas *evas;
   /// int mouse_x, mouse_y;
   ///
   /// evas_pointer_output_xy_get(evas, &mouse_x, &mouse_y);
   /// printf("Mouse is at screen position %i, %i\n", mouse_x, mouse_y);
   /// @endcode
   ///
   /// @param x The pointer to an integer to be filled in
   /// @param y The pointer to an integer to be filled in
   /// @ingroup Evas_Pointer_Group
   ///
   void pointer_output_xy_get(int* x_, int* y_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_pointer_output_xy_get(x_, y_));
   }

   /// @brief Returns whether the mouse pointer is logically inside the canvas
   ///
   /// @return An integer that is 1 if the mouse is inside the canvas, 0 otherwise
   /// @ingroup Evas_Pointer_Group
   ///
   /// When this function is called it will return a value of either 0 or
   /// 1, depending on if evas_event_feed_mouse_in(),
   /// evas_event_feed_mouse_in_data(), or evas_event_feed_mouse_out(),
   /// evas_event_feed_mouse_out_data() have been called to feed in a
   /// mouse enter event into the canvas.
   ///
   /// A return value of 1 indicates the mouse is logically inside the
   /// canvas, and 0 implies it is logically outside the canvas.
   ///
   /// A canvas begins with the mouse being assumed outside (0).
   ///
   /// If @p e is not a valid canvas, the return value is undefined.
   ///
   /// Example:
   /// @code
   /// extern Evas *evas;
   ///
   /// if (evas_pointer_inside_get(evas)) printf("Mouse is in!\n");
   /// else printf("Mouse is out!\n");
   /// @endcode
   ///
   bool pointer_inside_get() const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_pointer_inside_get());
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Get the maximum image size evas can possibly handle
   ///
   /// This function returns the larges image or surface size that evas can handle
   /// in pixels, and if there is one, returns @c EINA_TRUE. It returns
   /// @c EINA_FALSE if no extra constraint on maximum image size exists. You still
   /// should check the return values of @p maxw and @p maxh as there may still be
   /// a limit, just a much higher one.
   ///
   /// @since 1.1
   ///
   /// @param maxw Pointer to hold the return value in pixels of the maximum width
   /// @param maxh Pointer to hold the return value in pixels of the maximum height
   ///
   bool image_max_size_get(int* maxw_, int* maxh_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_image_max_size_get(maxw_, maxh_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Get the lowest (stacked) Evas object on the canvas @p e.
   ///
   /// @return a pointer to the lowest object on it, if any, or @c NULL,
   /// otherwise
   ///
   /// This function will take all populated layers in the canvas into
   /// account, getting the lowest object for the lowest layer, naturally.
   ///
   /// @see evas_object_layer_get()
   /// @see evas_object_layer_set()
   /// @see evas_object_below_get()
   /// @see evas_object_above_get()
   ///
   /// @warning This function will @b skip objects parented by smart
   /// objects, acting only on the ones at the "top level", with regard to
   /// object parenting.
   ///
   evas::object object_bottom_get() const
   {
      Evas_Object * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_object_bottom_get());
      return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Returns a handle to the list of modifier keys registered in the
   /// canvas @p e. This is required to check for which modifiers are set
   /// at a given time with the evas_key_modifier_is_set() function.
   ///
   /// @see evas_key_modifier_add
   /// @see evas_key_modifier_del
   /// @see evas_key_modifier_on
   /// @see evas_key_modifier_off
   /// @see evas_key_modifier_is_set
   ///
   /// @return An .Evas_Modifier handle to query Evas' keys subsystem
   /// with evas_key_modifier_is_set(), or @c NULL on error.
   ///
   const Evas_Modifier * key_modifier_get() const
   {
      const Evas_Modifier * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_key_modifier_get());
      return _tmp_ret;
   }

   /// @brief Returns a bitmask with the mouse buttons currently pressed, set to 1
   ///
   /// @return A bitmask of the currently depressed buttons on the canvas
   /// @ingroup Evas_Pointer_Group
   ///
   /// Calling this function will return a 32-bit integer with the
   /// appropriate bits set to 1 that correspond to a mouse button being
   /// depressed. This limits Evas to a mouse devices with a maximum of 32
   /// buttons, but that is generally in excess of any host system's
   /// pointing device abilities.
   ///
   /// A canvas by default begins with no mouse buttons being pressed and
   /// only calls to evas_event_feed_mouse_down(),
   /// evas_event_feed_mouse_down_data(), evas_event_feed_mouse_up() and
   /// evas_event_feed_mouse_up_data() will alter that.
   ///
   /// The least significant bit corresponds to the first mouse button
   /// (button 1) and the most significant bit corresponds to the last
   /// mouse button (button 32).
   ///
   /// If @p e is not a valid canvas, the return value is undefined.
   ///
   /// Example:
   /// @code
   /// extern Evas *evas;
   /// int button_mask, i;
   ///
   /// button_mask = evas_pointer_button_down_mask_get(evas);
   /// printf("Buttons currently pressed:\n");
   /// for (i = 0; i < 32; i++)
   /// {
   /// if ((button_mask & (1 << i)) != 0) printf("Button %i\n", i + 1);
   /// }
   /// @endcode
   ///
   int pointer_button_down_mask_get() const
   {
      int _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_pointer_button_down_mask_get());
      return _tmp_ret;
   }

   /// @brief Retrieve a list of Evas objects lying over a given position in
   /// a canvas.
   ///
   /// This function will traverse all the layers of the given canvas,
   /// from top to bottom, querying for objects with areas covering the
   /// given position. It will enter the smart objects.
   /// It will not append to the list pass events as hidden objects.
   /// Call eina_list_free on the returned list after usage.
   ///
   /// @param stop An Evas Object where to stop searching.
   /// @param x The horizontal coordinate of the position.
   /// @param y The vertical coordinate of the position.
   ///
   efl::eina::range_list< evas::object > tree_objects_at_xy_get(evas::object stop_, int x_, int y_) const
   {
      Eina_List * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_tree_objects_at_xy_get(efl::eolian::to_c(stop_), x_, y_));
      return efl::eolian::to_cxx<efl::eina::range_list< evas::object >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
   }

   /// @brief Mouse wheel event feed.
   ///
   /// This function will set some evas properties that is necessary when
   /// the mouse wheel is scrolled up or down. It prepares information to
   /// be treated by the callback function.
   ///
   /// @param direction The wheel mouse direction.
   /// @param z How much mouse wheel was scrolled up or down.
   /// @param timestamp The timestamp of the mouse up event.
   /// @param data The data for canvas.
   ///
   void event_feed_mouse_wheel(int direction_, int z_, unsigned int timestamp_, const void * data_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_event_feed_mouse_wheel(direction_, z_, timestamp_, data_));
   }

   /// @brief Enables or turns on programmatically the lock key with name @p
   /// keyname.
   ///
   /// The effect will be as if the key was put on its active state after
   /// this call.
   ///
   /// @see evas_key_lock_get
   /// @see evas_key_lock_add
   /// @see evas_key_lock_del
   /// @see evas_key_lock_off
   ///
   /// @param keyname The name of the lock to enable.
   ///
   void key_lock_on(std::string keyname_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_key_lock_on(efl::eolian::to_c(keyname_)));
   }

   /// @brief Key down event feed
   ///
   /// This function will set some evas properties that is necessary when
   /// a key is pressed. It prepares information to be treated by the
   /// callback function.
   ///
   /// @param keyname Name of the key
   /// @param key The key pressed.
   /// @param string A String
   /// @param compose The compose string
   /// @param timestamp Timestamp of the mouse up event
   /// @param data Data for canvas.
   ///
   void event_feed_key_down(std::string keyname_, std::string key_, std::string string_, std::string compose_, unsigned int timestamp_, const void * data_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_event_feed_key_down(efl::eolian::to_c(keyname_), efl::eolian::to_c(key_), efl::eolian::to_c(string_), efl::eolian::to_c(compose_), timestamp_, data_));
   }

   /// @brief Creates a bit mask from the @p keyname @b modifier key. Values
   /// returned from different calls to it may be ORed together,
   /// naturally.
   ///
   /// @returns the bit mask or 0 if the @p keyname key wasn't registered as a
   /// modifier for canvas @p e.
   ///
   /// This function is meant to be using in conjunction with
   /// evas_object_key_grab()/evas_object_key_ungrab(). Go check their
   /// documentation for more information.
   ///
   /// @see evas_key_modifier_add
   /// @see evas_key_modifier_get
   /// @see evas_key_modifier_on
   /// @see evas_key_modifier_off
   /// @see evas_key_modifier_is_set
   /// @see evas_object_key_grab
   /// @see evas_object_key_ungrab
   ///
   /// @param keyname The name of the modifier key to create the mask for.
   ///
   Evas_Modifier_Mask key_modifier_mask_get(std::string keyname_) const
   {
      Evas_Modifier_Mask _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_key_modifier_mask_get(efl::eolian::to_c(keyname_)));
      return _tmp_ret;
   }

   /// @brief Adds the @p keyname key to the current list of modifier keys.
   ///
   /// Modifiers are keys like shift, alt and ctrl, i.e., keys which are
   /// meant to be pressed together with others, altering the behavior of
   /// the secondly pressed keys somehow. Evas is so that these keys can
   /// be user defined.
   ///
   /// This call allows custom modifiers to be added to the Evas system at
   /// run time. It is then possible to set and unset modifier keys
   /// programmatically for other parts of the program to check and act
   /// on. Programmers using Evas would check for modifier keys on key
   /// event callbacks using evas_key_modifier_is_set().
   ///
   /// @see evas_key_modifier_del
   /// @see evas_key_modifier_get
   /// @see evas_key_modifier_on
   /// @see evas_key_modifier_off
   /// @see evas_key_modifier_is_set
   ///
   /// @note If the programmer instantiates the canvas by means of the
   /// ecore_evas_new() family of helper functions, Ecore will take
   /// care of registering on it all standard modifiers: "Shift",
   /// "Control", "Alt", "Meta", "Hyper", "Super".
   ///
   /// @param keyname The name of the modifier key to add to the list of
   /// Evas modifiers.
   ///
   void key_modifier_add(std::string keyname_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_key_modifier_add(efl::eolian::to_c(keyname_)));
   }

   /// @brief Disables or turns off programmatically the modifier key with name
   /// @p keyname.
   ///
   /// @see evas_key_modifier_add
   /// @see evas_key_modifier_get
   /// @see evas_key_modifier_on
   /// @see evas_key_modifier_is_set
   ///
   /// @param keyname The name of the modifier to disable.
   ///
   void key_modifier_off(std::string keyname_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_key_modifier_off(efl::eolian::to_c(keyname_)));
   }

   /// @brief Hold event feed
   ///
   /// This function makes the object to stop sending events.
   ///
   /// @param hold The hold.
   /// @param timestamp The timestamp of the mouse up event.
   /// @param data The data for canvas.
   ///
   void event_feed_hold(int hold_, unsigned int timestamp_, const void * data_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_event_feed_hold(hold_, timestamp_, data_));
   }

   /// @brief Mouse move event feed.
   ///
   /// This function will set some evas properties that is necessary when
   /// the mouse is moved from its last position. It prepares information
   /// to be treated by the callback function.
   ///
   /// @param x The horizontal position of the mouse pointer.
   /// @param y The vertical position of the mouse pointer.
   /// @param timestamp The timestamp of the mouse up event.
   /// @param data The data for canvas.
   ///
   void event_feed_mouse_move(int x_, int y_, unsigned int timestamp_, const void * data_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_event_feed_mouse_move(x_, y_, timestamp_, data_));
   }

   /// @brief Key up event feed
   ///
   /// This function will set some evas properties that is necessary when
   /// a key is released. It prepares information to be treated by the
   /// callback function.
   ///
   /// @param keyname Name of the key
   /// @param key The key released.
   /// @param string string
   /// @param compose compose
   /// @param timestamp Timestamp of the mouse up event
   /// @param data Data for canvas.
   ///
   void event_feed_key_up(std::string keyname_, std::string key_, std::string string_, std::string compose_, unsigned int timestamp_, const void * data_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_event_feed_key_up(efl::eolian::to_c(keyname_), efl::eolian::to_c(key_), efl::eolian::to_c(string_), efl::eolian::to_c(compose_), timestamp_, data_));
   }

   /// @brief Mouse out event feed.
   ///
   /// This function will set some evas properties that is necessary when
   /// the mouse out event happens. It prepares information to be treated
   /// by the callback function.
   ///
   /// @param timestamp Timestamp of the mouse up event.
   /// @param data The data for canvas.
   ///
   void event_feed_mouse_out(unsigned int timestamp_, const void * data_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_event_feed_mouse_out(timestamp_, data_));
   }

   /// @brief No description supplied by the EAPI.
   ///
   /// @param d 
   /// @param x 
   /// @param y 
   /// @param rad 
   /// @param radx 
   /// @param rady 
   /// @param pres 
   /// @param ang 
   /// @param fx 
   /// @param fy 
   /// @param timestamp 
   /// @param data 
   ///
   void event_input_multi_move(int d_, int x_, int y_, double rad_, double radx_, double rady_, double pres_, double ang_, double fx_, double fy_, unsigned int timestamp_, const void * data_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_event_input_multi_move(d_, x_, y_, rad_, radx_, rady_, pres_, ang_, fx_, fy_, timestamp_, data_));
   }

   /// @brief Retrieve a list of Evas objects lying over a given position in
   /// a canvas
   ///
   /// @return  The list of Evas objects that are over the given position
   /// in @p e
   ///
   /// This function will traverse all the layers of the given canvas,
   /// from top to bottom, querying for objects with areas covering the
   /// given position. The user can remove from query
   /// objects which are hidden and/or which are set to pass events.
   ///
   /// @warning This function will @b skip objects parented by smart
   /// objects, acting only on the ones at the "top level", with regard to
   /// object parenting.
   ///
   /// @param x The horizontal coordinate of the position
   /// @param y The vertical coordinate of the position
   /// @param include_pass_events_objects Boolean flag to include or not
   /// objects which pass events in this calculation
   /// @param include_hidden_objects Boolean flag to include or not hidden
   /// objects in this calculation
   ///
   efl::eina::range_list< evas::object > objects_at_xy_get(Evas_Coord x_, Evas_Coord y_, bool include_pass_events_objects_, bool include_hidden_objects_) const
   {
      Eina_List * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_objects_at_xy_get(x_, y_, efl::eolian::to_c(include_pass_events_objects_), efl::eolian::to_c(include_hidden_objects_)));
      return efl::eolian::to_cxx<efl::eina::range_list< evas::object >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
   }

   /// @brief No description supplied by the EAPI.
   ///
   /// @param d 
   /// @param x 
   /// @param y 
   /// @param rad 
   /// @param radx 
   /// @param rady 
   /// @param pres 
   /// @param ang 
   /// @param fx 
   /// @param fy 
   /// @param flags 
   /// @param timestamp 
   /// @param data 
   ///
   void event_input_multi_up(int d_, int x_, int y_, double rad_, double radx_, double rady_, double pres_, double ang_, double fx_, double fy_, Evas_Button_Flags flags_, unsigned int timestamp_, const void * data_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_event_input_multi_up(d_, x_, y_, rad_, radx_, rady_, pres_, ang_, fx_, fy_, flags_, timestamp_, data_));
   }

   /// @brief No description supplied by the EAPI.
   ///
   /// @param d 
   /// @param x 
   /// @param y 
   /// @param rad 
   /// @param radx 
   /// @param rady 
   /// @param pres 
   /// @param ang 
   /// @param fx 
   /// @param fy 
   /// @param flags 
   /// @param timestamp 
   /// @param data 
   ///
   void event_feed_multi_down(int d_, int x_, int y_, double rad_, double radx_, double rady_, double pres_, double ang_, double fx_, double fy_, Evas_Button_Flags flags_, unsigned int timestamp_, const void * data_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_event_feed_multi_down(d_, x_, y_, rad_, radx_, rady_, pres_, ang_, fx_, fy_, flags_, timestamp_, data_));
   }

   /// @brief Render the given Evas canvas asynchronously.
   ///
   /// @return EINA_TRUE if the canvas will render, EINA_FALSE otherwise.
   ///
   /// This function only returns EINA_TRUE when a frame will be rendered. If the
   /// previous frame is still rendering, EINA_FALSE will be returned so the users
   /// know not to wait for the updates callback and just return to their main
   /// loop.
   ///
   /// If a @p func callback is given, a list of updated areas will be generated
   /// and the function will be called from the main thread after the rendered
   /// frame is flushed to the screen. The resulting list should be freed with
   /// @f evas_render_updates_free().
   /// The list is given in the @p event_info parameter of the callback function.
   ///
   /// @ingroup Evas_Canvas
   /// @since 1.8
   ///
   bool render_async() const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_render_async());
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Inform to the evas that it lost the focus.
   ///
   /// @ingroup Evas_Canvas
   ///
   void focus_out() const
   {
      eo_do(_eo_ptr(), ::evas_canvas_focus_out());
   }

   /// @brief Mouse move event feed from input.
   ///
   /// Similar to the evas_event_feed_mouse_move(), this function will inform Evas
   /// about mouse move events which were received by the input system, relative to
   /// the 0,0 of the window, not to the canvas 0,0. It will take care of doing any
   /// special transformation like adding the framespace offset to the mouse event.
   ///
   /// @since 1.8
   /// @see evas_event_feed_mouse_move
   ///
   /// @param x The horizontal position of the mouse pointer relative to the 0,0 of
   /// the window/surface.
   /// @param y The vertical position of the mouse pointer relative to the 0,0 of
   /// the window/surface.
   /// @param timestamp The timestamp of the mouse move event.
   /// @param data The data for canvas.
   ///
   void event_input_mouse_move(int x_, int y_, unsigned int timestamp_, const void * data_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_event_input_mouse_move(x_, y_, timestamp_, data_));
   }

   /// @brief Update the canvas internal objects but not triggering immediate
   /// renderization.
   ///
   /// This function updates the canvas internal objects not triggering
   /// renderization. To force renderization function evas_render() should
   /// be used.
   ///
   /// @see evas_render.
   ///
   /// @ingroup Evas_Canvas
   ///
   void norender() const
   {
      eo_do(_eo_ptr(), ::evas_canvas_norender());
   }

   /// @brief Get the number of touched point in the evas.
   ///
   /// @return The number of touched point on the evas.
   ///
   /// New touched point is added to the list whenever touching the evas
   /// and point is removed whenever removing touched point from the evas.
   ///
   /// Example:
   /// @code
   /// extern Evas *evas;
   /// int count;
   ///
   /// count = evas_touch_point_list_count(evas);
   /// printf("The count of touch points: %i\n", count);
   /// @endcode
   ///
   /// @see evas_touch_point_list_nth_xy_get()
   /// @see evas_touch_point_list_nth_id_get()
   /// @see evas_touch_point_list_nth_state_get()
   ///
   unsigned int touch_point_list_count() const
   {
      unsigned int _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_touch_point_list_count());
      return _tmp_ret;
   }

   /// @brief No description supplied by the EAPI.
   ///
   /// @param d 
   /// @param x 
   /// @param y 
   /// @param rad 
   /// @param radx 
   /// @param rady 
   /// @param pres 
   /// @param ang 
   /// @param fx 
   /// @param fy 
   /// @param flags 
   /// @param timestamp 
   /// @param data 
   ///
   void event_input_multi_down(int d_, int x_, int y_, double rad_, double radx_, double rady_, double pres_, double ang_, double fx_, double fy_, Evas_Button_Flags flags_, unsigned int timestamp_, const void * data_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_event_input_multi_down(d_, x_, y_, rad_, radx_, rady_, pres_, ang_, fx_, fy_, flags_, timestamp_, data_));
   }

   /// @brief Pop the nochange flag down 1
   ///
   /// This tells evas, that while the nochange flag is greater than 0, do not
   /// mark objects as "changed" when making changes.
   ///
   /// @ingroup Evas_Canvas
   ///
   void nochange_pop() const
   {
      eo_do(_eo_ptr(), ::evas_canvas_nochange_pop());
   }

   /// @brief Disables or turns off programmatically the lock key with name @p
   /// keyname.
   ///
   /// The effect will be as if the key was put on its inactive state
   /// after this call.
   ///
   /// @see evas_key_lock_get
   /// @see evas_key_lock_add
   /// @see evas_key_lock_del
   /// @see evas_key_lock_on
   ///
   /// @param keyname The name of the lock to disable.
   ///
   void key_lock_off(std::string keyname_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_key_lock_off(efl::eolian::to_c(keyname_)));
   }

   /// @brief Push the nochange flag up 1
   ///
   /// This tells evas, that while the nochange flag is greater than 0, do not
   /// mark objects as "changed" when making changes.
   ///
   /// @ingroup Evas_Canvas
   ///
   void nochange_push() const
   {
      eo_do(_eo_ptr(), ::evas_canvas_nochange_push());
   }

   /// @brief Force the given evas and associated engine to flush its font cache.
   ///
   /// @ingroup Evas_Font_Group
   ///
   void font_cache_flush() const
   {
      eo_do(_eo_ptr(), ::evas_canvas_font_cache_flush());
   }

   /// @brief Checks if the font hinting is supported by the given evas.
   ///
   /// #EVAS_FONT_HINTING_AUTO, #EVAS_FONT_HINTING_BYTECODE.
   /// @return @c EINA_TRUE if it is supported, @c EINA_FALSE otherwise.
   /// @ingroup Evas_Font_Group
   ///
   /// @param hinting The hinting to use, one of #EVAS_FONT_HINTING_NONE,
   ///
   bool font_hinting_can_hint(Evas_Font_Hinting_Flags hinting_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_font_hinting_can_hint(hinting_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Retrieve the Evas object stacked at the top of a given position in
   /// a canvas
   ///
   /// @return  The Evas object that is over all other objects at the given
   /// position.
   ///
   /// This function will traverse all the layers of the given canvas,
   /// from top to bottom, querying for objects with areas covering the
   /// given position. The user can remove from the query
   /// objects which are hidden and/or which are set to pass events.
   ///
   /// @warning This function will @b skip objects parented by smart
   /// objects, acting only on the ones at the "top level", with regard to
   /// object parenting.
   ///
   /// @param x The horizontal coordinate of the position
   /// @param y The vertical coordinate of the position
   /// @param include_pass_events_objects Boolean flag to include or not
   /// objects which pass events in this calculation
   /// @param include_hidden_objects Boolean flag to include or not hidden
   /// objects in this calculation
   ///
   evas::object object_top_at_xy_get(Evas_Coord x_, Evas_Coord y_, bool include_pass_events_objects_, bool include_hidden_objects_) const
   {
      Evas_Object * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_object_top_at_xy_get(x_, y_, efl::eolian::to_c(include_pass_events_objects_), efl::eolian::to_c(include_hidden_objects_)));
      return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Enables or turns on programmatically the modifier key with name @p
   /// keyname.
   ///
   /// The effect will be as if the key was pressed for the whole time
   /// between this call and a matching evas_key_modifier_off().
   ///
   /// @see evas_key_modifier_add
   /// @see evas_key_modifier_get
   /// @see evas_key_modifier_off
   /// @see evas_key_modifier_is_set
   ///
   /// @param keyname The name of the modifier to enable.
   ///
   void key_modifier_on(std::string keyname_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_key_modifier_on(efl::eolian::to_c(keyname_)));
   }

   /// @brief Mouse up event feed.
   ///
   /// This function will set some evas properties that is necessary when
   /// the mouse button is released. It prepares information to be treated
   /// by the callback function.
   ///
   /// @param b The button number.
   /// @param flags evas button flags.
   /// @param timestamp The timestamp of the mouse up event.
   /// @param data The data for canvas.
   ///
   void event_feed_mouse_up(int b_, Evas_Button_Flags flags_, unsigned int timestamp_, const void * data_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_event_feed_mouse_up(b_, flags_, timestamp_, data_));
   }

   /// @brief Mouse down event feed.
   ///
   /// This function will set some evas properties that is necessary when
   /// the mouse button is pressed. It prepares information to be treated
   /// by the callback function.
   ///
   /// @param b The button number.
   /// @param flags The evas button flags.
   /// @param timestamp The timestamp of the mouse down event.
   /// @param data The data for canvas.
   ///
   void event_feed_mouse_down(int b_, Evas_Button_Flags flags_, unsigned int timestamp_, const void * data_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_event_feed_mouse_down(b_, flags_, timestamp_, data_));
   }

   /// @brief Re feed event.
   ///
   /// This function re-feeds the event pointed by event_copy
   ///
   /// This function call evas_event_feed_* functions, so it can
   /// cause havoc if not used wisely. Please use it responsibly.
   ///
   /// @param event_copy the event to refeed
   /// @param event_type Event type
   ///
   void event_refeed_event(void * event_copy_, Evas_Callback_Type event_type_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_event_refeed_event(event_copy_, event_type_));
   }

   /// @brief List of available font descriptions known or found by this evas.
   ///
   /// The list depends on Evas compile time configuration, such as
   /// fontconfig support, and the paths provided at runtime as explained
   /// in @ref Evas_Font_Path_Group.
   ///
   /// @return a newly allocated list of strings. Do not change the
   /// strings.  Be sure to call evas_font_available_list_free()
   /// after you're done.
   ///
   /// @ingroup Evas_Font_Group
   ///
   efl::eina::range_list< std::string > font_available_list() const
   {
      Eina_List * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_font_available_list());
      return efl::eolian::to_cxx<efl::eina::range_list< std::string >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
   }

   /// @param x 
   /// @param y 
   /// @param w 
   /// @param h 
   /// @param include_pass_events_objects 
   /// @param include_hidden_objects 
   ///
   efl::eina::range_list< evas::object > objects_in_rectangle_get(Evas_Coord x_, Evas_Coord y_, Evas_Coord w_, Evas_Coord h_, bool include_pass_events_objects_, bool include_hidden_objects_) const
   {
      Eina_List * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_objects_in_rectangle_get(x_, y_, w_, h_, efl::eolian::to_c(include_pass_events_objects_), efl::eolian::to_c(include_hidden_objects_)));
      return efl::eolian::to_cxx<efl::eina::range_list< evas::object >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
   }

   /// @brief Retrieves the object on the given evas 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(). If
   /// the name is not unique canvas-wide, then which one of the many objects
   /// with that name is returned is undefined, so only use this if you can ensure
   /// the object name is unique.
   ///
   /// @ingroup Evas_Object_Group_Find
   ///
   /// @param name The given name.
   ///
   evas::object object_name_find(std::string name_) const
   {
      Evas_Object * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_object_name_find(efl::eolian::to_c(name_)));
      return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Appends a font path to the list of font paths used by the given evas.
   /// @ingroup Evas_Font_Path_Group
   ///
   /// @param path The new font path.
   ///
   void font_path_append(std::string path_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_font_path_append(efl::eolian::to_c(path_)));
   }

   /// @brief This function returns the @p id of nth touch point.
   ///
   /// @return id of nth touch point, if the call succeeded, -1 otherwise.
   ///
   /// The point which comes from Mouse Event has @p id 0 and The point
   /// which comes from Multi Event has @p id that is same as Multi
   /// Event's device id.
   ///
   /// Example:
   /// @code
   /// extern Evas *evas;
   /// int id;
   ///
   /// if (evas_touch_point_list_count(evas))
   /// {
   /// id = evas_touch_point_nth_id_get(evas, 0);
   /// printf("The first touch point's id: %i\n", id);
   /// }
   /// @endcode
   ///
   /// @see evas_touch_point_list_count()
   /// @see evas_touch_point_list_nth_xy_get()
   /// @see evas_touch_point_list_nth_state_get()
   ///
   /// @param n The number of the touched point (0 being the first).
   ///
   int touch_point_list_nth_id_get(unsigned int n_) const
   {
      int _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_touch_point_list_nth_id_get(n_));
      return _tmp_ret;
   }

   /// @brief Removes all font paths loaded into memory for the given evas.
   /// @ingroup Evas_Font_Path_Group
   ///
   void font_path_clear() const
   {
      eo_do(_eo_ptr(), ::evas_canvas_font_path_clear());
   }

   /// @brief Call user-provided @c calculate() smart functions and unset the
   /// flag signalling that the object needs to get recalculated to @b all
   /// smart objects in the canvas.
   ///
   /// @see evas_object_smart_need_recalculate_set()
   ///
   /// @ingroup Evas_Smart_Object_Group
   ///
   void smart_objects_calculate() const
   {
      eo_do(_eo_ptr(), ::evas_canvas_smart_objects_calculate());
   }

   /// @brief This function returns the nth touch point's co-ordinates.
   ///
   /// Touch point's co-ordinates is updated whenever moving that point
   /// on the canvas.
   ///
   /// Example:
   /// @code
   /// extern Evas *evas;
   /// Evas_Coord x, y;
   ///
   /// if (evas_touch_point_list_count(evas))
   /// {
   /// evas_touch_point_nth_xy_get(evas, 0, &x, &y);
   /// printf("The first touch point's co-ordinate: (%i, %i)\n", x, y);
   /// }
   /// @endcode
   ///
   /// @see evas_touch_point_list_count()
   /// @see evas_touch_point_list_nth_id_get()
   /// @see evas_touch_point_list_nth_state_get()
   ///
   /// @param n The number of the touched point (0 being the first).
   /// @param[out] x The pointer to a Evas_Coord to be filled in.
   /// @param[out] y The pointer to a Evas_Coord to be filled in.
   ///
   void touch_point_list_nth_xy_get(unsigned int n_, Evas_Coord* x_, Evas_Coord* y_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_touch_point_list_nth_xy_get(n_, x_, y_));
   }

   /// @brief Removes the @p keyname key from the current list of lock keys on
   /// canvas @p e.
   ///
   /// @see evas_key_lock_get
   /// @see evas_key_lock_add
   /// @see evas_key_lock_on
   /// @see evas_key_lock_off
   ///
   /// @param keyname The name of the key to remove from the locks list.
   ///
   void key_lock_del(std::string keyname_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_key_lock_del(efl::eolian::to_c(keyname_)));
   }

   /// @brief Add a damage rectangle.
   ///
   /// This is the function by which one tells evas that a part of the
   /// canvas has to be repainted.
   ///
   /// @note All newly created Evas rectangles get the default color values of 255 255 255 255 (opaque white).
   ///
   /// @ingroup Evas_Canvas
   ///
   /// @param x The rectangle's left position.
   /// @param y The rectangle's top position.
   /// @param w The rectangle's width.
   /// @param h The rectangle's height.
   ///
   void damage_rectangle_add(int x_, int y_, int w_, int h_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_damage_rectangle_add(x_, y_, w_, h_));
   }

   /// @brief No description supplied by the EAPI.
   ///
   void sync() const
   {
      eo_do(_eo_ptr(), ::evas_canvas_sync());
   }

   /// @brief Retrieves the list of font paths used by the given evas.
   /// @return  The list of font paths used.
   /// @ingroup Evas_Font_Path_Group
   ///
   efl::eina::crange_list< std::string > font_path_list() const
   {
      const Eina_List * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_font_path_list());
      return efl::eolian::to_cxx<efl::eina::crange_list< std::string >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
   }

   /// @brief Reload the image cache
   ///
   /// This function reloads the image cache of canvas.
   ///
   void image_cache_reload() const
   {
      eo_do(_eo_ptr(), ::evas_canvas_image_cache_reload());
   }

   /// @brief Convert/scale a canvas co-ordinate into output screen co-ordinates
   ///
   /// @return The output/screen co-ordinate translated to output co-ordinates
   /// @ingroup Evas_Coord_Mapping_Group
   ///
   /// This function takes in a horizontal co-ordinate as the @p x
   /// parameter and converts it into output units, accounting for output
   /// size, viewport size and location, returning it as the function
   /// return value. If @p e is invalid, the results are undefined.
   ///
   /// Example:
   /// @code
   /// extern Evas *evas;
   /// int screen_x;
   /// extern Evas_Coord canvas_x;
   ///
   /// screen_x = evas_coord_world_x_to_screen(evas, canvas_x);
   /// @endcode
   ///
   /// @param x The canvas x co-ordinate
   ///
   int coord_world_x_to_screen(Evas_Coord x_) const
   {
      int _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_coord_world_x_to_screen(x_));
      return _tmp_ret;
   }

   /// @brief No description supplied by the EAPI.
   ///
   /// @param d 
   /// @param x 
   /// @param y 
   /// @param rad 
   /// @param radx 
   /// @param rady 
   /// @param pres 
   /// @param ang 
   /// @param fx 
   /// @param fy 
   /// @param timestamp 
   /// @param data 
   ///
   void event_feed_multi_move(int d_, int x_, int y_, double rad_, double radx_, double rady_, double pres_, double ang_, double fx_, double fy_, unsigned int timestamp_, const void * data_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_event_feed_multi_move(d_, x_, y_, rad_, radx_, rady_, pres_, ang_, fx_, fy_, timestamp_, data_));
   }

   /// @brief Force immediate renderization of the given Evas canvas.
   ///
   /// @return A newly allocated list of updated rectangles of the canvas
   /// (@c Eina.Rectangle structs). Free this list with
   /// evas_render_updates_free().
   ///
   /// This function forces an immediate renderization update of the given
   /// canvas @p e.
   ///
   /// @note This is a <b>very low level function</b>, which most of
   /// Evas' users wouldn't care about. One would use it, for example, to
   /// grab an Evas' canvas update regions and paint them back, using the
   /// canvas' pixmap, on a displaying system working below Evas.
   ///
   /// @note Evas is a stateful canvas. If no operations changing its
   /// state took place since the last rendering action, you won't see no
   /// changes and this call will be a no-op.
   ///
   /// Example code follows.
   /// @dontinclude evas-events.c
   /// @skip add an obscured
   /// @until d.obscured = !d.obscured;
   ///
   /// See the full @ref Example_Evas_Events "example".
   ///
   /// @ingroup Evas_Canvas
   ///
   efl::eina::list< Eina_Rectangle * > render_updates() const
   {
      Eina_List * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_render_updates());
      return efl::eolian::to_cxx<efl::eina::list< Eina_Rectangle * >>(_tmp_ret, std::tuple<std::true_type, std::false_type>());
   }

   /// @brief Flush the image cache of the canvas.
   ///
   /// This function flushes image cache of canvas.
   ///
   void image_cache_flush() const
   {
      eo_do(_eo_ptr(), ::evas_canvas_image_cache_flush());
   }

   /// @brief Convert/scale an output screen co-ordinate into canvas co-ordinates
   ///
   /// @return The screen co-ordinate translated to canvas unit co-ordinates
   /// @ingroup Evas_Coord_Mapping_Group
   ///
   /// This function takes in a vertical co-ordinate as the @p y parameter
   /// and converts it into canvas units, accounting for output size,
   /// viewport size and location, returning it as the function return
   /// value. If @p e is invalid, the results are undefined.
   ///
   /// Example:
   /// @code
   /// extern Evas *evas;
   /// extern int screen_y;
   /// Evas_Coord canvas_y;
   ///
   /// canvas_y = evas_coord_screen_y_to_world(evas, screen_y);
   /// @endcode
   ///
   /// @param y The screen/output y co-ordinate
   ///
   Evas_Coord coord_screen_y_to_world(int y_) const
   {
      Evas_Coord _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_coord_screen_y_to_world(y_));
      return _tmp_ret;
   }

   /// @brief Removes the @p keyname key from the current list of modifier keys
   /// on canvas @p e.
   ///
   /// @see evas_key_modifier_add
   /// @see evas_key_modifier_get
   /// @see evas_key_modifier_on
   /// @see evas_key_modifier_off
   /// @see evas_key_modifier_is_set
   ///
   /// @param keyname The name of the key to remove from the modifiers list.
   ///
   void key_modifier_del(std::string keyname_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_key_modifier_del(efl::eolian::to_c(keyname_)));
   }

   /// @brief This function returns the @p state of nth touch point.
   ///
   /// @return @p state of nth touch point, if the call succeeded,
   /// EVAS_TOUCH_POINT_CANCEL otherwise.
   ///
   /// The point's @p state is EVAS_TOUCH_POINT_DOWN when pressed,
   /// EVAS_TOUCH_POINT_STILL when the point is not moved after pressed,
   /// EVAS_TOUCH_POINT_MOVE when moved at least once after pressed and
   /// EVAS_TOUCH_POINT_UP when released.
   ///
   /// Example:
   /// @code
   /// extern Evas *evas;
   /// Evas_Touch_Point_State state;
   ///
   /// if (evas_touch_point_list_count(evas))
   /// {
   /// state = evas_touch_point_nth_state_get(evas, 0);
   /// printf("The first touch point's state: %i\n", state);
   /// }
   /// @endcode
   ///
   /// @see evas_touch_point_list_count()
   /// @see evas_touch_point_list_nth_xy_get()
   /// @see evas_touch_point_list_nth_id_get()
   ///
   /// @param n The number of the touched point (0 being the first).
   ///
   Evas_Touch_Point_State touch_point_list_nth_state_get(unsigned int n_) const
   {
      Evas_Touch_Point_State _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_touch_point_list_nth_state_get(n_));
      return _tmp_ret;
   }

   /// @brief Inform to the evas that it got the focus.
   ///
   /// @ingroup Evas_Canvas
   ///
   void focus_in() const
   {
      eo_do(_eo_ptr(), ::evas_canvas_focus_in());
   }

   /// @brief Add an "obscured region" to an Evas canvas.
   ///
   /// This is the function by which one tells an Evas canvas that a part
   /// of it <b>must not</b> be repainted. The region must be
   /// rectangular and its coordinates inside the canvas viewport are
   /// passed in the call. After this call, the region specified won't
   /// participate in any form in Evas' calculations and actions during
   /// its rendering updates, having its displaying content frozen as it
   /// was just after this function took place.
   ///
   /// We call it "obscured region" because the most common use case for
   /// this rendering (partial) freeze is something else (most probably
   /// other canvas) being on top of the specified rectangular region,
   /// thus shading it completely from the user's final scene in a
   /// display. To avoid unnecessary processing, one should indicate to the
   /// obscured canvas not to bother about the non-important area.
   ///
   /// The majority of users won't have to worry about this function, as
   /// they'll be using just one canvas in their applications, with
   /// nothing inset or on top of it in any form.
   ///
   /// To make this region one that @b has to be repainted again, call the
   /// function evas_obscured_clear().
   ///
   /// @note This is a <b>very low level function</b>, which most of
   /// Evas' users wouldn't care about.
   ///
   /// @note This function does @b not flag the canvas as having its state
   /// changed. If you want to re-render it afterwards expecting new
   /// contents, you have to add "damage" regions yourself (see
   /// evas_damage_rectangle_add()).
   ///
   /// @see evas_obscured_clear()
   /// @see evas_render_updates()
   ///
   /// Example code follows.
   /// @dontinclude evas-events.c
   /// @skip add an obscured
   /// @until evas_obscured_clear(evas);
   ///
   /// In that example, pressing the "Ctrl" and "o" keys will impose or
   /// remove an obscured region in the middle of the canvas. You'll get
   /// the same contents at the time the key was pressed, if toggling it
   /// on, until you toggle it off again (make sure the animation is
   /// running on to get the idea better). See the full @ref
   /// Example_Evas_Events "example".
   ///
   /// @ingroup Evas_Canvas
   ///
   /// @param x The rectangle's top left corner's horizontal coordinate.
   /// @param y The rectangle's top left corner's vertical coordinate
   /// @param w The rectangle's width.
   /// @param h The rectangle's height.
   ///
   void obscured_rectangle_add(int x_, int y_, int w_, int h_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_obscured_rectangle_add(x_, y_, w_, h_));
   }

   /// @brief Make the canvas discard as much data as possible used by the engine at
   /// runtime.
   ///
   /// This function will unload images, delete textures and much more, where
   /// possible. You may also want to call evas_render_idle_flush() immediately
   /// prior to this to perhaps discard a little more, though evas_render_dump()
   /// should implicitly delete most of what evas_render_idle_flush() might
   /// discard too.
   ///
   /// @ingroup Evas_Canvas
   ///
   void render_dump() const
   {
      eo_do(_eo_ptr(), ::evas_canvas_render_dump());
   }

   /// @brief Mouse in event feed.
   ///
   /// This function will set some evas properties that is necessary when
   /// the mouse in event happens. It prepares information to be treated
   /// by the callback function.
   ///
   /// @param timestamp The timestamp of the mouse up event.
   /// @param data The data for canvas.
   ///
   void event_feed_mouse_in(unsigned int timestamp_, const void * data_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_event_feed_mouse_in(timestamp_, data_));
   }

   /// @brief Retrieve the Evas object stacked at the top of a given rectangular
   /// region in a canvas
   ///
   /// @return  The Evas object that is over all other objects at the given
   /// rectangular region.
   ///
   /// This function will traverse all the layers of the given canvas,
   /// from top to bottom, querying for objects with areas overlapping
   /// with the given rectangular region inside @p e. The user can remove
   /// from the query objects which are hidden and/or which are set to
   /// pass events.
   ///
   /// @warning This function will @b skip objects parented by smart
   /// objects, acting only on the ones at the "top level", with regard to
   /// object parenting.
   ///
   /// @param x The top left corner's horizontal coordinate for the
   /// rectangular region
   /// @param y The top left corner's vertical coordinate for the
   /// rectangular region
   /// @param w The width of the rectangular region
   /// @param h The height of the rectangular region
   /// @param include_pass_events_objects Boolean flag to include or not
   /// objects which pass events in this calculation
   /// @param include_hidden_objects Boolean flag to include or not hidden
   /// objects in this calculation
   ///
   evas::object object_top_in_rectangle_get(Evas_Coord x_, Evas_Coord y_, Evas_Coord w_, Evas_Coord h_, bool include_pass_events_objects_, bool include_hidden_objects_) const
   {
      Evas_Object * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_object_top_in_rectangle_get(x_, y_, w_, h_, efl::eolian::to_c(include_pass_events_objects_), efl::eolian::to_c(include_hidden_objects_)));
      return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Force renderization of the given canvas.
   ///
   /// @ingroup Evas_Canvas
   ///
   void render() const
   {
      eo_do(_eo_ptr(), ::evas_canvas_render());
   }

   /// @brief No description supplied by the EAPI.
   ///
   /// @param d 
   /// @param x 
   /// @param y 
   /// @param rad 
   /// @param radx 
   /// @param rady 
   /// @param pres 
   /// @param ang 
   /// @param fx 
   /// @param fy 
   /// @param flags 
   /// @param timestamp 
   /// @param data 
   ///
   void event_feed_multi_up(int d_, int x_, int y_, double rad_, double radx_, double rady_, double pres_, double ang_, double fx_, double fy_, Evas_Button_Flags flags_, unsigned int timestamp_, const void * data_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_event_feed_multi_up(d_, x_, y_, rad_, radx_, rady_, pres_, ang_, fx_, fy_, flags_, timestamp_, data_));
   }

   /// @brief Prepends a font path to the list of font paths used by the given evas.
   /// @ingroup Evas_Font_Path_Group
   ///
   /// @param path The new font path.
   ///
   void font_path_prepend(std::string path_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_font_path_prepend(efl::eolian::to_c(path_)));
   }

   /// @brief Remove all "obscured regions" from an Evas canvas.
   ///
   /// This function removes all the rectangles from the obscured regions
   /// list of the canvas @p e. It takes obscured areas added with
   /// evas_obscured_rectangle_add() and make them again a regions that @b
   /// have to be repainted on rendering updates.
   ///
   /// @note This is a <b>very low level function</b>, which most of
   /// Evas' users wouldn't care about.
   ///
   /// @note This function does @b not flag the canvas as having its state
   /// changed. If you want to re-render it afterwards expecting new
   /// contents, you have to add "damage" regions yourself (see
   /// evas_damage_rectangle_add()).
   ///
   /// @see evas_obscured_rectangle_add() for an example
   /// @see evas_render_updates()
   ///
   /// @ingroup Evas_Canvas
   ///
   void obscured_clear() const
   {
      eo_do(_eo_ptr(), ::evas_canvas_obscured_clear());
   }

   /// @brief Mouse cancel event feed.
   ///
   /// This function will call evas_event_feed_mouse_up() when a
   /// mouse cancel event happens.
   ///
   /// @param timestamp The timestamp of the mouse up event.
   /// @param data The data for canvas.
   ///
   void event_feed_mouse_cancel(unsigned int timestamp_, const void * data_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_event_feed_mouse_cancel(timestamp_, data_));
   }

   /// @brief Convert/scale an output screen co-ordinate into canvas co-ordinates
   ///
   /// @return The screen co-ordinate translated to canvas unit co-ordinates
   /// @ingroup Evas_Coord_Mapping_Group
   ///
   /// This function takes in a horizontal co-ordinate as the @p x
   /// parameter and converts it into canvas units, accounting for output
   /// size, viewport size and location, returning it as the function
   /// return value. If @p e is invalid, the results are undefined.
   ///
   /// Example:
   /// @code
   /// extern Evas *evas;
   /// extern int screen_x;
   /// Evas_Coord canvas_x;
   ///
   /// canvas_x = evas_coord_screen_x_to_world(evas, screen_x);
   /// @endcode
   ///
   /// @param x The screen/output x co-ordinate
   ///
   Evas_Coord coord_screen_x_to_world(int x_) const
   {
      Evas_Coord _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_coord_screen_x_to_world(x_));
      return _tmp_ret;
   }

   /// @brief Adds the @p keyname key to the current list of lock keys.
   ///
   /// Locks are keys like caps lock, num lock or scroll lock, i.e., keys
   /// which are meant to be pressed once -- toggling a binary state which
   /// is bound to it -- and thus altering the behavior of all
   /// subsequently pressed keys somehow, depending on its state. Evas is
   /// so that these keys can be defined by the user.
   ///
   /// This allows custom locks to be added to the evas system at run
   /// time. It is then possible to set and unset lock keys
   /// programmatically for other parts of the program to check and act
   /// on. Programmers using Evas would check for lock keys on key event
   /// callbacks using evas_key_lock_is_set().
   ///
   /// @see evas_key_lock_get
   /// @see evas_key_lock_del
   /// @see evas_key_lock_on
   /// @see evas_key_lock_off
   /// @see evas_key_lock_is_set
   ///
   /// @note If the programmer instantiates the canvas by means of the
   /// ecore_evas_new() family of helper functions, Ecore will take
   /// care of registering on it all standard lock keys: "Caps_Lock",
   /// "Num_Lock", "Scroll_Lock".
   ///
   /// @param keyname The name of the key to add to the locks list.
   ///
   void key_lock_add(std::string keyname_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_key_lock_add(efl::eolian::to_c(keyname_)));
   }

   /// @brief Make the canvas discard internally cached data used for rendering.
   ///
   /// This function flushes the arrays of delete, active and render objects.
   /// Other things it may also discard are: shared memory segments,
   /// temporary scratch buffers, cached data to avoid re-compute of that data etc.
   ///
   /// @ingroup Evas_Canvas
   ///
   void render_idle_flush() const
   {
      eo_do(_eo_ptr(), ::evas_canvas_render_idle_flush());
   }

   /// @brief Convert/scale a canvas co-ordinate into output screen co-ordinates
   ///
   /// @return The output/screen co-ordinate translated to output co-ordinates
   /// @ingroup Evas_Coord_Mapping_Group
   ///
   /// This function takes in a vertical co-ordinate as the @p x parameter
   /// and converts it into output units, accounting for output size,
   /// viewport size and location, returning it as the function return
   /// value. If @p e is invalid, the results are undefined.
   ///
   /// Example:
   /// @code
   /// extern Evas *evas;
   /// int screen_y;
   /// extern Evas_Coord canvas_y;
   ///
   /// screen_y = evas_coord_world_y_to_screen(evas, canvas_y);
   /// @endcode
   ///
   /// @param y The canvas y co-ordinate
   ///
   int coord_world_y_to_screen(Evas_Coord y_) const
   {
      int _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_canvas_coord_world_y_to_screen(y_));
      return _tmp_ret;
   }

   /// @brief Key down event feed with keycode
   ///
   /// This function will set some evas properties that is necessary when
   /// a key is pressed. It prepares information to be treated by the
   /// callback function.
   ///
   /// @since 1.10
   ///
   /// @param keyname Name of the key
   /// @param key The key pressed.
   /// @param string A String
   /// @param compose The compose string
   /// @param timestamp Timestamp of the mouse up event
   /// @param data Data for canvas.
   /// @param keycode Key scan code numeric value for canvas.
   ///
   void event_feed_key_down_with_keycode(std::string keyname_, std::string key_, std::string string_, std::string compose_, unsigned int timestamp_, const void * data_, unsigned int keycode_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_event_feed_key_down_with_keycode(efl::eolian::to_c(keyname_), efl::eolian::to_c(key_), efl::eolian::to_c(string_), efl::eolian::to_c(compose_), timestamp_, data_, keycode_));
   }

   /// @brief Key up event feed with keycode
   ///
   /// This function will set some evas properties that is necessary when
   /// a key is released. It prepares information to be treated by the
   /// callback function.
   ///
   /// @since 1.10
   ///
   /// @param keyname Name of the key
   /// @param key The key released.
   /// @param string string
   /// @param compose compose
   /// @param timestamp Timestamp of the mouse up event
   /// @param data Data for canvas.
   /// @param keycode Key scan code numeric value for canvas.
   ///
   void event_feed_key_up_with_keycode(std::string keyname_, std::string key_, std::string string_, std::string compose_, unsigned int timestamp_, const void * data_, unsigned int keycode_) const
   {
      eo_do(_eo_ptr(), ::evas_canvas_event_feed_key_up_with_keycode(efl::eolian::to_c(keyname_), efl::eolian::to_c(key_), efl::eolian::to_c(string_), efl::eolian::to_c(compose_), timestamp_, data_, keycode_));
   }

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

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

};
} 

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

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

template <typename T>
Evas * evas_canvas_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_canvas_output_framespace_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_)
{
   static_cast<T*>(self->this_)->output_framespace_get(x_, y_, w_, h_);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template <typename T>
evas::object evas_canvas_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>
evas::object evas_canvas_object_top_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self)
{
   return static_cast<T*>(self->this_)->object_top_get();
}

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

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

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

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

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

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

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

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

template <typename T>
bool evas_canvas_image_max_size_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, int* maxw_, int* maxh_)
{
   return static_cast<T*>(self->this_)->image_max_size_get(maxw_, maxh_);
}

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

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

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

template <typename T>
efl::eina::range_list< evas::object > evas_canvas_tree_objects_at_xy_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Object * stop_, int x_, int y_)
{
   return static_cast<T*>(self->this_)->tree_objects_at_xy_get(efl::eolian::to_cxx<evas::object>(stop_, std::tuple<std::false_type>()), x_, y_);
}

template <typename T>
void evas_canvas_event_feed_mouse_wheel_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, int direction_, int z_, unsigned int timestamp_, const void * data_)
{
   static_cast<T*>(self->this_)->event_feed_mouse_wheel(direction_, z_, timestamp_, data_);
}

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

template <typename T>
void evas_canvas_event_feed_key_down_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * keyname_, const char * key_, const char * string_, const char * compose_, unsigned int timestamp_, const void * data_)
{
   static_cast<T*>(self->this_)->event_feed_key_down(efl::eolian::to_cxx<std::string>(keyname_, std::tuple<std::false_type>()), efl::eolian::to_cxx<std::string>(key_, std::tuple<std::false_type>()), efl::eolian::to_cxx<std::string>(string_, std::tuple<std::false_type>()), efl::eolian::to_cxx<std::string>(compose_, std::tuple<std::false_type>()), timestamp_, data_);
}

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

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

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

template <typename T>
void evas_canvas_event_feed_hold_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, int hold_, unsigned int timestamp_, const void * data_)
{
   static_cast<T*>(self->this_)->event_feed_hold(hold_, timestamp_, data_);
}

template <typename T>
void evas_canvas_event_feed_mouse_move_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, int x_, int y_, unsigned int timestamp_, const void * data_)
{
   static_cast<T*>(self->this_)->event_feed_mouse_move(x_, y_, timestamp_, data_);
}

template <typename T>
void evas_canvas_event_feed_key_up_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * keyname_, const char * key_, const char * string_, const char * compose_, unsigned int timestamp_, const void * data_)
{
   static_cast<T*>(self->this_)->event_feed_key_up(efl::eolian::to_cxx<std::string>(keyname_, std::tuple<std::false_type>()), efl::eolian::to_cxx<std::string>(key_, std::tuple<std::false_type>()), efl::eolian::to_cxx<std::string>(string_, std::tuple<std::false_type>()), efl::eolian::to_cxx<std::string>(compose_, std::tuple<std::false_type>()), timestamp_, data_);
}

template <typename T>
void evas_canvas_event_feed_mouse_out_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, unsigned int timestamp_, const void * data_)
{
   static_cast<T*>(self->this_)->event_feed_mouse_out(timestamp_, data_);
}

template <typename T>
void evas_canvas_event_input_multi_move_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, int d_, int x_, int y_, double rad_, double radx_, double rady_, double pres_, double ang_, double fx_, double fy_, unsigned int timestamp_, const void * data_)
{
   static_cast<T*>(self->this_)->event_input_multi_move(d_, x_, y_, rad_, radx_, rady_, pres_, ang_, fx_, fy_, timestamp_, data_);
}

template <typename T>
efl::eina::range_list< evas::object > evas_canvas_objects_at_xy_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Coord x_, Evas_Coord y_, Eina_Bool include_pass_events_objects_, Eina_Bool include_hidden_objects_)
{
   return static_cast<T*>(self->this_)->objects_at_xy_get(x_, y_, efl::eolian::to_cxx<bool>(include_pass_events_objects_, std::tuple<std::false_type>()), efl::eolian::to_cxx<bool>(include_hidden_objects_, std::tuple<std::false_type>()));
}

template <typename T>
void evas_canvas_event_input_multi_up_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, int d_, int x_, int y_, double rad_, double radx_, double rady_, double pres_, double ang_, double fx_, double fy_, Evas_Button_Flags flags_, unsigned int timestamp_, const void * data_)
{
   static_cast<T*>(self->this_)->event_input_multi_up(d_, x_, y_, rad_, radx_, rady_, pres_, ang_, fx_, fy_, flags_, timestamp_, data_);
}

template <typename T>
void evas_canvas_event_feed_multi_down_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, int d_, int x_, int y_, double rad_, double radx_, double rady_, double pres_, double ang_, double fx_, double fy_, Evas_Button_Flags flags_, unsigned int timestamp_, const void * data_)
{
   static_cast<T*>(self->this_)->event_feed_multi_down(d_, x_, y_, rad_, radx_, rady_, pres_, ang_, fx_, fy_, flags_, timestamp_, data_);
}

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

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

template <typename T>
void evas_canvas_event_input_mouse_move_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, int x_, int y_, unsigned int timestamp_, const void * data_)
{
   static_cast<T*>(self->this_)->event_input_mouse_move(x_, y_, timestamp_, data_);
}

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

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

template <typename T>
void evas_canvas_event_input_multi_down_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, int d_, int x_, int y_, double rad_, double radx_, double rady_, double pres_, double ang_, double fx_, double fy_, Evas_Button_Flags flags_, unsigned int timestamp_, const void * data_)
{
   static_cast<T*>(self->this_)->event_input_multi_down(d_, x_, y_, rad_, radx_, rady_, pres_, ang_, fx_, fy_, flags_, timestamp_, data_);
}

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

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

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

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

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

template <typename T>
evas::object evas_canvas_object_top_at_xy_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Coord x_, Evas_Coord y_, Eina_Bool include_pass_events_objects_, Eina_Bool include_hidden_objects_)
{
   return static_cast<T*>(self->this_)->object_top_at_xy_get(x_, y_, efl::eolian::to_cxx<bool>(include_pass_events_objects_, std::tuple<std::false_type>()), efl::eolian::to_cxx<bool>(include_hidden_objects_, std::tuple<std::false_type>()));
}

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

template <typename T>
void evas_canvas_event_feed_mouse_up_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, int b_, Evas_Button_Flags flags_, unsigned int timestamp_, const void * data_)
{
   static_cast<T*>(self->this_)->event_feed_mouse_up(b_, flags_, timestamp_, data_);
}

template <typename T>
void evas_canvas_event_feed_mouse_down_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, int b_, Evas_Button_Flags flags_, unsigned int timestamp_, const void * data_)
{
   static_cast<T*>(self->this_)->event_feed_mouse_down(b_, flags_, timestamp_, data_);
}

template <typename T>
void evas_canvas_event_refeed_event_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, void * event_copy_, Evas_Callback_Type event_type_)
{
   static_cast<T*>(self->this_)->event_refeed_event(event_copy_, event_type_);
}

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

template <typename T>
efl::eina::range_list< evas::object > evas_canvas_objects_in_rectangle_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Coord x_, Evas_Coord y_, Evas_Coord w_, Evas_Coord h_, Eina_Bool include_pass_events_objects_, Eina_Bool include_hidden_objects_)
{
   return static_cast<T*>(self->this_)->objects_in_rectangle_get(x_, y_, w_, h_, efl::eolian::to_cxx<bool>(include_pass_events_objects_, std::tuple<std::false_type>()), efl::eolian::to_cxx<bool>(include_hidden_objects_, std::tuple<std::false_type>()));
}

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

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

template <typename T>
int evas_canvas_touch_point_list_nth_id_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, unsigned int n_)
{
   return static_cast<T*>(self->this_)->touch_point_list_nth_id_get(n_);
}

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

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

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

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

template <typename T>
void evas_canvas_damage_rectangle_add_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, int x_, int y_, int w_, int h_)
{
   static_cast<T*>(self->this_)->damage_rectangle_add(x_, y_, w_, h_);
}

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

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

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

template <typename T>
int evas_canvas_coord_world_x_to_screen_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Coord x_)
{
   return static_cast<T*>(self->this_)->coord_world_x_to_screen(x_);
}

template <typename T>
void evas_canvas_event_feed_multi_move_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, int d_, int x_, int y_, double rad_, double radx_, double rady_, double pres_, double ang_, double fx_, double fy_, unsigned int timestamp_, const void * data_)
{
   static_cast<T*>(self->this_)->event_feed_multi_move(d_, x_, y_, rad_, radx_, rady_, pres_, ang_, fx_, fy_, timestamp_, data_);
}

template <typename T>
efl::eina::list< Eina_Rectangle * > evas_canvas_render_updates_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self)
{
   return static_cast<T*>(self->this_)->render_updates();
}

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

template <typename T>
Evas_Coord evas_canvas_coord_screen_y_to_world_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, int y_)
{
   return static_cast<T*>(self->this_)->coord_screen_y_to_world(y_);
}

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

template <typename T>
Evas_Touch_Point_State evas_canvas_touch_point_list_nth_state_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, unsigned int n_)
{
   return static_cast<T*>(self->this_)->touch_point_list_nth_state_get(n_);
}

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

template <typename T>
void evas_canvas_obscured_rectangle_add_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, int x_, int y_, int w_, int h_)
{
   static_cast<T*>(self->this_)->obscured_rectangle_add(x_, y_, w_, h_);
}

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

template <typename T>
void evas_canvas_event_feed_mouse_in_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, unsigned int timestamp_, const void * data_)
{
   static_cast<T*>(self->this_)->event_feed_mouse_in(timestamp_, data_);
}

template <typename T>
evas::object evas_canvas_object_top_in_rectangle_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Coord x_, Evas_Coord y_, Evas_Coord w_, Evas_Coord h_, Eina_Bool include_pass_events_objects_, Eina_Bool include_hidden_objects_)
{
   return static_cast<T*>(self->this_)->object_top_in_rectangle_get(x_, y_, w_, h_, efl::eolian::to_cxx<bool>(include_pass_events_objects_, std::tuple<std::false_type>()), efl::eolian::to_cxx<bool>(include_hidden_objects_, std::tuple<std::false_type>()));
}

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

template <typename T>
void evas_canvas_event_feed_multi_up_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, int d_, int x_, int y_, double rad_, double radx_, double rady_, double pres_, double ang_, double fx_, double fy_, Evas_Button_Flags flags_, unsigned int timestamp_, const void * data_)
{
   static_cast<T*>(self->this_)->event_feed_multi_up(d_, x_, y_, rad_, radx_, rady_, pres_, ang_, fx_, fy_, flags_, timestamp_, data_);
}

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

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

template <typename T>
void evas_canvas_event_feed_mouse_cancel_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, unsigned int timestamp_, const void * data_)
{
   static_cast<T*>(self->this_)->event_feed_mouse_cancel(timestamp_, data_);
}

template <typename T>
Evas_Coord evas_canvas_coord_screen_x_to_world_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, int x_)
{
   return static_cast<T*>(self->this_)->coord_screen_x_to_world(x_);
}

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

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

template <typename T>
int evas_canvas_coord_world_y_to_screen_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Coord y_)
{
   return static_cast<T*>(self->this_)->coord_world_y_to_screen(y_);
}

template <typename T>
void evas_canvas_event_feed_key_down_with_keycode_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * keyname_, const char * key_, const char * string_, const char * compose_, unsigned int timestamp_, const void * data_, unsigned int keycode_)
{
   static_cast<T*>(self->this_)->event_feed_key_down_with_keycode(efl::eolian::to_cxx<std::string>(keyname_, std::tuple<std::false_type>()), efl::eolian::to_cxx<std::string>(key_, std::tuple<std::false_type>()), efl::eolian::to_cxx<std::string>(string_, std::tuple<std::false_type>()), efl::eolian::to_cxx<std::string>(compose_, std::tuple<std::false_type>()), timestamp_, data_, keycode_);
}

template <typename T>
void evas_canvas_event_feed_key_up_with_keycode_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * keyname_, const char * key_, const char * string_, const char * compose_, unsigned int timestamp_, const void * data_, unsigned int keycode_)
{
   static_cast<T*>(self->this_)->event_feed_key_up_with_keycode(efl::eolian::to_cxx<std::string>(keyname_, std::tuple<std::false_type>()), efl::eolian::to_cxx<std::string>(key_, std::tuple<std::false_type>()), efl::eolian::to_cxx<std::string>(string_, std::tuple<std::false_type>()), efl::eolian::to_cxx<std::string>(compose_, std::tuple<std::false_type>()), timestamp_, data_, keycode_);
}

namespace efl { namespace eo { namespace detail {

template<>
struct operations< evas::canvas >
{
   template <typename T>
   struct type
   {
      virtual void event_thaw()
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::eo_event_thaw());
      }

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

      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 output_framespace_get(Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_canvas_output_framespace_get(x_, y_, w_, h_));
      }

      virtual void output_framespace_set(Evas_Coord x_, Evas_Coord y_, Evas_Coord w_, Evas_Coord h_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_canvas_output_framespace_set(x_, y_, w_, h_));
      }

      virtual void output_viewport_get(Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_canvas_output_viewport_get(x_, y_, w_, h_));
      }

      virtual void output_viewport_set(Evas_Coord x_, Evas_Coord y_, Evas_Coord w_, Evas_Coord h_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_canvas_output_viewport_set(x_, y_, w_, h_));
      }

      virtual int image_cache_get()
      {
         int _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_canvas_image_cache_get());
            return _tmp_ret;
      }

      virtual void image_cache_set(int size_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_canvas_image_cache_set(size_));
      }

      virtual Evas_Event_Flags event_default_flags_get()
      {
         Evas_Event_Flags _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_canvas_event_default_flags_get());
            return _tmp_ret;
      }

      virtual void event_default_flags_set(Evas_Event_Flags flags_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_canvas_event_default_flags_set(flags_));
      }

      virtual int output_method_get()
      {
         int _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_canvas_output_method_get());
            return _tmp_ret;
      }

      virtual void output_method_set(int render_method_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_canvas_output_method_set(render_method_));
      }

      virtual int font_cache_get()
      {
         int _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_canvas_font_cache_get());
            return _tmp_ret;
      }

      virtual void font_cache_set(int size_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_canvas_font_cache_set(size_));
      }

      virtual void output_size_get(int* w_, int* h_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_canvas_output_size_get(w_, h_));
      }

      virtual void output_size_set(int w_, int h_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_canvas_output_size_set(w_, h_));
      }

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

      virtual void data_attach_set(void * data_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_canvas_data_attach_set(data_));
      }

      virtual Evas_Font_Hinting_Flags font_hinting_get()
      {
         Evas_Font_Hinting_Flags _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_canvas_font_hinting_get());
            return _tmp_ret;
      }

      virtual void font_hinting_set(Evas_Font_Hinting_Flags hinting_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_canvas_font_hinting_set(hinting_));
      }

      virtual Evas_Engine_Info * engine_info_get()
      {
         Evas_Engine_Info * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_canvas_engine_info_get());
            return _tmp_ret;
      }

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

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

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

      virtual const Evas_Lock * key_lock_get()
      {
         const Evas_Lock * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_canvas_key_lock_get());
            return _tmp_ret;
      }

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

      virtual int event_down_count_get()
      {
         int _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_canvas_event_down_count_get());
            return _tmp_ret;
      }

      virtual int smart_objects_calculate_count_get()
      {
         int _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_canvas_smart_objects_calculate_count_get());
            return _tmp_ret;
      }

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

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

      virtual void pointer_output_xy_get(int* x_, int* y_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_canvas_pointer_output_xy_get(x_, y_));
      }

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

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

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

      virtual const Evas_Modifier * key_modifier_get()
      {
         const Evas_Modifier * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_canvas_key_modifier_get());
            return _tmp_ret;
      }

      virtual int pointer_button_down_mask_get()
      {
         int _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_canvas_pointer_button_down_mask_get());
            return _tmp_ret;
      }

      virtual efl::eina::range_list< evas::object > tree_objects_at_xy_get(evas::object stop_, int x_, int y_)
      {
         Eina_List * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_canvas_tree_objects_at_xy_get(efl::eolian::to_c(stop_), x_, y_));
            return efl::eolian::to_cxx<efl::eina::range_list< evas::object >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
      }

      virtual void event_feed_mouse_wheel(int direction_, int z_, unsigned int timestamp_, const void * data_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_canvas_event_feed_mouse_wheel(direction_, z_, timestamp_, data_));
      }

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

      virtual void event_feed_key_down(std::string keyname_, std::string key_, std::string string_, std::string compose_, unsigned int timestamp_, const void * data_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_canvas_event_feed_key_down(efl::eolian::to_c(keyname_), efl::eolian::to_c(key_), efl::eolian::to_c(string_), efl::eolian::to_c(compose_), timestamp_, data_));
      }

      virtual Evas_Modifier_Mask key_modifier_mask_get(std::string keyname_)
      {
         Evas_Modifier_Mask _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_canvas_key_modifier_mask_get(efl::eolian::to_c(keyname_)));
            return _tmp_ret;
      }

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

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

      virtual void event_feed_hold(int hold_, unsigned int timestamp_, const void * data_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_canvas_event_feed_hold(hold_, timestamp_, data_));
      }

      virtual void event_feed_mouse_move(int x_, int y_, unsigned int timestamp_, const void * data_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_canvas_event_feed_mouse_move(x_, y_, timestamp_, data_));
      }

      virtual void event_feed_key_up(std::string keyname_, std::string key_, std::string string_, std::string compose_, unsigned int timestamp_, const void * data_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_canvas_event_feed_key_up(efl::eolian::to_c(keyname_), efl::eolian::to_c(key_), efl::eolian::to_c(string_), efl::eolian::to_c(compose_), timestamp_, data_));
      }

      virtual void event_feed_mouse_out(unsigned int timestamp_, const void * data_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_canvas_event_feed_mouse_out(timestamp_, data_));
      }

      virtual void event_input_multi_move(int d_, int x_, int y_, double rad_, double radx_, double rady_, double pres_, double ang_, double fx_, double fy_, unsigned int timestamp_, const void * data_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_canvas_event_input_multi_move(d_, x_, y_, rad_, radx_, rady_, pres_, ang_, fx_, fy_, timestamp_, data_));
      }

      virtual efl::eina::range_list< evas::object > objects_at_xy_get(Evas_Coord x_, Evas_Coord y_, bool include_pass_events_objects_, bool include_hidden_objects_)
      {
         Eina_List * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_canvas_objects_at_xy_get(x_, y_, efl::eolian::to_c(include_pass_events_objects_), efl::eolian::to_c(include_hidden_objects_)));
            return efl::eolian::to_cxx<efl::eina::range_list< evas::object >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
      }

      virtual void event_input_multi_up(int d_, int x_, int y_, double rad_, double radx_, double rady_, double pres_, double ang_, double fx_, double fy_, Evas_Button_Flags flags_, unsigned int timestamp_, const void * data_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_canvas_event_input_multi_up(d_, x_, y_, rad_, radx_, rady_, pres_, ang_, fx_, fy_, flags_, timestamp_, data_));
      }

      virtual void event_feed_multi_down(int d_, int x_, int y_, double rad_, double radx_, double rady_, double pres_, double ang_, double fx_, double fy_, Evas_Button_Flags flags_, unsigned int timestamp_, const void * data_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_canvas_event_feed_multi_down(d_, x_, y_, rad_, radx_, rady_, pres_, ang_, fx_, fy_, flags_, timestamp_, data_));
      }

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

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

      virtual void event_input_mouse_move(int x_, int y_, unsigned int timestamp_, const void * data_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_canvas_event_input_mouse_move(x_, y_, timestamp_, data_));
      }

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

      virtual unsigned int touch_point_list_count()
      {
         unsigned int _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_canvas_touch_point_list_count());
            return _tmp_ret;
      }

      virtual void event_input_multi_down(int d_, int x_, int y_, double rad_, double radx_, double rady_, double pres_, double ang_, double fx_, double fy_, Evas_Button_Flags flags_, unsigned int timestamp_, const void * data_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_canvas_event_input_multi_down(d_, x_, y_, rad_, radx_, rady_, pres_, ang_, fx_, fy_, flags_, timestamp_, data_));
      }

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

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

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

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

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

      virtual evas::object object_top_at_xy_get(Evas_Coord x_, Evas_Coord y_, bool include_pass_events_objects_, bool include_hidden_objects_)
      {
         Evas_Object * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_canvas_object_top_at_xy_get(x_, y_, efl::eolian::to_c(include_pass_events_objects_), efl::eolian::to_c(include_hidden_objects_)));
            return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }

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

      virtual void event_feed_mouse_up(int b_, Evas_Button_Flags flags_, unsigned int timestamp_, const void * data_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_canvas_event_feed_mouse_up(b_, flags_, timestamp_, data_));
      }

      virtual void event_feed_mouse_down(int b_, Evas_Button_Flags flags_, unsigned int timestamp_, const void * data_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_canvas_event_feed_mouse_down(b_, flags_, timestamp_, data_));
      }

      virtual void event_refeed_event(void * event_copy_, Evas_Callback_Type event_type_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_canvas_event_refeed_event(event_copy_, event_type_));
      }

      virtual efl::eina::range_list< std::string > font_available_list()
      {
         Eina_List * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_canvas_font_available_list());
            return efl::eolian::to_cxx<efl::eina::range_list< std::string >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
      }

      virtual efl::eina::range_list< evas::object > objects_in_rectangle_get(Evas_Coord x_, Evas_Coord y_, Evas_Coord w_, Evas_Coord h_, bool include_pass_events_objects_, bool include_hidden_objects_)
      {
         Eina_List * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_canvas_objects_in_rectangle_get(x_, y_, w_, h_, efl::eolian::to_c(include_pass_events_objects_), efl::eolian::to_c(include_hidden_objects_)));
            return efl::eolian::to_cxx<efl::eina::range_list< evas::object >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
      }

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

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

      virtual int touch_point_list_nth_id_get(unsigned int n_)
      {
         int _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_canvas_touch_point_list_nth_id_get(n_));
            return _tmp_ret;
      }

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

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

      virtual void touch_point_list_nth_xy_get(unsigned int n_, Evas_Coord* x_, Evas_Coord* y_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_canvas_touch_point_list_nth_xy_get(n_, x_, y_));
      }

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

      virtual void damage_rectangle_add(int x_, int y_, int w_, int h_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_canvas_damage_rectangle_add(x_, y_, w_, h_));
      }

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

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

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

      virtual int coord_world_x_to_screen(Evas_Coord x_)
      {
         int _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_canvas_coord_world_x_to_screen(x_));
            return _tmp_ret;
      }

      virtual void event_feed_multi_move(int d_, int x_, int y_, double rad_, double radx_, double rady_, double pres_, double ang_, double fx_, double fy_, unsigned int timestamp_, const void * data_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_canvas_event_feed_multi_move(d_, x_, y_, rad_, radx_, rady_, pres_, ang_, fx_, fy_, timestamp_, data_));
      }

      virtual efl::eina::list< Eina_Rectangle * > render_updates()
      {
         Eina_List * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_canvas_render_updates());
            return efl::eolian::to_cxx<efl::eina::list< Eina_Rectangle * >>(_tmp_ret, std::tuple<std::true_type, std::false_type>());
      }

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

      virtual Evas_Coord coord_screen_y_to_world(int y_)
      {
         Evas_Coord _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_canvas_coord_screen_y_to_world(y_));
            return _tmp_ret;
      }

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

      virtual Evas_Touch_Point_State touch_point_list_nth_state_get(unsigned int n_)
      {
         Evas_Touch_Point_State _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_canvas_touch_point_list_nth_state_get(n_));
            return _tmp_ret;
      }

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

      virtual void obscured_rectangle_add(int x_, int y_, int w_, int h_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_canvas_obscured_rectangle_add(x_, y_, w_, h_));
      }

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

      virtual void event_feed_mouse_in(unsigned int timestamp_, const void * data_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_canvas_event_feed_mouse_in(timestamp_, data_));
      }

      virtual evas::object object_top_in_rectangle_get(Evas_Coord x_, Evas_Coord y_, Evas_Coord w_, Evas_Coord h_, bool include_pass_events_objects_, bool include_hidden_objects_)
      {
         Evas_Object * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_canvas_object_top_in_rectangle_get(x_, y_, w_, h_, efl::eolian::to_c(include_pass_events_objects_), efl::eolian::to_c(include_hidden_objects_)));
            return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }

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

      virtual void event_feed_multi_up(int d_, int x_, int y_, double rad_, double radx_, double rady_, double pres_, double ang_, double fx_, double fy_, Evas_Button_Flags flags_, unsigned int timestamp_, const void * data_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_canvas_event_feed_multi_up(d_, x_, y_, rad_, radx_, rady_, pres_, ang_, fx_, fy_, flags_, timestamp_, data_));
      }

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

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

      virtual void event_feed_mouse_cancel(unsigned int timestamp_, const void * data_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_canvas_event_feed_mouse_cancel(timestamp_, data_));
      }

      virtual Evas_Coord coord_screen_x_to_world(int x_)
      {
         Evas_Coord _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_canvas_coord_screen_x_to_world(x_));
            return _tmp_ret;
      }

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

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

      virtual int coord_world_y_to_screen(Evas_Coord y_)
      {
         int _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_canvas_coord_world_y_to_screen(y_));
            return _tmp_ret;
      }

      virtual void event_feed_key_down_with_keycode(std::string keyname_, std::string key_, std::string string_, std::string compose_, unsigned int timestamp_, const void * data_, unsigned int keycode_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_canvas_event_feed_key_down_with_keycode(efl::eolian::to_c(keyname_), efl::eolian::to_c(key_), efl::eolian::to_c(string_), efl::eolian::to_c(compose_), timestamp_, data_, keycode_));
      }

      virtual void event_feed_key_up_with_keycode(std::string keyname_, std::string key_, std::string string_, std::string compose_, unsigned int timestamp_, const void * data_, unsigned int keycode_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_canvas_event_feed_key_up_with_keycode(efl::eolian::to_c(keyname_), efl::eolian::to_c(key_), efl::eolian::to_c(string_), efl::eolian::to_c(compose_), timestamp_, data_, keycode_));
      }

   };
};


template<>
struct operation_description_class_size< evas::canvas >
{
   static const int value = 104;
};

template <typename T>
int initialize_operation_description(efl::eo::detail::tag<evas::canvas>
                                 , Eo_Op_Description* ops)
{
   (void)ops;
   ops[0].func = reinterpret_cast<void*>(& ::evas_canvas_event_thaw_wrapper<T>);
   ops[0].api_func = reinterpret_cast<void*>(& ::eo_event_thaw);
   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_canvas_event_freeze_wrapper<T>);
   ops[1].api_func = reinterpret_cast<void*>(& ::eo_event_freeze);
   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_canvas_evas_get_wrapper<T>);
   ops[2].api_func = reinterpret_cast<void*>(& ::evas_common_evas_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_canvas_output_framespace_get_wrapper<T>);
   ops[3].api_func = reinterpret_cast<void*>(& ::evas_canvas_output_framespace_get);
   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_canvas_output_framespace_set_wrapper<T>);
   ops[4].api_func = reinterpret_cast<void*>(& ::evas_canvas_output_framespace_set);
   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_canvas_output_viewport_get_wrapper<T>);
   ops[5].api_func = reinterpret_cast<void*>(& ::evas_canvas_output_viewport_get);
   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_canvas_output_viewport_set_wrapper<T>);
   ops[6].api_func = reinterpret_cast<void*>(& ::evas_canvas_output_viewport_set);
   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_canvas_image_cache_get_wrapper<T>);
   ops[7].api_func = reinterpret_cast<void*>(& ::evas_canvas_image_cache_get);
   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_canvas_image_cache_set_wrapper<T>);
   ops[8].api_func = reinterpret_cast<void*>(& ::evas_canvas_image_cache_set);
   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_canvas_event_default_flags_get_wrapper<T>);
   ops[9].api_func = reinterpret_cast<void*>(& ::evas_canvas_event_default_flags_get);
   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_canvas_event_default_flags_set_wrapper<T>);
   ops[10].api_func = reinterpret_cast<void*>(& ::evas_canvas_event_default_flags_set);
   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_canvas_output_method_get_wrapper<T>);
   ops[11].api_func = reinterpret_cast<void*>(& ::evas_canvas_output_method_get);
   ops[11].op = EO_OP_OVERRIDE;
   ops[11].op_type = EO_OP_TYPE_REGULAR;
   ops[11].doc = NULL;

   ops[12].func = reinterpret_cast<void*>(& ::evas_canvas_output_method_set_wrapper<T>);
   ops[12].api_func = reinterpret_cast<void*>(& ::evas_canvas_output_method_set);
   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_canvas_font_cache_get_wrapper<T>);
   ops[13].api_func = reinterpret_cast<void*>(& ::evas_canvas_font_cache_get);
   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_canvas_font_cache_set_wrapper<T>);
   ops[14].api_func = reinterpret_cast<void*>(& ::evas_canvas_font_cache_set);
   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_canvas_output_size_get_wrapper<T>);
   ops[15].api_func = reinterpret_cast<void*>(& ::evas_canvas_output_size_get);
   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_canvas_output_size_set_wrapper<T>);
   ops[16].api_func = reinterpret_cast<void*>(& ::evas_canvas_output_size_set);
   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_canvas_data_attach_get_wrapper<T>);
   ops[17].api_func = reinterpret_cast<void*>(& ::evas_canvas_data_attach_get);
   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_canvas_data_attach_set_wrapper<T>);
   ops[18].api_func = reinterpret_cast<void*>(& ::evas_canvas_data_attach_set);
   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_canvas_font_hinting_get_wrapper<T>);
   ops[19].api_func = reinterpret_cast<void*>(& ::evas_canvas_font_hinting_get);
   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_canvas_font_hinting_set_wrapper<T>);
   ops[20].api_func = reinterpret_cast<void*>(& ::evas_canvas_font_hinting_set);
   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_canvas_engine_info_get_wrapper<T>);
   ops[21].api_func = reinterpret_cast<void*>(& ::evas_canvas_engine_info_get);
   ops[21].op = EO_OP_OVERRIDE;
   ops[21].op_type = EO_OP_TYPE_REGULAR;
   ops[21].doc = NULL;

   ops[22].func = reinterpret_cast<void*>(& ::evas_canvas_engine_info_set_wrapper<T>);
   ops[22].api_func = reinterpret_cast<void*>(& ::evas_canvas_engine_info_set);
   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_canvas_focus_get_wrapper<T>);
   ops[23].api_func = reinterpret_cast<void*>(& ::evas_canvas_focus_get);
   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_canvas_object_top_get_wrapper<T>);
   ops[24].api_func = reinterpret_cast<void*>(& ::evas_canvas_object_top_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_canvas_key_lock_get_wrapper<T>);
   ops[25].api_func = reinterpret_cast<void*>(& ::evas_canvas_key_lock_get);
   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_canvas_pointer_canvas_xy_get_wrapper<T>);
   ops[26].api_func = reinterpret_cast<void*>(& ::evas_canvas_pointer_canvas_xy_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_canvas_event_down_count_get_wrapper<T>);
   ops[27].api_func = reinterpret_cast<void*>(& ::evas_canvas_event_down_count_get);
   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_canvas_smart_objects_calculate_count_get_wrapper<T>);
   ops[28].api_func = reinterpret_cast<void*>(& ::evas_canvas_smart_objects_calculate_count_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_canvas_focus_state_get_wrapper<T>);
   ops[29].api_func = reinterpret_cast<void*>(& ::evas_canvas_focus_state_get);
   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_canvas_changed_get_wrapper<T>);
   ops[30].api_func = reinterpret_cast<void*>(& ::evas_canvas_changed_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_canvas_pointer_output_xy_get_wrapper<T>);
   ops[31].api_func = reinterpret_cast<void*>(& ::evas_canvas_pointer_output_xy_get);
   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_canvas_pointer_inside_get_wrapper<T>);
   ops[32].api_func = reinterpret_cast<void*>(& ::evas_canvas_pointer_inside_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_canvas_image_max_size_get_wrapper<T>);
   ops[33].api_func = reinterpret_cast<void*>(& ::evas_canvas_image_max_size_get);
   ops[33].op = EO_OP_OVERRIDE;
   ops[33].op_type = EO_OP_TYPE_REGULAR;
   ops[33].doc = NULL;

   ops[34].func = reinterpret_cast<void*>(& ::evas_canvas_object_bottom_get_wrapper<T>);
   ops[34].api_func = reinterpret_cast<void*>(& ::evas_canvas_object_bottom_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_canvas_key_modifier_get_wrapper<T>);
   ops[35].api_func = reinterpret_cast<void*>(& ::evas_canvas_key_modifier_get);
   ops[35].op = EO_OP_OVERRIDE;
   ops[35].op_type = EO_OP_TYPE_REGULAR;
   ops[35].doc = NULL;

   ops[36].func = reinterpret_cast<void*>(& ::evas_canvas_pointer_button_down_mask_get_wrapper<T>);
   ops[36].api_func = reinterpret_cast<void*>(& ::evas_canvas_pointer_button_down_mask_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_canvas_tree_objects_at_xy_get_wrapper<T>);
   ops[37].api_func = reinterpret_cast<void*>(& ::evas_canvas_tree_objects_at_xy_get);
   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_canvas_event_feed_mouse_wheel_wrapper<T>);
   ops[38].api_func = reinterpret_cast<void*>(& ::evas_canvas_event_feed_mouse_wheel);
   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_canvas_key_lock_on_wrapper<T>);
   ops[39].api_func = reinterpret_cast<void*>(& ::evas_canvas_key_lock_on);
   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_canvas_event_feed_key_down_wrapper<T>);
   ops[40].api_func = reinterpret_cast<void*>(& ::evas_canvas_event_feed_key_down);
   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_canvas_key_modifier_mask_get_wrapper<T>);
   ops[41].api_func = reinterpret_cast<void*>(& ::evas_canvas_key_modifier_mask_get);
   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_canvas_key_modifier_add_wrapper<T>);
   ops[42].api_func = reinterpret_cast<void*>(& ::evas_canvas_key_modifier_add);
   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_canvas_key_modifier_off_wrapper<T>);
   ops[43].api_func = reinterpret_cast<void*>(& ::evas_canvas_key_modifier_off);
   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_canvas_event_feed_hold_wrapper<T>);
   ops[44].api_func = reinterpret_cast<void*>(& ::evas_canvas_event_feed_hold);
   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_canvas_event_feed_mouse_move_wrapper<T>);
   ops[45].api_func = reinterpret_cast<void*>(& ::evas_canvas_event_feed_mouse_move);
   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_canvas_event_feed_key_up_wrapper<T>);
   ops[46].api_func = reinterpret_cast<void*>(& ::evas_canvas_event_feed_key_up);
   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_canvas_event_feed_mouse_out_wrapper<T>);
   ops[47].api_func = reinterpret_cast<void*>(& ::evas_canvas_event_feed_mouse_out);
   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_canvas_event_input_multi_move_wrapper<T>);
   ops[48].api_func = reinterpret_cast<void*>(& ::evas_canvas_event_input_multi_move);
   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_canvas_objects_at_xy_get_wrapper<T>);
   ops[49].api_func = reinterpret_cast<void*>(& ::evas_canvas_objects_at_xy_get);
   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_canvas_event_input_multi_up_wrapper<T>);
   ops[50].api_func = reinterpret_cast<void*>(& ::evas_canvas_event_input_multi_up);
   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_canvas_event_feed_multi_down_wrapper<T>);
   ops[51].api_func = reinterpret_cast<void*>(& ::evas_canvas_event_feed_multi_down);
   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_canvas_render_async_wrapper<T>);
   ops[52].api_func = reinterpret_cast<void*>(& ::evas_canvas_render_async);
   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_canvas_focus_out_wrapper<T>);
   ops[53].api_func = reinterpret_cast<void*>(& ::evas_canvas_focus_out);
   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_canvas_event_input_mouse_move_wrapper<T>);
   ops[54].api_func = reinterpret_cast<void*>(& ::evas_canvas_event_input_mouse_move);
   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_canvas_norender_wrapper<T>);
   ops[55].api_func = reinterpret_cast<void*>(& ::evas_canvas_norender);
   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_canvas_touch_point_list_count_wrapper<T>);
   ops[56].api_func = reinterpret_cast<void*>(& ::evas_canvas_touch_point_list_count);
   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_canvas_event_input_multi_down_wrapper<T>);
   ops[57].api_func = reinterpret_cast<void*>(& ::evas_canvas_event_input_multi_down);
   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_canvas_nochange_pop_wrapper<T>);
   ops[58].api_func = reinterpret_cast<void*>(& ::evas_canvas_nochange_pop);
   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_canvas_key_lock_off_wrapper<T>);
   ops[59].api_func = reinterpret_cast<void*>(& ::evas_canvas_key_lock_off);
   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_canvas_nochange_push_wrapper<T>);
   ops[60].api_func = reinterpret_cast<void*>(& ::evas_canvas_nochange_push);
   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_canvas_font_cache_flush_wrapper<T>);
   ops[61].api_func = reinterpret_cast<void*>(& ::evas_canvas_font_cache_flush);
   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_canvas_font_hinting_can_hint_wrapper<T>);
   ops[62].api_func = reinterpret_cast<void*>(& ::evas_canvas_font_hinting_can_hint);
   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_canvas_object_top_at_xy_get_wrapper<T>);
   ops[63].api_func = reinterpret_cast<void*>(& ::evas_canvas_object_top_at_xy_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_canvas_key_modifier_on_wrapper<T>);
   ops[64].api_func = reinterpret_cast<void*>(& ::evas_canvas_key_modifier_on);
   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_canvas_event_feed_mouse_up_wrapper<T>);
   ops[65].api_func = reinterpret_cast<void*>(& ::evas_canvas_event_feed_mouse_up);
   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_canvas_event_feed_mouse_down_wrapper<T>);
   ops[66].api_func = reinterpret_cast<void*>(& ::evas_canvas_event_feed_mouse_down);
   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_canvas_event_refeed_event_wrapper<T>);
   ops[67].api_func = reinterpret_cast<void*>(& ::evas_canvas_event_refeed_event);
   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_canvas_font_available_list_wrapper<T>);
   ops[68].api_func = reinterpret_cast<void*>(& ::evas_canvas_font_available_list);
   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_canvas_objects_in_rectangle_get_wrapper<T>);
   ops[69].api_func = reinterpret_cast<void*>(& ::evas_canvas_objects_in_rectangle_get);
   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_canvas_object_name_find_wrapper<T>);
   ops[70].api_func = reinterpret_cast<void*>(& ::evas_canvas_object_name_find);
   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_canvas_font_path_append_wrapper<T>);
   ops[71].api_func = reinterpret_cast<void*>(& ::evas_canvas_font_path_append);
   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_canvas_touch_point_list_nth_id_get_wrapper<T>);
   ops[72].api_func = reinterpret_cast<void*>(& ::evas_canvas_touch_point_list_nth_id_get);
   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_canvas_font_path_clear_wrapper<T>);
   ops[73].api_func = reinterpret_cast<void*>(& ::evas_canvas_font_path_clear);
   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_canvas_smart_objects_calculate_wrapper<T>);
   ops[74].api_func = reinterpret_cast<void*>(& ::evas_canvas_smart_objects_calculate);
   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_canvas_touch_point_list_nth_xy_get_wrapper<T>);
   ops[75].api_func = reinterpret_cast<void*>(& ::evas_canvas_touch_point_list_nth_xy_get);
   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_canvas_key_lock_del_wrapper<T>);
   ops[76].api_func = reinterpret_cast<void*>(& ::evas_canvas_key_lock_del);
   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_canvas_damage_rectangle_add_wrapper<T>);
   ops[77].api_func = reinterpret_cast<void*>(& ::evas_canvas_damage_rectangle_add);
   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_canvas_sync_wrapper<T>);
   ops[78].api_func = reinterpret_cast<void*>(& ::evas_canvas_sync);
   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_canvas_font_path_list_wrapper<T>);
   ops[79].api_func = reinterpret_cast<void*>(& ::evas_canvas_font_path_list);
   ops[79].op = EO_OP_OVERRIDE;
   ops[79].op_type = EO_OP_TYPE_REGULAR;
   ops[79].doc = NULL;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      void output_framespace_get(Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_output_framespace_get(x_, y_, w_, h_));
      }

      void output_framespace_set(Evas_Coord x_, Evas_Coord y_, Evas_Coord w_, Evas_Coord h_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_output_framespace_set(x_, y_, w_, h_));
      }

      void output_viewport_get(Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_output_viewport_get(x_, y_, w_, h_));
      }

      void output_viewport_set(Evas_Coord x_, Evas_Coord y_, Evas_Coord w_, Evas_Coord h_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_output_viewport_set(x_, y_, w_, h_));
      }

      int image_cache_get()
      {
         int _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_canvas_image_cache_get());
            return _tmp_ret;
      }

      void image_cache_set(int size_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_image_cache_set(size_));
      }

      Evas_Event_Flags event_default_flags_get()
      {
         Evas_Event_Flags _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_canvas_event_default_flags_get());
            return _tmp_ret;
      }

      void event_default_flags_set(Evas_Event_Flags flags_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_event_default_flags_set(flags_));
      }

      int output_method_get()
      {
         int _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_canvas_output_method_get());
            return _tmp_ret;
      }

      void output_method_set(int render_method_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_output_method_set(render_method_));
      }

      int font_cache_get()
      {
         int _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_canvas_font_cache_get());
            return _tmp_ret;
      }

      void font_cache_set(int size_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_font_cache_set(size_));
      }

      void output_size_get(int* w_, int* h_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_output_size_get(w_, h_));
      }

      void output_size_set(int w_, int h_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_output_size_set(w_, h_));
      }

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

      void data_attach_set(void * data_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_data_attach_set(data_));
      }

      Evas_Font_Hinting_Flags font_hinting_get()
      {
         Evas_Font_Hinting_Flags _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_canvas_font_hinting_get());
            return _tmp_ret;
      }

      void font_hinting_set(Evas_Font_Hinting_Flags hinting_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_font_hinting_set(hinting_));
      }

      Evas_Engine_Info * engine_info_get()
      {
         Evas_Engine_Info * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_canvas_engine_info_get());
            return _tmp_ret;
      }

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

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

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

      const Evas_Lock * key_lock_get()
      {
         const Evas_Lock * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_canvas_key_lock_get());
            return _tmp_ret;
      }

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

      int event_down_count_get()
      {
         int _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_canvas_event_down_count_get());
            return _tmp_ret;
      }

      int smart_objects_calculate_count_get()
      {
         int _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_canvas_smart_objects_calculate_count_get());
            return _tmp_ret;
      }

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

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

      void pointer_output_xy_get(int* x_, int* y_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_pointer_output_xy_get(x_, y_));
      }

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

      bool image_max_size_get(int* maxw_, int* maxh_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_canvas_image_max_size_get(maxw_, maxh_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

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

      const Evas_Modifier * key_modifier_get()
      {
         const Evas_Modifier * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_canvas_key_modifier_get());
            return _tmp_ret;
      }

      int pointer_button_down_mask_get()
      {
         int _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_canvas_pointer_button_down_mask_get());
            return _tmp_ret;
      }

      efl::eina::range_list< evas::object > tree_objects_at_xy_get(evas::object stop_, int x_, int y_)
      {
         Eina_List * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_canvas_tree_objects_at_xy_get(efl::eolian::to_c(stop_), x_, y_));
            return efl::eolian::to_cxx<efl::eina::range_list< evas::object >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
      }

      void event_feed_mouse_wheel(int direction_, int z_, unsigned int timestamp_, const void * data_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_event_feed_mouse_wheel(direction_, z_, timestamp_, data_));
      }

      void key_lock_on(std::string keyname_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_key_lock_on(efl::eolian::to_c(keyname_)));
      }

      void event_feed_key_down(std::string keyname_, std::string key_, std::string string_, std::string compose_, unsigned int timestamp_, const void * data_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_event_feed_key_down(efl::eolian::to_c(keyname_), efl::eolian::to_c(key_), efl::eolian::to_c(string_), efl::eolian::to_c(compose_), timestamp_, data_));
      }

      Evas_Modifier_Mask key_modifier_mask_get(std::string keyname_)
      {
         Evas_Modifier_Mask _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_canvas_key_modifier_mask_get(efl::eolian::to_c(keyname_)));
            return _tmp_ret;
      }

      void key_modifier_add(std::string keyname_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_key_modifier_add(efl::eolian::to_c(keyname_)));
      }

      void key_modifier_off(std::string keyname_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_key_modifier_off(efl::eolian::to_c(keyname_)));
      }

      void event_feed_hold(int hold_, unsigned int timestamp_, const void * data_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_event_feed_hold(hold_, timestamp_, data_));
      }

      void event_feed_mouse_move(int x_, int y_, unsigned int timestamp_, const void * data_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_event_feed_mouse_move(x_, y_, timestamp_, data_));
      }

      void event_feed_key_up(std::string keyname_, std::string key_, std::string string_, std::string compose_, unsigned int timestamp_, const void * data_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_event_feed_key_up(efl::eolian::to_c(keyname_), efl::eolian::to_c(key_), efl::eolian::to_c(string_), efl::eolian::to_c(compose_), timestamp_, data_));
      }

      void event_feed_mouse_out(unsigned int timestamp_, const void * data_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_event_feed_mouse_out(timestamp_, data_));
      }

      void event_input_multi_move(int d_, int x_, int y_, double rad_, double radx_, double rady_, double pres_, double ang_, double fx_, double fy_, unsigned int timestamp_, const void * data_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_event_input_multi_move(d_, x_, y_, rad_, radx_, rady_, pres_, ang_, fx_, fy_, timestamp_, data_));
      }

      efl::eina::range_list< evas::object > objects_at_xy_get(Evas_Coord x_, Evas_Coord y_, bool include_pass_events_objects_, bool include_hidden_objects_)
      {
         Eina_List * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_canvas_objects_at_xy_get(x_, y_, efl::eolian::to_c(include_pass_events_objects_), efl::eolian::to_c(include_hidden_objects_)));
            return efl::eolian::to_cxx<efl::eina::range_list< evas::object >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
      }

      void event_input_multi_up(int d_, int x_, int y_, double rad_, double radx_, double rady_, double pres_, double ang_, double fx_, double fy_, Evas_Button_Flags flags_, unsigned int timestamp_, const void * data_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_event_input_multi_up(d_, x_, y_, rad_, radx_, rady_, pres_, ang_, fx_, fy_, flags_, timestamp_, data_));
      }

      void event_feed_multi_down(int d_, int x_, int y_, double rad_, double radx_, double rady_, double pres_, double ang_, double fx_, double fy_, Evas_Button_Flags flags_, unsigned int timestamp_, const void * data_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_event_feed_multi_down(d_, x_, y_, rad_, radx_, rady_, pres_, ang_, fx_, fy_, flags_, timestamp_, data_));
      }

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

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

      void event_input_mouse_move(int x_, int y_, unsigned int timestamp_, const void * data_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_event_input_mouse_move(x_, y_, timestamp_, data_));
      }

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

      unsigned int touch_point_list_count()
      {
         unsigned int _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_canvas_touch_point_list_count());
            return _tmp_ret;
      }

      void event_input_multi_down(int d_, int x_, int y_, double rad_, double radx_, double rady_, double pres_, double ang_, double fx_, double fy_, Evas_Button_Flags flags_, unsigned int timestamp_, const void * data_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_event_input_multi_down(d_, x_, y_, rad_, radx_, rady_, pres_, ang_, fx_, fy_, flags_, timestamp_, data_));
      }

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

      void key_lock_off(std::string keyname_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_key_lock_off(efl::eolian::to_c(keyname_)));
      }

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

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

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

      evas::object object_top_at_xy_get(Evas_Coord x_, Evas_Coord y_, bool include_pass_events_objects_, bool include_hidden_objects_)
      {
         Evas_Object * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_canvas_object_top_at_xy_get(x_, y_, efl::eolian::to_c(include_pass_events_objects_), efl::eolian::to_c(include_hidden_objects_)));
            return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }

      void key_modifier_on(std::string keyname_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_key_modifier_on(efl::eolian::to_c(keyname_)));
      }

      void event_feed_mouse_up(int b_, Evas_Button_Flags flags_, unsigned int timestamp_, const void * data_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_event_feed_mouse_up(b_, flags_, timestamp_, data_));
      }

      void event_feed_mouse_down(int b_, Evas_Button_Flags flags_, unsigned int timestamp_, const void * data_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_event_feed_mouse_down(b_, flags_, timestamp_, data_));
      }

      void event_refeed_event(void * event_copy_, Evas_Callback_Type event_type_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_event_refeed_event(event_copy_, event_type_));
      }

      efl::eina::range_list< std::string > font_available_list()
      {
         Eina_List * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_canvas_font_available_list());
            return efl::eolian::to_cxx<efl::eina::range_list< std::string >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
      }

      efl::eina::range_list< evas::object > objects_in_rectangle_get(Evas_Coord x_, Evas_Coord y_, Evas_Coord w_, Evas_Coord h_, bool include_pass_events_objects_, bool include_hidden_objects_)
      {
         Eina_List * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_canvas_objects_in_rectangle_get(x_, y_, w_, h_, efl::eolian::to_c(include_pass_events_objects_), efl::eolian::to_c(include_hidden_objects_)));
            return efl::eolian::to_cxx<efl::eina::range_list< evas::object >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
      }

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

      void font_path_append(std::string path_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_font_path_append(efl::eolian::to_c(path_)));
      }

      int touch_point_list_nth_id_get(unsigned int n_)
      {
         int _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_canvas_touch_point_list_nth_id_get(n_));
            return _tmp_ret;
      }

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

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

      void touch_point_list_nth_xy_get(unsigned int n_, Evas_Coord* x_, Evas_Coord* y_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_touch_point_list_nth_xy_get(n_, x_, y_));
      }

      void key_lock_del(std::string keyname_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_key_lock_del(efl::eolian::to_c(keyname_)));
      }

      void damage_rectangle_add(int x_, int y_, int w_, int h_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_damage_rectangle_add(x_, y_, w_, h_));
      }

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

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

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

      int coord_world_x_to_screen(Evas_Coord x_)
      {
         int _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_canvas_coord_world_x_to_screen(x_));
            return _tmp_ret;
      }

      void event_feed_multi_move(int d_, int x_, int y_, double rad_, double radx_, double rady_, double pres_, double ang_, double fx_, double fy_, unsigned int timestamp_, const void * data_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_event_feed_multi_move(d_, x_, y_, rad_, radx_, rady_, pres_, ang_, fx_, fy_, timestamp_, data_));
      }

      efl::eina::list< Eina_Rectangle * > render_updates()
      {
         Eina_List * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_canvas_render_updates());
            return efl::eolian::to_cxx<efl::eina::list< Eina_Rectangle * >>(_tmp_ret, std::tuple<std::true_type, std::false_type>());
      }

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

      Evas_Coord coord_screen_y_to_world(int y_)
      {
         Evas_Coord _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_canvas_coord_screen_y_to_world(y_));
            return _tmp_ret;
      }

      void key_modifier_del(std::string keyname_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_key_modifier_del(efl::eolian::to_c(keyname_)));
      }

      Evas_Touch_Point_State touch_point_list_nth_state_get(unsigned int n_)
      {
         Evas_Touch_Point_State _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_canvas_touch_point_list_nth_state_get(n_));
            return _tmp_ret;
      }

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

      void obscured_rectangle_add(int x_, int y_, int w_, int h_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_obscured_rectangle_add(x_, y_, w_, h_));
      }

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

      void event_feed_mouse_in(unsigned int timestamp_, const void * data_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_event_feed_mouse_in(timestamp_, data_));
      }

      evas::object object_top_in_rectangle_get(Evas_Coord x_, Evas_Coord y_, Evas_Coord w_, Evas_Coord h_, bool include_pass_events_objects_, bool include_hidden_objects_)
      {
         Evas_Object * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_canvas_object_top_in_rectangle_get(x_, y_, w_, h_, efl::eolian::to_c(include_pass_events_objects_), efl::eolian::to_c(include_hidden_objects_)));
            return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }

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

      void event_feed_multi_up(int d_, int x_, int y_, double rad_, double radx_, double rady_, double pres_, double ang_, double fx_, double fy_, Evas_Button_Flags flags_, unsigned int timestamp_, const void * data_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_event_feed_multi_up(d_, x_, y_, rad_, radx_, rady_, pres_, ang_, fx_, fy_, flags_, timestamp_, data_));
      }

      void font_path_prepend(std::string path_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_font_path_prepend(efl::eolian::to_c(path_)));
      }

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

      void event_feed_mouse_cancel(unsigned int timestamp_, const void * data_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_event_feed_mouse_cancel(timestamp_, data_));
      }

      Evas_Coord coord_screen_x_to_world(int x_)
      {
         Evas_Coord _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_canvas_coord_screen_x_to_world(x_));
            return _tmp_ret;
      }

      void key_lock_add(std::string keyname_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_key_lock_add(efl::eolian::to_c(keyname_)));
      }

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

      int coord_world_y_to_screen(Evas_Coord y_)
      {
         int _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_canvas_coord_world_y_to_screen(y_));
            return _tmp_ret;
      }

      void event_feed_key_down_with_keycode(std::string keyname_, std::string key_, std::string string_, std::string compose_, unsigned int timestamp_, const void * data_, unsigned int keycode_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_event_feed_key_down_with_keycode(efl::eolian::to_c(keyname_), efl::eolian::to_c(key_), efl::eolian::to_c(string_), efl::eolian::to_c(compose_), timestamp_, data_, keycode_));
      }

      void event_feed_key_up_with_keycode(std::string keyname_, std::string key_, std::string string_, std::string compose_, unsigned int timestamp_, const void * data_, unsigned int keycode_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_canvas_event_feed_key_up_with_keycode(efl::eolian::to_c(keyname_), efl::eolian::to_c(key_), efl::eolian::to_c(string_), efl::eolian::to_c(compose_), timestamp_, data_, keycode_));
      }

   };
};

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

} } }
#endif // EFL_GENERATED_EVAS_CANVAS_HH

