#ifndef EFL_GENERATED_EVAS_IMAGE_HH
#define EFL_GENERATED_EVAS_IMAGE_HH

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

#include <eo_cxx_interop.hh>

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

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

namespace evas {

struct image
      : evas::object,
      efl::eo::detail::extension_inheritance<efl::file>::template type< ::evas::image>,
      efl::eo::detail::extension_inheritance<efl::image>::template type< ::evas::image>

{
   /// @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)
   {}

   /// @brief Call the object's constructor.
   /// Should not be used with #eo_do. Only use it with #eo_do_super.
   ///
   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 Get dbg information from the object.
   ///
   /// @param root_node node of the tree
   ///
   void dbg_info_get(Eo_Dbg_Info * root_node_) const
   {
      eo_do(_eo_ptr(), ::eo_dbg_info_get(root_node_));
   }

   /// @brief Set the source file from where an image object must fetch the real
   /// image data (it may be an Eet file, besides pure image ones).
   ///
   /// If the file supports multiple data stored in it (as Eet files do),
   /// you can specify the key to be used as the index of the image in
   /// this file.
   ///
   /// Example:
   /// @code
   /// img = evas_object_image_add(canvas);
   /// evas_object_image_file_set(img, "/path/to/img", NULL);
   /// err = evas_object_image_load_error_get(img);
   /// if (err != EVAS_LOAD_ERROR_NONE)
   /// {
   /// fprintf(stderr, "could not load image '%s'. error string is \"%s\"\n",
   /// valid_path, evas_load_error_str(err));
   /// }
   /// else
   /// {
   /// evas_object_image_fill_set(img, 0, 0, w, h);
   /// evas_object_resize(img, w, h);
   /// evas_object_show(img);
   /// }
   /// @endcode
   ///
   /// @param file The image file path.
   /// @param key The image key in @p file (if its an Eet one), or @c
   /// NULL, otherwise.
   ///
   bool file_set(std::string file_, std::string key_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::efl_file_set(efl::eolian::to_c(file_), efl::eolian::to_c(key_)));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Retrieve the source file from where an image object is to fetch the
   /// real image data (it may be an Eet file, besides pure image ones).
   ///
   /// You must @b not modify the strings on the returned pointers.
   ///
   /// @note Use @c NULL pointers on the file components you're not
   /// interested in: they'll be ignored by the function.
   ///
   /// @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(), ::efl_file_get(file_, key_));
   }

   /// @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 = ::efl_file_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 Check if an image  can be animated (have multiple frames)
   ///
   /// @return whether the image support animation
   ///
   /// @param is_animated If it's animated or not.
   ///
   bool animated_get() const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::efl_image_animated_get());
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Set the loading size of an image. The image will be loaded into memory as if it was
   /// the set size instead of the original size. This can save a lot of memory, and is
   /// important for scalable types like svg.
   ///
   /// @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(), ::efl_image_load_size_set(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_get(int* w_, int* h_) const
   {
      eo_do(_eo_ptr(), ::efl_image_load_size_get(w_, h_));
   }

   /// @brief Sets whether to use high-quality image scaling algorithm on the
   /// given image.
   ///
   /// When enabled, a higher quality image scaling algorithm is used when
   /// scaling images to sizes other than the source image's original
   /// one. This gives better results but is more computationally
   /// expensive.
   ///
   /// @param smooth_scale Whether to use smooth scale or not.
   ///
   void smooth_scale_set(bool smooth_scale_) const
   {
      eo_do(_eo_ptr(), ::efl_image_smooth_scale_set(efl::eolian::to_c(smooth_scale_)));
   }

   /// @brief Retrieves whether the given image is using high-quality
   /// image scaling algorithm.
   ///
   /// @return Whether smooth scale is being used.
   ///
   /// @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 = ::efl_image_smooth_scale_get());
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Get the DPI resolution of a loaded image object in the canvas.
   ///
   /// @return The DPI resolution of the given canvas image.
   ///
   /// This function returns the DPI resolution of the given canvas image.
   ///
   /// @see evas_object_image_load_dpi_set() for more details
   ///
   /// @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;
   }

   /// @brief Set the DPI resolution of an image object's source image.
   ///
   /// This function sets the DPI resolution of a given loaded canvas
   /// image. Most useful for the SVG image loader.
   ///
   /// @see evas_object_image_load_dpi_get()
   ///
   /// @param dpi The new DPI resolution.
   ///
   void load_dpi_set(double dpi_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_load_dpi_set(dpi_));
   }

   /// @brief Determine whether an object is clipped by source object's clipper.
   ///
   /// @return @c EINA_TRUE if source clip is enabled, @c EINA_FALSE otherwise.
   ///
   /// @see evas_object_clip_set()
   /// @see evas_object_image_source_set()
   /// @see evas_object_image_source_clip_set()
   /// @since 1.8
   ///
   /// @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>());
   }

   /// @brief Clip the proxy object with the source object's clipper.
   ///
   /// @see evas_object_clip_set()
   /// @see evas_object_image_source_set()
   /// @since 1.8
   ///
   /// @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_)));
   }

   /// @brief Get the current source object of an image object.
   ///
   /// @return Source object (if any), or @c NULL, if not in "proxy mode"
   /// (or on errors).
   ///
   /// @see evas_object_image_source_set() for more details
   ///
   /// @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>());
   }

   /// @brief Set the source object on an image object to used as a @b proxy.
   ///
   /// @return @c EINA_TRUE on success, @c EINA_FALSE on error.
   ///
   /// If an image object is set to behave as a @b proxy, it will mirror
   /// the rendering contents of a given @b source object in its drawing
   /// region, without affecting that source in any way. The source must
   /// be another valid Evas object. Other effects may be applied to the
   /// proxy, such as a map (see evas_object_map_set()) to create a
   /// reflection of the original object (for example).
   ///
   /// Any existing source object on @p obj will be removed after this
   /// call. Setting @p src to @c NULL clears the proxy object (not in
   /// "proxy state" anymore).
   ///
   /// @warning You cannot set a proxy as another proxy's source.
   ///
   /// @see evas_object_image_source_get()
   /// @see evas_object_image_source_unset()
   /// @see evas_object_image_source_visible_set()
   ///
   /// @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>());
   }

   /// @brief Retrieve whether the image object's fill property should track the
   /// object's size.
   ///
   /// @return @c EINA_TRUE if it is tracking, @c EINA_FALSE, if not (and
   /// evas_object_fill_set() must be called manually).
   ///
   /// @see evas_object_image_filled_set() for more information
   ///
   /// @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>());
   }

   /// @brief Set whether the image object's fill property should track the
   /// object's size.
   ///
   /// If @p setting is @c EINA_TRUE, then every evas_object_resize() will
   /// @b automatically trigger a call to evas_object_image_fill_set()
   /// with the that new size (and @c 0, @c 0 as source image's origin),
   /// so the bound image will fill the whole object's area.
   ///
   /// @see evas_object_image_filled_add()
   /// @see evas_object_image_fill_get()
   ///
   /// @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_)));
   }

   /// @brief Get the content hint setting of a given image object of the canvas.
   ///
   /// @return hint The content hint value set on it, one of the
   /// #Evas_Image_Content_Hint ones (#EVAS_IMAGE_CONTENT_HINT_NONE means
   /// an error).
   ///
   /// This function returns the content hint value of the given image of
   /// the canvas.
   ///
   /// @see evas_object_image_content_hint_set()
   ///
   /// @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;
   }

   /// @brief Set the content hint setting of a given image object of the canvas.
   ///
   /// This function sets the content hint value of the given image of the
   /// canvas. For example, if you're on the GL engine and your driver
   /// implementation supports it, setting this hint to
   /// #EVAS_IMAGE_CONTENT_HINT_DYNAMIC will make it need @b zero copies
   /// at texture upload time, which is an "expensive" operation.
   ///
   /// @see evas_object_image_content_hint_get()
   ///
   /// @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_));
   }

   /// @brief Retrieve the coordinates of a given image object's selective
   /// (source image) load region.
   ///
   /// @note Use @c NULL pointers on the coordinates you're not interested
   /// in: they'll be ignored by the function.
   ///
   /// @see evas_object_image_load_region_get()
   ///
   /// @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_));
   }

   /// @brief Inform a given image object to load a selective region of its
   /// source image.
   ///
   /// This function is useful when one is not showing all of an image's
   /// area on its image object.
   ///
   /// @note The image loader for the image format in question has to
   /// support selective region loading in order to this function to take
   /// effect.
   ///
   /// @see evas_object_image_load_region_get()
   ///
   /// @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_));
   }

   /// @brief Retrieve whether alpha channel data is being used on the given
   /// image object.
   ///
   /// @return Whether the alpha channel data is being used (@c EINA_TRUE)
   /// or not (@c EINA_FALSE).
   ///
   /// This function returns @c EINA_TRUE if the image object's alpha
   /// channel is being used, or @c EINA_FALSE otherwise.
   ///
   /// See @ref evas_object_image_alpha_set() for more details.
   ///
   /// @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>());
   }

   /// @brief Enable or disable alpha channel usage on the given image object.
   ///
   /// This function sets a flag on an image object indicating whether or
   /// not to use alpha channel data. A value of @c EINA_TRUE makes it use
   /// alpha channel data, and @c EINA_FALSE makes it ignore that
   /// data. Note that this has nothing to do with an object's color as
   /// manipulated by evas_object_color_set().
   ///
   /// @see evas_object_image_alpha_get()
   ///
   /// @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_)));
   }

   /// @brief Retrieve the dimensions for an image object's border, a region
   /// which @b won't ever be scaled together with its center.
   ///
   /// @note Use @c NULL pointers on the border components you're not
   /// interested in: they'll be ignored by the function.
   ///
   /// See @ref evas_object_image_border_set() for more details.
   ///
   /// @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_));
   }

   /// @brief Set the dimensions for an image object's border, a region which @b
   /// won't ever be scaled together with its center.
   ///
   /// When Evas is rendering, an image source may be scaled to fit the
   /// size of its image object. This function sets an area from the
   /// borders of the image inwards which is @b not to be scaled. This
   /// function is useful for making frames and for widget theming, where,
   /// for example, buttons may be of varying sizes, but their border size
   /// must remain constant.
   ///
   /// The units used for @p l, @p r, @p t and @p b are canvas units.
   ///
   /// @note The border region itself @b may be scaled by the
   /// evas_object_image_border_scale_set() function.
   ///
   /// @note By default, image objects have no borders set, i. e. @c l, @c
   /// r, @c t and @c b start as @c 0.
   ///
   /// See the following figures for visual explanation:\n
   /// @htmlonly
   /// <img src="image-borders.png" style="max-width: 100%;" />
   /// <a href="image-borders.png">Full-size</a>
   /// @endhtmlonly
   /// @image rtf image-borders.png
   /// @image latex image-borders.eps width=\textwidth
   /// @htmlonly
   /// <img src="border-effect.png" style="max-width: 100%;" />
   /// <a href="border-effect.png">Full-size</a>
   /// @endhtmlonly
   /// @image rtf border-effect.png
   /// @image latex border-effect.eps width=\textwidth
   ///
   /// @see evas_object_image_border_get()
   /// @see evas_object_image_border_center_fill_set()
   ///
   /// @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_));
   }

   /// @brief Retrieves the scaling factor (multiplier) for the borders of an
   /// image object.
   ///
   /// @return The scale factor set for its borders
   ///
   /// @see evas_object_image_border_set()
   /// @see evas_object_image_border_scale_set()
   ///
   /// @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;
   }

   /// @brief Sets the scaling factor (multiplier) for the borders of an image
   /// object.
   ///
   /// @see evas_object_image_border_set()
   /// @see evas_object_image_border_scale_get()
   ///
   /// @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_));
   }

   /// @brief Retrieves whether the given image object is dirty (needs to be redrawn).
   ///
   /// @return Whether the image is dirty.
   ///
   /// @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>());
   }

   /// @brief Mark whether the given image object is dirty and needs to request its pixels.
   ///
   /// This function will only properly work if a pixels get callback has been set.
   ///
   /// @warning use this function if you really know what you are doing.
   ///
   /// @see evas_object_image_pixels_get_callback_set()
   ///
   /// @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_)));
   }

   /// @brief Get the video surface linekd to a given image of the canvas
   ///
   /// @return The video surface of the given canvas image.
   /// @since 1.1
   ///
   /// This function returns the video surface linked to a given canvas image.
   ///
   /// @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;
   }

   /// @brief Set the video surface linked to a given image of the canvas
   ///
   /// This function links a video surface to a given canvas image.
   ///
   /// @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_));
   }

   /// @brief Get the video surface capabilities to a given image of the canvas
   ///
   /// @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;
   }

   /// @brief Set the video surface capabilities to a given image of the canvas
   ///
   /// @param caps in
   ///
   void video_surface_caps_set(unsigned int caps_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_video_surface_caps_set(caps_));
   }

   /// @brief Get if the orientation information in the image file should be honored.
   ///
   /// @since 1.1
   ///
   /// @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>());
   }

   /// @brief Define if the orientation information in the image file should be honored.
   ///
   /// @since 1.1
   ///
   /// @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_)));
   }

   /// @brief Retrieves the spread (tiling mode) for the given image object's
   /// fill.
   ///
   /// @return  The current spread mode of the image object.
   ///
   /// @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;
   }

   /// @brief Sets the tiling mode for the given evas image object's fill.
   /// EVAS_TEXTURE_RESTRICT, or EVAS_TEXTURE_PAD.
   ///
   /// @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_));
   }

   /// @brief Retrieves @b how the center part of the given image object (not the
   /// borders) is to be drawn when Evas is rendering it.
   ///
   /// @return fill Fill mode of the center region of @p obj (a value in
   /// #Evas_Border_Fill_Mode).
   ///
   /// See @ref evas_object_image_fill_set() for more details.
   ///
   /// @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;
   }

   /// @brief Sets @b how the center part of the given image object (not the
   /// borders) should be drawn when Evas is rendering it.
   ///
   /// This function sets how the center part of the image object's source
   /// image is to be drawn, which must be one of the values in
   /// #Evas_Border_Fill_Mode. By center we mean the complementary part of
   /// that defined by evas_object_image_border_set(). This one is very
   /// useful for making frames and decorations. You would most probably
   /// also be using a filled image (as in evas_object_image_filled_set())
   /// to use as a frame.
   ///
   /// @see evas_object_image_border_center_fill_get()
   ///
   /// @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_));
   }

   /// @brief Retrieves the size of the given image object.
   ///
   /// See @ref evas_object_image_size_set() for more details.
   ///
   /// @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_));
   }

   /// @brief Sets the size of the given image object.
   ///
   /// This function will scale down or crop the image so that it is
   /// treated as if it were at the given size. If the size given is
   /// smaller than the image, it will be cropped. If the size given is
   /// larger, then the image will be treated as if it were in the upper
   /// left hand corner of a larger image that is otherwise transparent.
   ///
   /// @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_));
   }

   /// @brief Get the state of the source object visibility.
   ///
   /// @return @c EINA_TRUE if source object is visible, @c EINA_FALSE otherwise.
   ///
   /// @see evas_object_image_source_visible_set()
   /// @see evas_object_image_source_set()
   /// @see evas_object_show()
   /// @see evas_object_hide()
   /// @since 1.8
   ///
   /// @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>());
   }

   /// @brief Set the source object to be visible or not.
   ///
   /// If the @p visible set to @c EINA_FALSE, the source object of the proxy(@p obj
   /// ) will be invisible.
   ///
   /// This API works differently to evas_object_show() and evas_object_hide().
   /// Once source object is hidden by evas_object_hide() then the proxy object will
   /// be hidden as well. Actually in this case both objects are excluded from the
   /// Evas internal update circle.
   ///
   /// By this API, instead, one can toggle the visibility of a proxy's source
   /// object remaining the proxy visibility untouched.
   ///
   /// @warning If the all of proxies are deleted, then the source visibility of the
   /// source object will be cancelled.
   ///
   /// @see evas_object_image_source_visible_get()
   /// @see evas_object_image_source_set()
   /// @see evas_object_show()
   /// @see evas_object_hide()
   /// @since 1.8
   ///
   /// @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_)));
   }

   /// @brief Retrieve how an image object is to fill its drawing rectangle,
   /// given the (real) image bound to it.
   ///
   /// @note Use @c NULL pointers on the fill components you're not
   /// interested in: they'll be ignored by the function.
   ///
   /// See @ref evas_object_image_fill_set() for more details.
   ///
   /// @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_));
   }

   /// @brief Set how to fill an image object's drawing rectangle given the
   /// (real) image bound to it.
   ///
   /// Note that if @p w or @p h are smaller than the dimensions of
   /// @p obj, the displayed image will be @b tiled around the object's
   /// area. To have only one copy of the bound image drawn, @p x and @p y
   /// must be 0 and @p w and @p h need to be the exact width and height
   /// of the image object itself, respectively.
   ///
   /// See the following image to better understand the effects of this
   /// call. On this diagram, both image object and original image source
   /// have @c a x @c a dimensions and the image itself is a circle, with
   /// empty space around it:
   ///
   /// @image html image-fill.png
   /// @image rtf image-fill.png
   /// @image latex image-fill.eps
   ///
   /// @warning The default values for the fill parameters are @p x = 0,
   /// @p y = 0, @p w = 0 and @p h = 0. Thus, if you're not using the
   /// evas_object_image_filled_add() helper and want your image
   /// displayed, you'll have to set valid values with this function on
   /// your object.
   ///
   /// @note evas_object_image_filled_set() is a helper function which
   /// will @b override the values set here automatically, for you, in a
   /// given way.
   ///
   /// @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_));
   }

   /// @brief Get the native surface of a given image of the canvas
   ///
   /// @return The native surface of the given canvas image.
   ///
   /// This function returns the native surface of a given canvas image.
   ///
   /// @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;
   }

   /// @brief Set the native surface of a given image of the canvas
   ///
   /// This function sets a native surface of a given canvas image.
   ///
   /// @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_));
   }

   /// @brief get the scale down factor of a given image object's source image,
   /// when loading it.
   ///
   /// @see evas_object_image_load_scale_down_set() for more details
   ///
   /// @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;
   }

   /// @brief Set the scale down factor of a given image object's source image,
   /// when loading it.
   ///
   /// This function sets the scale down factor of a given canvas
   /// image. Most useful for the SVG image loader.
   ///
   /// @see evas_object_image_load_scale_down_get()
   ///
   /// @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_));
   }

   /// @brief Get the scale hint of a given image of the canvas.
   ///
   /// @return The scale hint value set on @p obj, a value in
   /// #Evas_Image_Scale_Hint.
   ///
   /// This function returns the scale hint value of the given image
   /// object of the canvas.
   ///
   /// @see evas_object_image_scale_hint_set() for more details.
   ///
   /// @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;
   }

   /// @brief Set the scale hint of a given image of the canvas.
   ///
   /// This function sets the scale hint value of the given image object
   /// in the canvas, which will affect how Evas is to cache scaled
   /// versions of its original source image.
   ///
   /// @see evas_object_image_scale_hint_get()
   ///
   /// @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_));
   }

   /// @brief Determine whether an object is set to source events.
   ///
   /// @return @c EINA_TRUE if source object has events, @c EINA_FALSE otherwise.
   ///
   /// @see evas_object_image_source_set()
   /// @see evas_object_image_source_visible_set()
   /// @see evas_object_image_source_events_set()
   /// @since 1.8
   ///
   /// @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>());
   }

   /// @brief Set whether an Evas object is to source events.
   ///
   /// Set whether an Evas object is to repeat events to source.
   ///
   /// If @p source is @c EINA_TRUE, it will make events on @p obj to also be
   /// repeated for the source object (see evas_object_image_source_set()). Even the
   /// @p obj and source geometries are different, the event position will be
   /// transformed to the source object's space.
   ///
   /// If @p source is @c EINA_FALSE, events occurring on @p obj will be
   /// processed only on it.
   ///
   /// @see evas_object_image_source_get()
   /// @see evas_object_image_source_visible_set()
   /// @see evas_object_image_source_events_get()
   /// @since 1.8
   ///
   /// @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_)));
   }

   /// @brief Get the colorspace of a given image of the canvas.
   ///
   /// @return The colorspace of the image.
   ///
   /// This function returns the colorspace of given canvas image.
   ///
   /// @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;
   }

   /// @brief Set the colorspace of a given image of the canvas.
   ///
   /// This function sets the colorspace of given canvas image.
   ///
   /// @param cspace The new color space.
   ///
   void colorspace_set(Evas_Colorspace cspace_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_colorspace_set(cspace_));
   }

   /// @brief Set the callback function to get pixels from a canvas' image.
   ///
   /// This functions sets a function to be the callback function that get
   /// pixels from a image of the canvas.
   ///
   /// @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_));
   }

   /// @brief Get the source mmaped file from where an image object must fetch the real
   /// image data (it must be an Eina_File).
   ///
   /// If the file supports multiple data stored in it (as Eet files do),
   /// you can get the key to be used as the index of the image in
   /// this file.
   ///
   /// @since 1.10
   ///
   /// @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_));
   }

   /// @brief Set the source mmaped file from where an image object must fetch the real
   /// image data (it must be an Eina_File).
   ///
   /// If the file supports multiple data stored in it (as Eet files do),
   /// you can specify the key to be used as the index of the image in
   /// this file.
   ///
   /// @since 1.8
   ///
   /// @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_)));
   }

   /// @brief Replaces the raw image data of the given image object.
   ///
   /// This function lets the application replace an image object's
   /// internal pixel buffer with an user-allocated one. For best results,
   /// you should generally first call evas_object_image_size_set() with
   /// the width and height for the new buffer.
   ///
   /// This call is best suited for when you will be using image data with
   /// different dimensions than the existing image data, if any. If you
   /// only need to modify the existing image in some fashion, then using
   /// evas_object_image_data_get() is probably what you are after.
   ///
   /// Note that the caller is responsible for freeing the buffer when
   /// finished with it, as user-set image data will not be automatically
   /// freed when the image object is deleted.
   ///
   /// See @ref evas_object_image_data_get() for more details.
   ///
   /// @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_));
   }

   /// @brief Set the frame to current frame of an image object
   ///
   /// This set image object's current frame to frame_num with 1 being the first
   /// frame.
   ///
   /// @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 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_));
   }

   /// @brief Get the support state of a given image
   ///
   /// @return The region support state
   /// @since 1.2
   ///
   /// This function returns the state of the region support of given image
   ///
   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>());
   }

   /// @brief Retrieves a number representing any error that occurred during the
   /// last loading of the given image object's source image.
   ///
   /// @return A value giving the last error that occurred. It should be
   /// one of the #Evas_Load_Error values. #EVAS_LOAD_ERROR_NONE
   /// is returned if there was no error.
   ///
   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;
   }

   /// @brief Get the total number of frames of the image object.
   ///
   /// @return The number of frames
   ///
   /// This returns total number of frames the image object supports (if animated)
   ///
   /// @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
   ///
   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;
   }

   /// @brief Retrieves the row stride of the given image object.
   ///
   /// @return The stride of the image (<b>in bytes</b>).
   ///
   /// The row stride is the number of bytes between the start of a row
   /// and the start of the next row for image data.
   ///
   int stride_get() const
   {
      int _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_image_stride_get());
      return _tmp_ret;
   }

   /// @brief Get the kind of looping the image object does.
   ///
   /// @return Loop type of the image object
   ///
   /// This returns the kind of looping the image object wants to do.
   ///
   /// If it returns EVAS_IMAGE_ANIMATED_HINT_LOOP, you should display frames in a sequence like:
   /// 1->2->3->1->2->3->1...
   /// If it returns EVAS_IMAGE_ANIMATED_HINT_PINGPONG, it is better to
   /// display frames in a sequence like: 1->2->3->2->1->2->3->1...
   ///
   /// The default type is EVAS_IMAGE_ANIMATED_HINT_LOOP.
   ///
   /// @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
   ///
   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;
   }

   /// @brief Get the number times the animation of the object loops.
   ///
   /// @return The number of loop of an animated image object
   ///
   /// This returns loop count of image. The loop count is the number of times
   /// the animation will play fully from first to last frame until the animation
   /// should stop (at the final frame).
   ///
   /// If 0 is returned, then looping should happen indefinitely (no limit to
   /// the number of times it loops).
   ///
   /// @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
   ///
   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;
   }

   /// @brief Get the 3D scene of a given image of the canvas.
   ///
   /// @return The 3d scene of the given canvas image.
   ///
   /// This function returns the 3d scene of a given canvas image.
   ///
   /// @see evas_object_image_scene_get
   /// @since 1.10
   ///
   /// @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;
   }

   /// @brief Set the 3D scene of a given image of the canvas.
   ///
   /// This function sets a 3d scene of a given canvas image.
   ///
   /// @see evas_object_image_scene_set
   /// @since 1.10
   ///
   /// @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_));
   }

   /// @brief Set an Evas filter program on this Text Object.
   ///
   /// If the program fails to compile (syntax error, invalid
   /// buffer name, etc...), the standard text effects will be
   /// applied instead (SHADOW, etc...). switch back to the
   /// standard text effects.
   ///
   /// @since 1.9
   /// @note EXPERIMENTAL FEATURE. This is an unstable API,
   /// please use only for testing purposes.
   /// @see @ref evasfiltersref "Evas filters reference"
   ///
   /// @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_)));
   }

   /// @brief Bind an object to use as a mask or texture with Evas Filters.
   ///
   /// This will create automatically a new RGBA buffer containing
   /// the source object's pixels (as it is rendered).
   ///
   /// @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_, efl::eo::base eobj_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_image_filter_source_set(efl::eolian::to_c(name_), efl::eolian::to_c(eobj_)));
   }

   /// @brief Get the value of the extra padding set when a filter is used.
   ///
   /// @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>());
   }

   /// @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 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());
   }

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

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

};
} 

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

template <typename T>
bool evas_image_file_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * file_, const char * key_)
{
   return 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>
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>
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>
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>
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_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_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>
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>
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_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>
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>
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>
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>()), efl::eolian::to_cxx<efl::eo::base>(eobj_, std::tuple<std::false_type>()));
}

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_);
}

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>
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();
}

namespace efl { namespace eo { namespace detail {

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

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

      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(),
               ::efl_file_get(file_, key_));
      }

      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 = ::efl_file_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 bool animated_get()
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::efl_image_animated_get());
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

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

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

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

      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 = ::efl_image_smooth_scale_get());
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      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 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 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 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 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_, efl::eo::base 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_), efl::eolian::to_c(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>());
      }

      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 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());
      }

   };
};


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

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_dbg_info_get_wrapper<T>);
   ops[0].api_func = reinterpret_cast<void*>(& ::eo_dbg_info_get);
   ops[0].op = EO_OP_OVERRIDE;
   ops[0].op_type = EO_OP_TYPE_REGULAR;
   ops[0].doc = NULL;

   ops[1].func = reinterpret_cast<void*>(& ::evas_image_file_set_wrapper<T>);
   ops[1].api_func = reinterpret_cast<void*>(& ::efl_file_set);
   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_file_get_wrapper<T>);
   ops[2].api_func = reinterpret_cast<void*>(& ::efl_file_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*>(& ::efl_file_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_animated_get_wrapper<T>);
   ops[4].api_func = reinterpret_cast<void*>(& ::efl_image_animated_get);
   ops[4].op = EO_OP_OVERRIDE;
   ops[4].op_type = EO_OP_TYPE_REGULAR;
   ops[4].doc = NULL;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   ops[38].func = reinterpret_cast<void*>(& ::evas_image_border_center_fill_set_wrapper<T>);
   ops[38].api_func = reinterpret_cast<void*>(& ::evas_obj_image_border_center_fill_set);
   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_size_get_wrapper<T>);
   ops[39].api_func = reinterpret_cast<void*>(& ::evas_obj_image_size_get);
   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_size_set_wrapper<T>);
   ops[40].api_func = reinterpret_cast<void*>(& ::evas_obj_image_size_set);
   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_source_visible_get_wrapper<T>);
   ops[41].api_func = reinterpret_cast<void*>(& ::evas_obj_image_source_visible_get);
   ops[41].op = EO_OP_OVERRIDE;
   ops[41].op_type = EO_OP_TYPE_REGULAR;
   ops[41].doc = NULL;

   ops[42].func = reinterpret_cast<void*>(& ::evas_image_source_visible_set_wrapper<T>);
   ops[42].api_func = reinterpret_cast<void*>(& ::evas_obj_image_source_visible_set);
   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_fill_get_wrapper<T>);
   ops[43].api_func = reinterpret_cast<void*>(& ::evas_obj_image_fill_get);
   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_fill_set_wrapper<T>);
   ops[44].api_func = reinterpret_cast<void*>(& ::evas_obj_image_fill_set);
   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_native_surface_get_wrapper<T>);
   ops[45].api_func = reinterpret_cast<void*>(& ::evas_obj_image_native_surface_get);
   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_native_surface_set_wrapper<T>);
   ops[46].api_func = reinterpret_cast<void*>(& ::evas_obj_image_native_surface_set);
   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_load_scale_down_get_wrapper<T>);
   ops[47].api_func = reinterpret_cast<void*>(& ::evas_obj_image_load_scale_down_get);
   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_load_scale_down_set_wrapper<T>);
   ops[48].api_func = reinterpret_cast<void*>(& ::evas_obj_image_load_scale_down_set);
   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_scale_hint_get_wrapper<T>);
   ops[49].api_func = reinterpret_cast<void*>(& ::evas_obj_image_scale_hint_get);
   ops[49].op = EO_OP_OVERRIDE;
   ops[49].op_type = EO_OP_TYPE_REGULAR;
   ops[49].doc = NULL;

   ops[50].func = reinterpret_cast<void*>(& ::evas_image_scale_hint_set_wrapper<T>);
   ops[50].api_func = reinterpret_cast<void*>(& ::evas_obj_image_scale_hint_set);
   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_source_events_get_wrapper<T>);
   ops[51].api_func = reinterpret_cast<void*>(& ::evas_obj_image_source_events_get);
   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_source_events_set_wrapper<T>);
   ops[52].api_func = reinterpret_cast<void*>(& ::evas_obj_image_source_events_set);
   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_colorspace_get_wrapper<T>);
   ops[53].api_func = reinterpret_cast<void*>(& ::evas_obj_image_colorspace_get);
   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_colorspace_set_wrapper<T>);
   ops[54].api_func = reinterpret_cast<void*>(& ::evas_obj_image_colorspace_set);
   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_pixels_get_callback_set_wrapper<T>);
   ops[55].api_func = reinterpret_cast<void*>(& ::evas_obj_image_pixels_get_callback_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_mmap_get_wrapper<T>);
   ops[56].api_func = reinterpret_cast<void*>(& ::evas_obj_image_mmap_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_mmap_set_wrapper<T>);
   ops[57].api_func = reinterpret_cast<void*>(& ::evas_obj_image_mmap_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_data_copy_set_wrapper<T>);
   ops[58].api_func = reinterpret_cast<void*>(& ::evas_obj_image_data_copy_set);
   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_animated_frame_set_wrapper<T>);
   ops[59].api_func = reinterpret_cast<void*>(& ::evas_obj_image_animated_frame_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_region_support_get_wrapper<T>);
   ops[60].api_func = reinterpret_cast<void*>(& ::evas_obj_image_region_support_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_load_error_get_wrapper<T>);
   ops[61].api_func = reinterpret_cast<void*>(& ::evas_obj_image_load_error_get);
   ops[61].op = EO_OP_OVERRIDE;
   ops[61].op_type = EO_OP_TYPE_REGULAR;
   ops[61].doc = NULL;

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

   ops[63].func = reinterpret_cast<void*>(& ::evas_image_stride_get_wrapper<T>);
   ops[63].api_func = reinterpret_cast<void*>(& ::evas_obj_image_stride_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_animated_loop_type_get_wrapper<T>);
   ops[64].api_func = reinterpret_cast<void*>(& ::evas_obj_image_animated_loop_type_get);
   ops[64].op = EO_OP_OVERRIDE;
   ops[64].op_type = EO_OP_TYPE_REGULAR;
   ops[64].doc = NULL;

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

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

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

   ops[68].func = reinterpret_cast<void*>(& ::evas_image_filter_program_set_wrapper<T>);
   ops[68].api_func = reinterpret_cast<void*>(& ::evas_obj_image_filter_program_set);
   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_filter_source_set_wrapper<T>);
   ops[69].api_func = reinterpret_cast<void*>(& ::evas_obj_image_filter_source_set);
   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_filter_padding_get_wrapper<T>);
   ops[70].api_func = reinterpret_cast<void*>(& ::evas_obj_image_filter_padding_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_preload_begin_wrapper<T>);
   ops[71].api_func = reinterpret_cast<void*>(& ::evas_obj_image_preload_begin);
   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_data_update_add_wrapper<T>);
   ops[72].api_func = reinterpret_cast<void*>(& ::evas_obj_image_data_update_add);
   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_frame_duration_get_wrapper<T>);
   ops[73].api_func = reinterpret_cast<void*>(& ::evas_obj_image_animated_frame_duration_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_data_set_wrapper<T>);
   ops[74].api_func = reinterpret_cast<void*>(& ::evas_obj_image_data_set);
   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_data_get_wrapper<T>);
   ops[75].api_func = reinterpret_cast<void*>(& ::evas_obj_image_data_get);
   ops[75].op = EO_OP_OVERRIDE;
   ops[75].op_type = EO_OP_TYPE_REGULAR;
   ops[75].doc = NULL;

   ops[76].func = reinterpret_cast<void*>(& ::evas_image_preload_cancel_wrapper<T>);
   ops[76].api_func = reinterpret_cast<void*>(& ::evas_obj_image_preload_cancel);
   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_data_convert_wrapper<T>);
   ops[77].api_func = reinterpret_cast<void*>(& ::evas_obj_image_data_convert);
   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_pixels_import_wrapper<T>);
   ops[78].api_func = reinterpret_cast<void*>(& ::evas_obj_image_pixels_import);
   ops[78].op = EO_OP_OVERRIDE;
   ops[78].op_type = EO_OP_TYPE_REGULAR;
   ops[78].doc = NULL;

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

   return 0;
}
inline void
call_constructor(tag< evas::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 dbg_info_get(Eo_Dbg_Info * root_node_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::eo_dbg_info_get(root_node_));
      }

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

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

      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 = ::efl_file_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>());
      }

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

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

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

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

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

      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 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_));
      }

      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_));
      }

      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;
      }

      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_, efl::eo::base eobj_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_image_filter_source_set(efl::eolian::to_c(name_), efl::eolian::to_c(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>());
      }

      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;
      }

      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());
      }

   };
};

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

} } }
#endif // EFL_GENERATED_EVAS_IMAGE_HH

