#ifndef EFL_GENERATED_EVAS_IMAGE_HH
#define EFL_GENERATED_EVAS_IMAGE_HH

#include <Eo.hh>

#include <eo_cxx_interop.hh>

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

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

namespace evas { 

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

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

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

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

   ~image() {}

   /// @brief Begin preloading an image object's image data in the background
   ///
   void preload_begin() const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_preload_begin());
   }

   /// @brief Mark a sub-region of the given image object to be redrawn.
   ///
   /// This function schedules a particular rectangular region of an image
   /// object to be updated (redrawn) at the next rendering cycle.
   ///
   /// @param x X-offset of the region to be updated.
   /// @param y Y-offset of the region to be updated.
   /// @param w Width of the region to be updated.
   /// @param h Height of the region to be updated.
   ///
   void data_update_add(int x_, int y_, int w_, int h_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_data_update_add(x_, y_, w_, h_));
   }

   /// @brief Get the duration of a sequence of frames.
   ///
   /// This returns total duration that the specified sequence of frames should
   /// take in seconds.
   ///
   /// If you set start_frame to 1 and frame_num 0, you get frame 1's duration
   /// If you set start_frame to 1 and frame_num 1, you get frame 1's duration +
   /// frame2's duration
   ///
   /// @see evas_object_image_animated_get()
   /// @see evas_object_image_animated_frame_count_get()
   /// @see evas_object_image_animated_loop_type_get()
   /// @see evas_object_image_animated_loop_count_get()
   /// @see evas_object_image_animated_frame_duration_get()
   /// @see evas_object_image_animated_frame_set()
   /// @since 1.1
   ///
   /// @param start_frame The first frame
   /// @param frame_num Number of frames in the sequence
   ///
   double animated_frame_duration_get(int start_frame_, int frame_num_) const
   {
      double _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_image_animated_frame_duration_get(start_frame_, frame_num_));
      return _tmp_ret;
   }

   /// @brief Save the given image object's contents to an (image) file.
   ///
   /// The extension suffix on @p file will determine which <b>saver
   /// module</b> Evas is to use when saving, thus the final file's
   /// format. If the file supports multiple data stored in it (Eet ones),
   /// you can specify the key to be used as the index of the image in it.
   ///
   /// You can specify some flags when saving the image.  Currently
   /// acceptable flags are @c quality and @c compress. Eg.: @c
   /// "quality=100 compress=9"
   ///
   /// @param file The filename to be used to save the image (extension
   /// obligatory).
   /// @param key The image key in the file (if an Eet one), or @c NULL,
   /// otherwise.
   /// @param flags String containing the flags to be used (@c NULL for
   /// none).
   ///
   bool save(std::string file_, std::string key_, std::string flags_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_image_save(efl::eolian::to_c(file_), efl::eolian::to_c(key_), efl::eolian::to_c(flags_)));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Sets the raw image data of the given image object.
   ///
   /// Note that the raw data must be of the same size (see
   /// evas_object_image_size_set(), which has to be called @b before this
   /// one) and colorspace (see evas_object_image_colorspace_set()) of the
   /// image. If data is @c NULL, the current image data will be
   /// freed. Naturally, if one does not set an image object's data
   /// manually, it will still have one, allocated by Evas.
   ///
   /// @see evas_object_image_data_get()
   ///
   /// @param data The raw data, or @c NULL.
   ///
   void data_set(void * data_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_data_set(data_));
   }

   /// @brief Get a pointer to the raw image data of the given image object.
   ///
   /// @return The raw image data.
   ///
   /// This function returns a pointer to an image object's internal pixel
   /// buffer, for reading only or read/write. If you request it for
   /// writing, the image will be marked dirty so that it gets redrawn at
   /// the next update.
   ///
   /// Each time you call this function on an image object, its data
   /// buffer will have an internal reference counter
   /// incremented. Decrement it back by using
   /// evas_object_image_data_set().
   ///
   /// This is best suited for when you want to modify an existing image,
   /// without changing its dimensions.
   ///
   /// @note The contents' format returned by it depend on the color
   /// space of the given image object.
   ///
   /// @note You may want to use evas_object_image_data_update_add() to
   /// inform data changes, if you did any.
   ///
   /// @see evas_object_image_data_set()
   ///
   /// @param for_writing Whether the data being retrieved will be
   /// modified (@c EINA_TRUE) or not (@c EINA_FALSE).
   ///
   void * data_get(bool for_writing_) const
   {
      void * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_image_data_get(efl::eolian::to_c(for_writing_)));
      return _tmp_ret;
   }

   /// @brief Cancel preloading an image object's image data in the background
   ///
   void preload_cancel() const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_preload_cancel());
   }

   /// @brief Converts the raw image data of the given image object to the
   /// specified colorspace.
   ///
   /// Note that this function does not modify the raw image data.  If the
   /// requested colorspace is the same as the image colorspace nothing is
   /// done and @c NULL is returned. You should use
   /// evas_object_image_colorspace_get() to check the current image
   /// colorspace.
   ///
   /// See @ref evas_object_image_colorspace_get.
   ///
   /// @return data A newly allocated data in the format specified by to_cspace.
   ///
   /// @param to_cspace The colorspace to which the image raw data will be converted.
   ///
   void * data_convert(Evas_Colorspace to_cspace_) const
   {
      void * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_image_data_convert(to_cspace_));
      return _tmp_ret;
   }

   /// @brief Import pixels from given source to a given canvas image object.
   ///
   /// This function imports pixels from a given source to a given canvas image.
   ///
   /// @param pixels The pixel's source to be imported.
   ///
   bool pixels_import(Evas_Pixel_Import_Source * pixels_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_image_pixels_import(pixels_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Reload an image object's image data.
   ///
   /// This function reloads the image data bound to image object @p obj.
   ///
   void reload() const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_reload());
   }

   /// @param dpi The new DPI resolution.
   ///
   double load_dpi_get() const
   {
      double _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_image_load_dpi_get());
      return _tmp_ret;
   }

   /// @param dpi The new DPI resolution.
   ///
   void load_dpi_set(double dpi_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_load_dpi_set(dpi_));
   }

   /// @param source_clip whether @p obj is clipped by the source clipper.
   /// (@c EINA_TRUE) or not (@c EINA_FALSE)
   ///
   bool source_clip_get() const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_image_source_clip_get());
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @param source_clip whether @p obj is clipped by the source clipper.
   /// (@c EINA_TRUE) or not (@c EINA_FALSE)
   ///
   void source_clip_set(bool source_clip_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_source_clip_set(efl::eolian::to_c(source_clip_)));
   }

   /// @param src Source object to use for the proxy.
   ///
   evas::object source_get() const
   {
      Evas_Object * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_image_source_get());
      return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @param src Source object to use for the proxy.
   ///
   bool source_set(evas::object src_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_image_source_set(efl::eolian::to_c(src_)));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @param filled @c EINA_TRUE, to make the fill property follow
   /// object size or @c EINA_FALSE, otherwise.
   ///
   bool filled_get() const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_image_filled_get());
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @param filled @c EINA_TRUE, to make the fill property follow
   /// object size or @c EINA_FALSE, otherwise.
   ///
   void filled_set(bool filled_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_filled_set(efl::eolian::to_c(filled_)));
   }

   /// @param hint The content hint value, one of the
   /// #Evas_Image_Content_Hint ones.
   ///
   Evas_Image_Content_Hint content_hint_get() const
   {
      Evas_Image_Content_Hint _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_image_content_hint_get());
      return _tmp_ret;
   }

   /// @param hint The content hint value, one of the
   /// #Evas_Image_Content_Hint ones.
   ///
   void content_hint_set(Evas_Image_Content_Hint hint_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_content_hint_set(hint_));
   }

   /// @param x X-offset of the region to be loaded.
   /// @param y Y-offset of the region to be loaded.
   /// @param w Width of the region to be loaded.
   /// @param h Height of the region to be loaded.
   ///
   void load_region_get(int* x_, int* y_, int* w_, int* h_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_load_region_get(x_, y_, w_, h_));
   }

   /// @param x X-offset of the region to be loaded.
   /// @param y Y-offset of the region to be loaded.
   /// @param w Width of the region to be loaded.
   /// @param h Height of the region to be loaded.
   ///
   void load_region_set(int x_, int y_, int w_, int h_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_load_region_set(x_, y_, w_, h_));
   }

   /// @param alpha Whether to use alpha channel (@c EINA_TRUE) data
   /// or not (@c EINA_FALSE).
   ///
   bool alpha_get() const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_image_alpha_get());
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @param alpha Whether to use alpha channel (@c EINA_TRUE) data
   /// or not (@c EINA_FALSE).
   ///
   void alpha_set(bool alpha_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_alpha_set(efl::eolian::to_c(alpha_)));
   }

   /// @param w The new width of the image's load size.
   /// @param h The new height of the image's load size.
   ///
   void load_size_get(int* w_, int* h_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_load_size_get(w_, h_));
   }

   /// @param w The new width of the image's load size.
   /// @param h The new height of the image's load size.
   ///
   void load_size_set(int w_, int h_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_load_size_set(w_, h_));
   }

   /// @param l The border's left width.
   /// @param r The border's right width.
   /// @param t The border's top width.
   /// @param b The border's bottom width.
   ///
   void border_get(int* l_, int* r_, int* t_, int* b_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_border_get(l_, r_, t_, b_));
   }

   /// @param l The border's left width.
   /// @param r The border's right width.
   /// @param t The border's top width.
   /// @param b The border's bottom width.
   ///
   void border_set(int l_, int r_, int t_, int b_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_border_set(l_, r_, t_, b_));
   }

   /// @param smooth_scale Whether to use smooth scale or not.
   ///
   bool smooth_scale_get() const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_image_smooth_scale_get());
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @param smooth_scale Whether to use smooth scale or not.
   ///
   void smooth_scale_set(bool smooth_scale_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_smooth_scale_set(efl::eolian::to_c(smooth_scale_)));
   }

   /// @param scale The scale factor (default is @c 1.0 - i.e. no scaling)
   ///
   double border_scale_get() const
   {
      double _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_image_border_scale_get());
      return _tmp_ret;
   }

   /// @param scale The scale factor (default is @c 1.0 - i.e. no scaling)
   ///
   void border_scale_set(double scale_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_border_scale_set(scale_));
   }

   /// @param dirty Whether the image is dirty.
   ///
   bool pixels_dirty_get() const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_image_pixels_dirty_get());
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @param dirty Whether the image is dirty.
   ///
   void pixels_dirty_set(bool dirty_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_pixels_dirty_set(efl::eolian::to_c(dirty_)));
   }

   /// @param surf The new video surface.
   /// @since 1.1
   ///
   const Evas_Video_Surface * video_surface_get() const
   {
      const Evas_Video_Surface * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_image_video_surface_get());
      return _tmp_ret;
   }

   /// @param surf The new video surface.
   /// @since 1.1
   ///
   void video_surface_set(Evas_Video_Surface * surf_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_video_surface_set(surf_));
   }

   /// @param caps in
   ///
   unsigned int video_surface_caps_get() const
   {
      unsigned int _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_image_video_surface_caps_get());
      return _tmp_ret;
   }

   /// @param caps in
   ///
   void video_surface_caps_set(unsigned int caps_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_video_surface_caps_set(caps_));
   }

   /// @param enable @c EINA_TRUE means that it should honor the orientation information
   ///
   bool load_orientation_get() const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_image_load_orientation_get());
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @param enable @c EINA_TRUE means that it should honor the orientation information
   ///
   void load_orientation_set(bool enable_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_load_orientation_set(efl::eolian::to_c(enable_)));
   }

   /// @param spread One of EVAS_TEXTURE_REFLECT, EVAS_TEXTURE_REPEAT,
   ///
   Evas_Fill_Spread fill_spread_get() const
   {
      Evas_Fill_Spread _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_image_fill_spread_get());
      return _tmp_ret;
   }

   /// @param spread One of EVAS_TEXTURE_REFLECT, EVAS_TEXTURE_REPEAT,
   ///
   void fill_spread_set(Evas_Fill_Spread spread_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_fill_spread_set(spread_));
   }

   /// @param file The image file path.
   /// @param key The image key in @p file (if its an Eet one), or @c
   /// NULL, otherwise.
   ///
   void file_get(const char ** file_, const char ** key_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_file_get(file_, key_));
   }

   /// @param file The image file path.
   /// @param key The image key in @p file (if its an Eet one), or @c
   /// NULL, otherwise.
   ///
   void file_set(std::string file_, std::string key_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_file_set(efl::eolian::to_c(file_), efl::eolian::to_c(key_)));
   }

   /// @param fill Fill mode of the center region of @p obj (a value in
   /// #Evas_Border_Fill_Mode).
   ///
   Evas_Border_Fill_Mode border_center_fill_get() const
   {
      Evas_Border_Fill_Mode _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_image_border_center_fill_get());
      return _tmp_ret;
   }

   /// @param fill Fill mode of the center region of @p obj (a value in
   /// #Evas_Border_Fill_Mode).
   ///
   void border_center_fill_set(Evas_Border_Fill_Mode fill_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_border_center_fill_set(fill_));
   }

   /// @param w The new width of the image.
   /// @param h The new height of the image.
   ///
   void size_get(int* w_, int* h_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_size_get(w_, h_));
   }

   /// @param w The new width of the image.
   /// @param h The new height of the image.
   ///
   void size_set(int w_, int h_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_size_set(w_, h_));
   }

   /// @param visible @c EINA_TRUE is source object to be shown, @c EINA_FALSE
   /// otherwise.
   ///
   bool source_visible_get() const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_image_source_visible_get());
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @param visible @c EINA_TRUE is source object to be shown, @c EINA_FALSE
   /// otherwise.
   ///
   void source_visible_set(bool visible_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_source_visible_set(efl::eolian::to_c(visible_)));
   }

   /// @param x The x coordinate (from the top left corner of the bound
   /// image) to start drawing from.
   /// @param y The y coordinate (from the top left corner of the bound
   /// image) to start drawing from.
   /// @param w The width the bound image will be displayed at.
   /// @param h The height the bound image will be displayed at.
   ///
   void fill_get(Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_fill_get(x_, y_, w_, h_));
   }

   /// @param x The x coordinate (from the top left corner of the bound
   /// image) to start drawing from.
   /// @param y The y coordinate (from the top left corner of the bound
   /// image) to start drawing from.
   /// @param w The width the bound image will be displayed at.
   /// @param h The height the bound image will be displayed at.
   ///
   void fill_set(Evas_Coord x_, Evas_Coord y_, Evas_Coord w_, Evas_Coord h_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_fill_set(x_, y_, w_, h_));
   }

   /// @param surf The new native surface.
   ///
   Evas_Native_Surface * native_surface_get() const
   {
      Evas_Native_Surface * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_image_native_surface_get());
      return _tmp_ret;
   }

   /// @param surf The new native surface.
   ///
   void native_surface_set(Evas_Native_Surface * surf_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_native_surface_set(surf_));
   }

   /// @param scale_down The scale down factor.
   ///
   int load_scale_down_get() const
   {
      int _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_image_load_scale_down_get());
      return _tmp_ret;
   }

   /// @param scale_down The scale down factor.
   ///
   void load_scale_down_set(int scale_down_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_load_scale_down_set(scale_down_));
   }

   /// @param hint The scale hint, a value in
   /// #Evas_Image_Scale_Hint.
   ///
   Evas_Image_Scale_Hint scale_hint_get() const
   {
      Evas_Image_Scale_Hint _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_image_scale_hint_get());
      return _tmp_ret;
   }

   /// @param hint The scale hint, a value in
   /// #Evas_Image_Scale_Hint.
   ///
   void scale_hint_set(Evas_Image_Scale_Hint hint_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_scale_hint_set(hint_));
   }

   /// @param source whether @p obj is to pass events (@c EINA_TRUE) or not
   /// (@c EINA_FALSE)
   ///
   bool source_events_get() const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_image_source_events_get());
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @param source whether @p obj is to pass events (@c EINA_TRUE) or not
   /// (@c EINA_FALSE)
   ///
   void source_events_set(bool source_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_source_events_set(efl::eolian::to_c(source_)));
   }

   /// @param cspace The new color space.
   ///
   Evas_Colorspace colorspace_get() const
   {
      Evas_Colorspace _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_image_colorspace_get());
      return _tmp_ret;
   }

   /// @param cspace The new color space.
   ///
   void colorspace_set(Evas_Colorspace cspace_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_colorspace_set(cspace_));
   }

   /// @param func The callback function.
   /// @param data The data pointer to be passed to @a func.
   ///
   void pixels_get_callback_set(Evas_Object_Image_Pixels_Get_Cb func_, void * data_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_pixels_get_callback_set(func_, data_));
   }

   /// @param f The mmaped file
   /// @param key The image key in @p file (if its an Eet one), or @c
   /// NULL, otherwise.
   ///
   void mmap_get(const Eina_File ** f_, const char ** key_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_mmap_get(f_, key_));
   }

   /// @param f The mmaped file
   /// @param key The image key in @p file (if its an Eet one), or @c
   /// NULL, otherwise.
   ///
   void mmap_set(const Eina_File * f_, std::string key_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_mmap_set(f_, efl::eolian::to_c(key_)));
   }

   /// @param data The raw data to replace.
   ///
   void data_copy_set(void * data_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_data_copy_set(data_));
   }

   /// @param frame_index The index of current frame
   ///
   void animated_frame_set(int frame_index_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_animated_frame_set(frame_index_));
   }

   bool region_support_get() const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_image_region_support_get());
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   Evas_Load_Error load_error_get() const
   {
      Evas_Load_Error _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_image_load_error_get());
      return _tmp_ret;
   }

   int animated_frame_count_get() const
   {
      int _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_image_animated_frame_count_get());
      return _tmp_ret;
   }

   int stride_get() const
   {
      int _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_image_stride_get());
      return _tmp_ret;
   }

   bool animated_get() const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_image_animated_get());
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   Evas_Image_Animated_Loop_Hint animated_loop_type_get() const
   {
      Evas_Image_Animated_Loop_Hint _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_image_animated_loop_type_get());
      return _tmp_ret;
   }

   int animated_loop_count_get() const
   {
      int _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_image_animated_loop_count_get());
      return _tmp_ret;
   }

   /// @param scene 3D scene on an image object.
   ///
   Evas_3D_Scene * scene_get() const
   {
      Evas_3D_Scene * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_image_scene_get());
      return _tmp_ret;
   }

   /// @param scene 3D scene on an image object.
   ///
   void scene_set(Evas_3D_Scene * scene_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_scene_set(scene_));
   }

   /// @param program The program code, as defined
   /// by the @ref evasfiltersref "Evas filters script language".
   /// Pass NULL to remove the former program and switch back
   /// to the standard text effect
   ///
   /// @since 1.9
   /// @note EXPERIMENTAL FEATURE. This is an unstable API,
   /// please use only for testing purposes.
   /// @see @ref evasfiltersref "Evas filters reference"
   ///
   void filter_program_set(std::string program_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_filter_program_set(efl::eolian::to_c(program_)));
   }

   /// @param name Object name as used in the program code
   /// @param eobj Eo object to use through proxy rendering
   ///
   void filter_source_set(std::string name_, Eo * eobj_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_filter_source_set(efl::eolian::to_c(name_), eobj_));
   }

   /// @param l Left padding in pixels
   /// @param r Right padding in pixels
   /// @param t Top padding in pixels
   /// @param b Bottom padding in pixels
   ///
   /// @return Returns false if the filter is invalid and padding is 0
   bool filter_padding_get(int* l_, int* r_, int* t_, int* b_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_image_filter_padding_get(l_, r_, t_, b_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

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

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

};
} 

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

template <typename T>
void evas_image_data_update_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_)->data_update_add(x_, y_, w_, h_);
}

template <typename T>
double evas_image_animated_frame_duration_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, int start_frame_, int frame_num_)
{
   return static_cast<T*>(self->this_)->animated_frame_duration_get(start_frame_, frame_num_);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template <typename T>
void evas_image_load_region_get_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_)->load_region_get(x_, y_, w_, h_);
}

template <typename T>
void evas_image_load_region_set_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_)->load_region_set(x_, y_, w_, h_);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template <typename T>
void evas_image_video_surface_caps_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, unsigned int caps_)
{
   static_cast<T*>(self->this_)->video_surface_caps_set(caps_);
}

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

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

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

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

template <typename T>
void evas_image_file_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char ** file_, const char ** key_)
{
   static_cast<T*>(self->this_)->file_get(file_, key_);
}

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

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

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

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

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

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

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

template <typename T>
void evas_image_fill_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_)->fill_get(x_, y_, w_, h_);
}

template <typename T>
void evas_image_fill_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_)->fill_set(x_, y_, w_, h_);
}

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

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

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

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

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

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

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

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

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

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

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

template <typename T>
void evas_image_mmap_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const Eina_File ** f_, const char ** key_)
{
   static_cast<T*>(self->this_)->mmap_get(f_, key_);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template <typename T>
bool evas_image_filter_padding_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, int* l_, int* r_, int* t_, int* b_)
{
   return static_cast<T*>(self->this_)->filter_padding_get(l_, r_, t_, b_);
}

namespace efl { namespace eo { namespace detail {

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

      virtual void data_update_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_obj_image_data_update_add(x_, y_, w_, h_));
      }

      virtual double animated_frame_duration_get(int start_frame_, int frame_num_)
      {
         double _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_image_animated_frame_duration_get(start_frame_, frame_num_));
            return _tmp_ret;
      }

      virtual bool save(std::string file_, std::string key_, std::string flags_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_image_save(efl::eolian::to_c(file_), efl::eolian::to_c(key_), efl::eolian::to_c(flags_)));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

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

      virtual void * data_get(bool for_writing_)
      {
         void * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_image_data_get(efl::eolian::to_c(for_writing_)));
            return _tmp_ret;
      }

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

      virtual void * data_convert(Evas_Colorspace to_cspace_)
      {
         void * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_image_data_convert(to_cspace_));
            return _tmp_ret;
      }

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

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

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

      virtual void load_dpi_set(double dpi_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_image_load_dpi_set(dpi_));
      }

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

      virtual void source_clip_set(bool source_clip_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_image_source_clip_set(efl::eolian::to_c(source_clip_)));
      }

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

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

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

      virtual void filled_set(bool filled_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_image_filled_set(efl::eolian::to_c(filled_)));
      }

      virtual Evas_Image_Content_Hint content_hint_get()
      {
         Evas_Image_Content_Hint _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_image_content_hint_get());
            return _tmp_ret;
      }

      virtual void content_hint_set(Evas_Image_Content_Hint hint_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_image_content_hint_set(hint_));
      }

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

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

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

      virtual void alpha_set(bool alpha_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_image_alpha_set(efl::eolian::to_c(alpha_)));
      }

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

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

      virtual void border_get(int* l_, int* r_, int* t_, int* b_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_image_border_get(l_, r_, t_, b_));
      }

      virtual void border_set(int l_, int r_, int t_, int b_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_image_border_set(l_, r_, t_, b_));
      }

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

      virtual void smooth_scale_set(bool smooth_scale_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_image_smooth_scale_set(efl::eolian::to_c(smooth_scale_)));
      }

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

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

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

      virtual void pixels_dirty_set(bool dirty_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_image_pixels_dirty_set(efl::eolian::to_c(dirty_)));
      }

      virtual const Evas_Video_Surface * video_surface_get()
      {
         const Evas_Video_Surface * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_image_video_surface_get());
            return _tmp_ret;
      }

      virtual void video_surface_set(Evas_Video_Surface * surf_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_image_video_surface_set(surf_));
      }

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

      virtual void video_surface_caps_set(unsigned int caps_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_image_video_surface_caps_set(caps_));
      }

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

      virtual void load_orientation_set(bool enable_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_image_load_orientation_set(efl::eolian::to_c(enable_)));
      }

      virtual Evas_Fill_Spread fill_spread_get()
      {
         Evas_Fill_Spread _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_image_fill_spread_get());
            return _tmp_ret;
      }

      virtual void fill_spread_set(Evas_Fill_Spread spread_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_image_fill_spread_set(spread_));
      }

      virtual void file_get(const char ** file_, const char ** key_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_image_file_get(file_, key_));
      }

      virtual void file_set(std::string file_, std::string key_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_image_file_set(efl::eolian::to_c(file_), efl::eolian::to_c(key_)));
      }

      virtual Evas_Border_Fill_Mode border_center_fill_get()
      {
         Evas_Border_Fill_Mode _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_image_border_center_fill_get());
            return _tmp_ret;
      }

      virtual void border_center_fill_set(Evas_Border_Fill_Mode fill_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_image_border_center_fill_set(fill_));
      }

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

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

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

      virtual void source_visible_set(bool visible_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_image_source_visible_set(efl::eolian::to_c(visible_)));
      }

      virtual void fill_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_obj_image_fill_get(x_, y_, w_, h_));
      }

      virtual void fill_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_obj_image_fill_set(x_, y_, w_, h_));
      }

      virtual Evas_Native_Surface * native_surface_get()
      {
         Evas_Native_Surface * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_image_native_surface_get());
            return _tmp_ret;
      }

      virtual void native_surface_set(Evas_Native_Surface * surf_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_image_native_surface_set(surf_));
      }

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

      virtual void load_scale_down_set(int scale_down_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_image_load_scale_down_set(scale_down_));
      }

      virtual Evas_Image_Scale_Hint scale_hint_get()
      {
         Evas_Image_Scale_Hint _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_image_scale_hint_get());
            return _tmp_ret;
      }

      virtual void scale_hint_set(Evas_Image_Scale_Hint hint_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_image_scale_hint_set(hint_));
      }

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

      virtual void source_events_set(bool source_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_image_source_events_set(efl::eolian::to_c(source_)));
      }

      virtual Evas_Colorspace colorspace_get()
      {
         Evas_Colorspace _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_image_colorspace_get());
            return _tmp_ret;
      }

      virtual void colorspace_set(Evas_Colorspace cspace_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_image_colorspace_set(cspace_));
      }

      virtual void pixels_get_callback_set(Evas_Object_Image_Pixels_Get_Cb func_, void * data_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_image_pixels_get_callback_set(func_, data_));
      }

      virtual void mmap_get(const Eina_File ** f_, const char ** key_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_image_mmap_get(f_, key_));
      }

      virtual void mmap_set(const Eina_File * f_, std::string key_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_image_mmap_set(f_, efl::eolian::to_c(key_)));
      }

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

      virtual void animated_frame_set(int frame_index_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_image_animated_frame_set(frame_index_));
      }

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

      virtual Evas_Load_Error load_error_get()
      {
         Evas_Load_Error _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_image_load_error_get());
            return _tmp_ret;
      }

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

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

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

      virtual Evas_Image_Animated_Loop_Hint animated_loop_type_get()
      {
         Evas_Image_Animated_Loop_Hint _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_image_animated_loop_type_get());
            return _tmp_ret;
      }

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

      virtual Evas_3D_Scene * scene_get()
      {
         Evas_3D_Scene * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_image_scene_get());
            return _tmp_ret;
      }

      virtual void scene_set(Evas_3D_Scene * scene_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_image_scene_set(scene_));
      }

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

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

      virtual bool filter_padding_get(int* l_, int* r_, int* t_, int* b_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_image_filter_padding_get(l_, r_, t_, b_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

   };
};


template<>
struct operation_description_class_size< evas::image >
{
   static const int value = 79;
};

template <typename T>
int initialize_operation_description(efl::eo::detail::tag<evas::image>
                                 , Eo_Op_Description* ops)
{
   (void)ops;
   ops[0].func = reinterpret_cast<void*>(& ::evas_image_preload_begin_wrapper<T>);
   ops[0].api_func = reinterpret_cast<void*>(& ::evas_obj_image_preload_begin);
   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_image_data_update_add_wrapper<T>);
   ops[1].api_func = reinterpret_cast<void*>(& ::evas_obj_image_data_update_add);
   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_image_animated_frame_duration_get_wrapper<T>);
   ops[2].api_func = reinterpret_cast<void*>(& ::evas_obj_image_animated_frame_duration_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_image_save_wrapper<T>);
   ops[3].api_func = reinterpret_cast<void*>(& ::evas_obj_image_save);
   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_image_data_set_wrapper<T>);
   ops[4].api_func = reinterpret_cast<void*>(& ::evas_obj_image_data_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_image_data_get_wrapper<T>);
   ops[5].api_func = reinterpret_cast<void*>(& ::evas_obj_image_data_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_image_preload_cancel_wrapper<T>);
   ops[6].api_func = reinterpret_cast<void*>(& ::evas_obj_image_preload_cancel);
   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_image_data_convert_wrapper<T>);
   ops[7].api_func = reinterpret_cast<void*>(& ::evas_obj_image_data_convert);
   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_image_pixels_import_wrapper<T>);
   ops[8].api_func = reinterpret_cast<void*>(& ::evas_obj_image_pixels_import);
   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_image_reload_wrapper<T>);
   ops[9].api_func = reinterpret_cast<void*>(& ::evas_obj_image_reload);
   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_image_load_dpi_get_wrapper<T>);
   ops[10].api_func = reinterpret_cast<void*>(& ::evas_obj_image_load_dpi_get);
   ops[10].op = EO_OP_OVERRIDE;
   ops[10].op_type = EO_OP_TYPE_REGULAR;
   ops[10].doc = NULL;

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

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

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

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

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

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

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

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

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

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

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

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

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

   ops[24].func = reinterpret_cast<void*>(& ::evas_image_load_size_get_wrapper<T>);
   ops[24].api_func = reinterpret_cast<void*>(& ::evas_obj_image_load_size_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_image_load_size_set_wrapper<T>);
   ops[25].api_func = reinterpret_cast<void*>(& ::evas_obj_image_load_size_set);
   ops[25].op = EO_OP_OVERRIDE;
   ops[25].op_type = EO_OP_TYPE_REGULAR;
   ops[25].doc = NULL;

   ops[26].func = reinterpret_cast<void*>(& ::evas_image_border_get_wrapper<T>);
   ops[26].api_func = reinterpret_cast<void*>(& ::evas_obj_image_border_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_image_border_set_wrapper<T>);
   ops[27].api_func = reinterpret_cast<void*>(& ::evas_obj_image_border_set);
   ops[27].op = EO_OP_OVERRIDE;
   ops[27].op_type = EO_OP_TYPE_REGULAR;
   ops[27].doc = NULL;

   ops[28].func = reinterpret_cast<void*>(& ::evas_image_smooth_scale_get_wrapper<T>);
   ops[28].api_func = reinterpret_cast<void*>(& ::evas_obj_image_smooth_scale_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_image_smooth_scale_set_wrapper<T>);
   ops[29].api_func = reinterpret_cast<void*>(& ::evas_obj_image_smooth_scale_set);
   ops[29].op = EO_OP_OVERRIDE;
   ops[29].op_type = EO_OP_TYPE_REGULAR;
   ops[29].doc = NULL;

   ops[30].func = reinterpret_cast<void*>(& ::evas_image_border_scale_get_wrapper<T>);
   ops[30].api_func = reinterpret_cast<void*>(& ::evas_obj_image_border_scale_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_image_border_scale_set_wrapper<T>);
   ops[31].api_func = reinterpret_cast<void*>(& ::evas_obj_image_border_scale_set);
   ops[31].op = EO_OP_OVERRIDE;
   ops[31].op_type = EO_OP_TYPE_REGULAR;
   ops[31].doc = NULL;

   ops[32].func = reinterpret_cast<void*>(& ::evas_image_pixels_dirty_get_wrapper<T>);
   ops[32].api_func = reinterpret_cast<void*>(& ::evas_obj_image_pixels_dirty_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_image_pixels_dirty_set_wrapper<T>);
   ops[33].api_func = reinterpret_cast<void*>(& ::evas_obj_image_pixels_dirty_set);
   ops[33].op = EO_OP_OVERRIDE;
   ops[33].op_type = EO_OP_TYPE_REGULAR;
   ops[33].doc = NULL;

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

   ops[36].func = reinterpret_cast<void*>(& ::evas_image_video_surface_caps_get_wrapper<T>);
   ops[36].api_func = reinterpret_cast<void*>(& ::evas_obj_image_video_surface_caps_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_image_video_surface_caps_set_wrapper<T>);
   ops[37].api_func = reinterpret_cast<void*>(& ::evas_obj_image_video_surface_caps_set);
   ops[37].op = EO_OP_OVERRIDE;
   ops[37].op_type = EO_OP_TYPE_REGULAR;
   ops[37].doc = NULL;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   ops[61].func = reinterpret_cast<void*>(& ::evas_image_colorspace_set_wrapper<T>);
   ops[61].api_func = reinterpret_cast<void*>(& ::evas_obj_image_colorspace_set);
   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_image_pixels_get_callback_set_wrapper<T>);
   ops[62].api_func = reinterpret_cast<void*>(& ::evas_obj_image_pixels_get_callback_set);
   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_image_mmap_get_wrapper<T>);
   ops[63].api_func = reinterpret_cast<void*>(& ::evas_obj_image_mmap_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_image_mmap_set_wrapper<T>);
   ops[64].api_func = reinterpret_cast<void*>(& ::evas_obj_image_mmap_set);
   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_image_data_copy_set_wrapper<T>);
   ops[65].api_func = reinterpret_cast<void*>(& ::evas_obj_image_data_copy_set);
   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_image_animated_frame_set_wrapper<T>);
   ops[66].api_func = reinterpret_cast<void*>(& ::evas_obj_image_animated_frame_set);
   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_image_region_support_get_wrapper<T>);
   ops[67].api_func = reinterpret_cast<void*>(& ::evas_obj_image_region_support_get);
   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_image_load_error_get_wrapper<T>);
   ops[68].api_func = reinterpret_cast<void*>(& ::evas_obj_image_load_error_get);
   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_image_animated_frame_count_get_wrapper<T>);
   ops[69].api_func = reinterpret_cast<void*>(& ::evas_obj_image_animated_frame_count_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_image_stride_get_wrapper<T>);
   ops[70].api_func = reinterpret_cast<void*>(& ::evas_obj_image_stride_get);
   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_image_animated_get_wrapper<T>);
   ops[71].api_func = reinterpret_cast<void*>(& ::evas_obj_image_animated_get);
   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_image_animated_loop_type_get_wrapper<T>);
   ops[72].api_func = reinterpret_cast<void*>(& ::evas_obj_image_animated_loop_type_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_image_animated_loop_count_get_wrapper<T>);
   ops[73].api_func = reinterpret_cast<void*>(& ::evas_obj_image_animated_loop_count_get);
   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_image_scene_get_wrapper<T>);
   ops[74].api_func = reinterpret_cast<void*>(& ::evas_obj_image_scene_get);
   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_image_scene_set_wrapper<T>);
   ops[75].api_func = reinterpret_cast<void*>(& ::evas_obj_image_scene_set);
   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_image_filter_program_set_wrapper<T>);
   ops[76].api_func = reinterpret_cast<void*>(& ::evas_obj_image_filter_program_set);
   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_image_filter_source_set_wrapper<T>);
   ops[77].api_func = reinterpret_cast<void*>(& ::evas_obj_image_filter_source_set);
   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_image_filter_padding_get_wrapper<T>);
   ops[78].api_func = reinterpret_cast<void*>(& ::evas_obj_image_filter_padding_get);
   ops[78].op = EO_OP_OVERRIDE;
   ops[78].op_type = EO_OP_TYPE_REGULAR;
   ops[78].doc = NULL;

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

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

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

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

      double animated_frame_duration_get(int start_frame_, int frame_num_)
      {
         double _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_image_animated_frame_duration_get(start_frame_, frame_num_));
            return _tmp_ret;
      }

      bool save(std::string file_, std::string key_, std::string flags_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_image_save(efl::eolian::to_c(file_), efl::eolian::to_c(key_), efl::eolian::to_c(flags_)));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

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

      void * data_get(bool for_writing_)
      {
         void * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_image_data_get(efl::eolian::to_c(for_writing_)));
            return _tmp_ret;
      }

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

      void * data_convert(Evas_Colorspace to_cspace_)
      {
         void * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_image_data_convert(to_cspace_));
            return _tmp_ret;
      }

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

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

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

      void load_dpi_set(double dpi_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_image_load_dpi_set(dpi_));
      }

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

      void source_clip_set(bool source_clip_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_image_source_clip_set(efl::eolian::to_c(source_clip_)));
      }

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

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

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

      void filled_set(bool filled_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_image_filled_set(efl::eolian::to_c(filled_)));
      }

      Evas_Image_Content_Hint content_hint_get()
      {
         Evas_Image_Content_Hint _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_image_content_hint_get());
            return _tmp_ret;
      }

      void content_hint_set(Evas_Image_Content_Hint hint_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_image_content_hint_set(hint_));
      }

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

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

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

      void alpha_set(bool alpha_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_image_alpha_set(efl::eolian::to_c(alpha_)));
      }

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

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

      void border_get(int* l_, int* r_, int* t_, int* b_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_image_border_get(l_, r_, t_, b_));
      }

      void border_set(int l_, int r_, int t_, int b_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_image_border_set(l_, r_, t_, b_));
      }

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

      void smooth_scale_set(bool smooth_scale_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_image_smooth_scale_set(efl::eolian::to_c(smooth_scale_)));
      }

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

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

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

      void pixels_dirty_set(bool dirty_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_image_pixels_dirty_set(efl::eolian::to_c(dirty_)));
      }

      const Evas_Video_Surface * video_surface_get()
      {
         const Evas_Video_Surface * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_image_video_surface_get());
            return _tmp_ret;
      }

      void video_surface_set(Evas_Video_Surface * surf_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_image_video_surface_set(surf_));
      }

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

      void video_surface_caps_set(unsigned int caps_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_image_video_surface_caps_set(caps_));
      }

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

      void load_orientation_set(bool enable_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_image_load_orientation_set(efl::eolian::to_c(enable_)));
      }

      Evas_Fill_Spread fill_spread_get()
      {
         Evas_Fill_Spread _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_image_fill_spread_get());
            return _tmp_ret;
      }

      void fill_spread_set(Evas_Fill_Spread spread_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_image_fill_spread_set(spread_));
      }

      void file_get(const char ** file_, const char ** key_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_image_file_get(file_, key_));
      }

      void file_set(std::string file_, std::string key_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_image_file_set(efl::eolian::to_c(file_), efl::eolian::to_c(key_)));
      }

      Evas_Border_Fill_Mode border_center_fill_get()
      {
         Evas_Border_Fill_Mode _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_image_border_center_fill_get());
            return _tmp_ret;
      }

      void border_center_fill_set(Evas_Border_Fill_Mode fill_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_image_border_center_fill_set(fill_));
      }

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

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

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

      void source_visible_set(bool visible_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_image_source_visible_set(efl::eolian::to_c(visible_)));
      }

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

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

      Evas_Native_Surface * native_surface_get()
      {
         Evas_Native_Surface * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_image_native_surface_get());
            return _tmp_ret;
      }

      void native_surface_set(Evas_Native_Surface * surf_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_image_native_surface_set(surf_));
      }

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

      void load_scale_down_set(int scale_down_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_image_load_scale_down_set(scale_down_));
      }

      Evas_Image_Scale_Hint scale_hint_get()
      {
         Evas_Image_Scale_Hint _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_image_scale_hint_get());
            return _tmp_ret;
      }

      void scale_hint_set(Evas_Image_Scale_Hint hint_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_image_scale_hint_set(hint_));
      }

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

      void source_events_set(bool source_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_image_source_events_set(efl::eolian::to_c(source_)));
      }

      Evas_Colorspace colorspace_get()
      {
         Evas_Colorspace _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_image_colorspace_get());
            return _tmp_ret;
      }

      void colorspace_set(Evas_Colorspace cspace_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_image_colorspace_set(cspace_));
      }

      void pixels_get_callback_set(Evas_Object_Image_Pixels_Get_Cb func_, void * data_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_image_pixels_get_callback_set(func_, data_));
      }

      void mmap_get(const Eina_File ** f_, const char ** key_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_image_mmap_get(f_, key_));
      }

      void mmap_set(const Eina_File * f_, std::string key_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_image_mmap_set(f_, efl::eolian::to_c(key_)));
      }

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

      void animated_frame_set(int frame_index_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_image_animated_frame_set(frame_index_));
      }

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

      Evas_Load_Error load_error_get()
      {
         Evas_Load_Error _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_image_load_error_get());
            return _tmp_ret;
      }

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

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

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

      Evas_Image_Animated_Loop_Hint animated_loop_type_get()
      {
         Evas_Image_Animated_Loop_Hint _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_image_animated_loop_type_get());
            return _tmp_ret;
      }

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

      Evas_3D_Scene * scene_get()
      {
         Evas_3D_Scene * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_image_scene_get());
            return _tmp_ret;
      }

      void scene_set(Evas_3D_Scene * scene_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_image_scene_set(scene_));
      }

      void filter_program_set(std::string program_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_image_filter_program_set(efl::eolian::to_c(program_)));
      }

      void filter_source_set(std::string name_, Eo * eobj_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_image_filter_source_set(efl::eolian::to_c(name_), eobj_));
      }

      bool filter_padding_get(int* l_, int* r_, int* t_, int* b_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_image_filter_padding_get(l_, r_, t_, b_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

   };
};

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

} } }
#endif // EFL_GENERATED_EVAS_IMAGE_HH

