class Evas.Image (Evas.Object, Efl.File, Efl.Image, Efl.Gfx.Fill, Efl.Gfx.View, Evas.Filter)
{
   legacy_prefix: evas_object_image;
   eo_prefix: evas_obj_image;
   methods {
      @property load_dpi {
         set {
            [[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.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif
            ]]
         }
         get {
            [[Get the DPI resolution of a loaded image object in the canvas.

              This function returns the DPI resolution of the given canvas
              image.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif
            ]]
         }
         values {
            dpi: double; [[The DPI resolution.]]
         }
      }

      @property source_clip {
         set {
            [[Clip the proxy object with the source object's clipper.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif

              @since 1.8
            ]]
         }
         get {
            [[Determine whether an object is clipped by source object's
              clipper.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif

              @since 1.8
            ]]
         }
         values {
            source_clip: bool; [[Whether $obj is clipped by the source
                                clipper ($true) or not ($false).]]
         }
      }
      @property source {
         set {
            [[Set the source object on an image object to used as a proxy.

              If an image object is set to behave as a proxy, it will mirror
              the rendering contents of a given 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
              \@ref evas_object_map_set) to create a reflection of the
              original object (for example).

              Any existing source object on $obj will be removed after this
              call. Setting $src to $null clears the proxy object (not in
              "proxy state" anymore).

              Warning: You cannot set a proxy as another proxy's source.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif
            ]]
            return: bool;
         }
         get {
            [[Get the current source object of an image object.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif
            ]]
         }
         values {
            src: Evas.Object *; [[Source object to use for the proxy.]]
         }
      }
      @property filled {
         set {
            [[Set whether the image object's fill property should track the
              object's size.

              If $setting is $true, then every \@ref evas_object_resize will
              automatically trigger a call to \@ref evas_object_image_fill_set
              with the that new size (and 0, 0 as source image's origin),
              so the bound image will fill the whole object's area.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif
            ]]
         }
         get {
            [[Retrieve whether the image object's fill property should track
              the object's size.

              Returns $true if it is tracking, $false if not (and
              \@ref evas_object_fill_set must be called manually).

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif
            ]]
         }
         values {
            filled: bool; [[$true to make the fill property follow
                            object size or $false otherwise.]]
         }
      }
      @property content_hint {
         set {
            [[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 zero copies
              at texture upload time, which is an "expensive" operation.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif
            ]]
         }
         get {
            [[Get the content hint setting of a given image object of the
              canvas.

              This returns #EVAS_IMAGE_CONTENT_HINT_NONE on error.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif
            ]]
         }
         values {
            hint: Evas_Image_Content_Hint; [[The content hint value, one of
                                             the #Evas_Image_Content_Hint ones.]]
         }
      }
      @property load_region {
         set {
            [[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.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif
            ]]
         }
         get {
            [[Retrieve the coordinates of a given image object's selective
              (source image) load region.

              Note: Use $null pointers on the coordinates you're not
              interested in: they'll be ignored by the function.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif
            ]]
         }
         values {
            x: int; [[X-offset of the region to be loaded.]]
            y: int; [[Y-offset of the region to be loaded.]]
            w: int; [[Width of the region to be loaded.]]
            h: int; [[Height of the region to be loaded.]]
         }
      }
      @property alpha {
         set {
            [[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 $true
              makes it use alpha channel data, and $false makes it ignore
              that data. Note that this has nothing to do with an object's
              color as  manipulated by \@ref evas_object_color_set.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif
            ]]
         }
         get {
            [[Retrieve whether alpha channel data is being used on the
              given image object.

              This function returns $true if the image object's alpha
              channel is being used, or $false otherwise.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif
            ]]
         }
         values {
            alpha: bool; [[Whether to use alpha channel ($true) data
                           or not ($false).]]
         }
      }
      @property border {
         set {
            [[Set the dimensions for an image object's border, a region
              which 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 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 $l, $r, $t and $b are canvas units.

              Note: The border region itself may be scaled by the
              @.border_scale.set function.

              Note: By default, image objects have no borders set, i. e.
              $l, $r, $t and $b start as 0.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif
            ]]
            /* FIXME-doc
            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
            */
         }
         get {
            [[Retrieve the dimensions for an image object's border, a
              region which won't ever be scaled together with its center.

              Note: Use $null pointers on the border components you're not
              interested in: they'll be ignored by the function.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif
            ]]
         }
         values {
            l: int; [[The border's left width.]]
            r: int; [[The border's right width.]]
            t: int; [[The border's top width.]]
            b: int; [[The border's bottom width.]]
         }
      }
      @property border_scale {
         set {
            [[Sets the scaling factor (multiplier) for the borders of an
              image object.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif
            ]]
         }
         get {
            [[Retrieves the scaling factor (multiplier) for the borders
              of an image object.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif
            ]]
         }
         values {
            scale: double; [[The scale factor (default is 1.0 - i.e. no scaling).]]
         }
      }
      @property pixels_dirty {
         set {
            [[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.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif
            ]]
         }
         get {
            [[Retrieves whether the given image object is dirty (needs to
              be redrawn).

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif
            ]]
         }
         values {
            dirty: bool; [[Whether the image is dirty.]]
         }
      }
      @property video_surface {
         set {
            [[Set the video surface linked to a given image of the canvas.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif

              @since 1.1
            ]]
            values {
               surf: Evas_Video_Surface*; [[The new video surface.]]
            }
         }
         get {
            [[Get the video surface linekd to a given image of the canvas.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif

              @since 1.1
            ]]
            values {
               surf: const(Evas_Video_Surface)*; [[The new video surface.]]
            }
         }
      }
      @property video_surface_caps {
         set {
            [[Set the video surface capabilities to a given image of the canvas.

              \@if MOBILE \@since_tizen 3.0
              \@elseif WEARABLE \@since_tizen 3.0
              \@endif
            ]]
         }
         get {
            [[Get the video surface capabilities to a given image of the canvas.

              \@if MOBILE \@since_tizen 3.0
              \@elseif WEARABLE \@since_tizen 3.0
              \@endif
            ]]
         }
         values {
            caps: uint;
         }
      }
      @property load_orientation {
         set {
            [[Define if the orientation information in the image file
              should be honored.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif

              @since 1.1
            ]]
         }
         get {
            [[Get if the orientation information in the image file should
              be honored.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif

              @since 1.1
            ]]
         }
         values {
            enable: bool; [[$true means that it should honor the orientation
                            information.]]
         }
      }
      @property border_center_fill {
         set {
            [[Sets 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 @.border.set. This one is very useful
              for making frames and decorations. You would most probably
              also be using a filled image (as in @.filled.set) to use as
              a frame.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif
            ]]
         }
         get {
            [[Retrieves how the center part of the given image object (not
              the borders) is to be drawn when Evas is rendering it.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif
            ]]
         }
         values {
            fill: Evas_Border_Fill_Mode; [[Fill mode of the center region
                                           of $obj (a value in  #Evas_Border_Fill_Mode).]]
         }
      }
      @property source_visible {
         set {
            [[Set the source object to be visible or not.

              If $visible is set to $false, the source object of the
              proxy ($obj) will be invisible.

              This API works differently to \@ref evas_object_show and
              \@ref evas_object_hide. Once source object is hidden, 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.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif

              @since 1.8
            ]]
         }
         get {
            [[Get the state of the source object visibility.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif

              @since 1.8
            ]]
         }
         values {
            visible: bool; [[$true is source object to be shown, $false
                             otherwise.]]
         }
      }
      @property native_surface {
         set {
            [[Set the native surface of a given image of the canvas

              This function sets a native surface of a given canvas image.
            ]]
            legacy: null;
         }
         get {
            [[Get the native surface of a given image of the canvas

              This function returns the native surface of a given canvas
              image.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif
            ]]
         }
         values {
            surf: Evas_Native_Surface* @nonull; [[The native surface.]]
         }
      }
      @property load_scale_down {
         set {
            [[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.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif
            ]]
         }
         get {
            [[Get the scale down factor of a given image object's source
              image, when loading it.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif
            ]]
         }
         values {
            scale_down: int; [[The scale down factor.]]
         }
      }
      @property scale_hint {
         set {
            [[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.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif
            ]]
         }
         get {
            [[Get the scale hint of a given image of the canvas.

              This function returns the scale hint value of the given image
              object of the canvas.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif
            ]]
         }
         values {
            hint: Evas_Image_Scale_Hint; [[The scale hint, a value in
                                           #Evas_Image_Scale_Hint.]]
         }
      }
      @property source_events {
         set {
            [[Set whether an Evas object is to source events.

              Set whether an Evas object is to repeat events to source.

              If $source is $true, it will make events on $obj to also be
              repeated for the source object (see @.source.set). Even the
              $obj and source geometries are different, the event position
              will be transformed to the source object's space.

              If $source is $false, events occurring on $obj will be
              processed only on it.

              \@if MOBILE \@since_tizen 3.0
              \@elseif WEARABLE \@since_tizen 3.0
              \@endif

              @since 1.8
            ]]
         }
         get {
            [[Determine whether an object is set to source events.

              \@if MOBILE \@since_tizen 3.0
              \@elseif WEARABLE \@since_tizen 3.0
              \@endif

              @since 1.8
            ]]
         }
         values {
            source: bool; [[Whether $obj is to pass events ($true) or not
                            ($false).]]
         }
      }
      @property colorspace {
         set {
            [[Set the colorspace of a given image of the canvas.

              This function sets the colorspace of given canvas image.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif
            ]]
         }
         get {
            [[Get the colorspace of a given image of the canvas.

              This function returns the colorspace of given canvas image.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif
            ]]
         }
         values {
            cspace: Evas_Colorspace; [[The new color space.]]
         }
      }
      @property pixels_get_callback {
         set {
            [[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.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif
            ]]
         }
         values {
            func: Evas_Object_Image_Pixels_Get_Cb @nonull; [[The callback function.]]
            data: void *; [[The data pointer to be passed to $func.]]
         }
      }
      @property data_copy {
         set {
            [[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
              \@ref 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 @.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.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif
            ]]
         }
         values {
            data: void *; [[The raw data to replace.]]
         }
      }
      @property animated_frame {
         set {
            [[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 also \@ref evas_object_image_animated_get,
              @.animated_frame_count.get, @.animated_loop_type.get,
              @.animated_loop_count.get, @.animated_frame_duration_get.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif

              @since 1.1
            ]]
         }
         values {
            frame_index: int; [[The index of current frame.]]
         }
      }
      @property region_support {
         get {
            [[Get the support state of a given image.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif

              @since 1.2
            ]]
            return: bool @warn_unused; [[The region support state.]]
         }
      }
      @property load_error {
         get {
            [[Retrieves a number representing any error that occurred during
              the last loading of the given image object's source image.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif
            ]]
            return: Evas_Load_Error @warn_unused; [[
               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.
            ]]
         }
      }
      @property animated_frame_count {
         get {
            [[Get the total number of frames of the image object.

              This returns total number of frames the image object
              supports (if animated).

              See also \@ref evas_object_image_animated_get,
              @.animated_frame_count.get, @.animated_loop_type.get,
              @.animated_loop_count.get, @.animated_frame_duration_get.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif

              @since 1.1
            ]]
            return: int; [[The number of frames.]]
         }
      }
      @property stride {
         get {
            [[Retrieves the row stride of the given image object.

              The row stride is the number of bytes between the start of a
              row and the start of the next row for image data.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif
            ]]
            return: int @warn_unused; [[The stride of the image (in bytes).]]
         }
      }
      @property animated_loop_type {
         get {
            [[Get the kind of looping the image object does.

              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 also \@ref evas_object_image_animated_get,
              @.animated_frame_count.get, @.animated_loop_type.get,
              @.animated_loop_count.get, @.animated_frame_duration_get.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif

              @since 1.1
            ]]
            return: Evas_Image_Animated_Loop_Hint; [[Loop type of the image object.]]
         }
      }
      @property animated_loop_count {
         get {
            [[Get the number times the animation of the object loops.

              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 also \@ref evas_object_image_animated_get,
              @.animated_frame_count.get, @.animated_loop_type.get,
              @.animated_loop_count.get, @.animated_frame_duration_get.

              \@if MOBILE \@since_tizen 2.3
              \@elseif WEARABLE \@since_tizen 2.3.1
              \@endif

              @since 1.1
            ]]
            return: int; [[The number of loop of an animated image object.]]
         }
      }

      @property scene {
         set {
            [[Set the 3D scene of a given image of the canvas.

              This function sets a 3d scene of a given canvas image.

              @since 1.10
            ]]
	    legacy: null;
         }
         get {
            [[Get the 3D scene of a given image of the canvas.

              This function returns the 3d scene of a given canvas image.

              @since 1.10
            ]]
            legacy: null;
         }
         values {
            scene: Evas.Canvas3D.Scene *; [[3D scene on an image object.]]
         }
      }
      @property orient {
         set {
            [[Set the image orientation.

              This function allows to rotate or flip the image.

              \@if MOBILE \@since_tizen 3.0
              \@elseif WEARABLE \@since_tizen 3.0
              \@endif

              @since 1.14
            ]]
         }
         get {
            [[Get the image orientation.

              \@if MOBILE \@since_tizen 3.0
              \@elseif WEARABLE \@since_tizen 3.0
              \@endif

              @since 1.14
            ]]
         }
         values {
            orient: Evas_Image_Orient; [[The image orientation \@ref Evas_Image_Orient.
                                         Default is #EVAS_IMAGE_ORIENT_NONE.]]
         }
      }
      @property snapshot {
         set {
            [[The content below the Evas_Object_Image will be rendered
              inside it and you can reuse it as a source for any kind
              of effect.

              \@if MOBILE \@since_tizen 3.0
              \@elseif WEARABLE \@since_tizen 3.0
              \@endif

              @since 1.15
            ]]
         }
         get {
            [[Determine wether the Evas_Object_Image replicate the content
              of the canvas below.

              \@if MOBILE \@since_tizen 3.0
              \@elseif WEARABLE \@since_tizen 3.0
              \@endif

              @since 1.15
            ]]
         }
         values {
            s: bool; [[Wether to put the content of the canvas below inside
                       the Evas_Object_Image.]]
         }
      }
      preload_begin {
         [[Begin preloading an image object's image data in the background.]]
         legacy: null;
      }
      data_update_add {
         [[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.

           \@if MOBILE \@since_tizen 2.3
           \@elseif WEARABLE \@since_tizen 2.3.1
           \@endif
         ]]
         params {
            @in x: int; [[X-offset of the region to be updated.]]
            @in y: int; [[Y-offset of the region to be updated.]]
            @in w: int; [[Width of the region to be updated.]]
            @in h: int; [[Height of the region to be updated.]]
         }
      }
      animated_frame_duration_get @const {
         [[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 also \@ref evas_object_image_animated_get,
           @.animated_frame_count.get, @.animated_loop_type.get,
           @.animated_loop_count.get, @.animated_frame_duration_get.

           \@if MOBILE \@since_tizen 2.3
           \@elseif WEARABLE \@since_tizen 2.3.1
           \@endif

           @since 1.1
         ]]
         return: double;
         params {
            @in start_frame: int; [[The first frame.]]
            @in frame_num: int; [[Number of frames in the sequence.]]
         }
      }
      data_set {
         [[Sets the raw image data of the given image object.

           Note that the raw data must be of the same size (see
           \@ref evas_object_image_size_set, which has to be called before
           this one) and colorspace (see @.colorspace.set) of the image.
           If data is $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.

           \@if MOBILE \@since_tizen 2.3
           \@elseif WEARABLE \@since_tizen 2.3.1
           \@endif
         ]]
         params {
            @in data: void *; [[The raw data, or $null.]]
         }
      }
      data_get @const {
         [[Get a pointer to the raw image data of the given image object.

           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 @.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 @.data_update_add to inform data
           changes, if you did any.

           \@if MOBILE \@since_tizen 2.3
           \@elseif WEARABLE \@since_tizen 2.3.1
           \@endif
         ]]
         return: void * @warn_unused; [[ The raw image data.]]
         params {
            @in for_writing: bool; [[Whether the data being retrieved will
                                     be modified ($true) or not ($false).]]
         }
      }
      preload_cancel {
         [[Cancel preloading an image object's image data in the background.]]
         legacy: null;
      }
   }
   implements {
      Eo.Base.constructor;
      Eo.Base.destructor;
      Eo.Base.dbg_info_get;
      Efl.File.file.set;
      Efl.File.file.get;
      Efl.File.mmap.set;
      Efl.File.mmap.get;
      Efl.File.save;
      Efl.Image.animated.get;
      Efl.Image.load_size.set;
      Efl.Image.load_size.get;
      Efl.Image.smooth_scale.set;
      Efl.Image.smooth_scale.get;
      Efl.Gfx.Fill.fill_spread.set;
      Efl.Gfx.Fill.fill_spread.get;
      Efl.Gfx.Fill.fill.set;
      Efl.Gfx.Fill.fill.get;
      Efl.Gfx.View.size.set;
      Efl.Gfx.View.size.get;
      Efl.Gfx.Filter.program.set;
      Evas.Filter.input_alpha;
      Evas.Filter.input_render;
      Evas.Filter.dirty;
   }
}
