From 2219b5434c7245a22e4b39f452bc7315d697b478 Mon Sep 17 00:00:00 2001 From: Yossi Kantor Date: Wed, 12 Mar 2014 16:28:40 +0200 Subject: [PATCH] Eolian: Integration of Evas Image --- src/Makefile_Evas.am | 10 +- src/lib/evas/Evas_Eo.h | 4 + src/lib/evas/canvas/evas_image.eo | 1154 ++++++++++++++++ src/lib/evas/canvas/evas_object_image.c | 1665 ++++------------------- 4 files changed, 1450 insertions(+), 1383 deletions(-) create mode 100644 src/lib/evas/canvas/evas_image.eo diff --git a/src/Makefile_Evas.am b/src/Makefile_Evas.am index b1f075e794..7afd640477 100644 --- a/src/Makefile_Evas.am +++ b/src/Makefile_Evas.am @@ -29,7 +29,9 @@ BUILT_SOURCES += \ lib/evas/canvas/evas.eo.c \ lib/evas/canvas/evas.eo.h \ lib/evas/canvas/evas_grid.eo.c \ - lib/evas/canvas/evas_grid.eo.h + lib/evas/canvas/evas_grid.eo.h \ + lib/evas/canvas/evas_image.eo.c \ + lib/evas/canvas/evas_image.eo.h EXTRA_DIST += \ lib/evas/canvas/evas_object.eo \ @@ -45,7 +47,8 @@ EXTRA_DIST += \ lib/evas/canvas/evas_table.eo \ lib/evas/canvas/evas_common_interface.eo \ lib/evas/canvas/evas.eo \ - lib/evas/canvas/evas_grid.eo + lib/evas/canvas/evas_grid.eo \ + lib/evas/canvas/evas_image.eo lib_LTLIBRARIES += lib/evas/libevas.la noinst_LTLIBRARIES = @@ -74,7 +77,8 @@ nodist_installed_evascanvasheaders_DATA = \ lib/evas/canvas/evas_common_interface.eo.h \ lib/evas/canvas/evas_object.eo.h \ lib/evas/canvas/evas.eo.h \ - lib/evas/canvas/evas_grid.eo.h + lib/evas/canvas/evas_grid.eo.h \ + lib/evas/canvas/evas_image.eo.h noinst_HEADERS = \ lib/evas/include/evas_inline.x \ diff --git a/src/lib/evas/Evas_Eo.h b/src/lib/evas/Evas_Eo.h index bc391f49c2..583b0fd260 100644 --- a/src/lib/evas/Evas_Eo.h +++ b/src/lib/evas/Evas_Eo.h @@ -5641,6 +5641,9 @@ enum const Eo_Class *evas_object_class_get(void) EINA_CONST; #endif +#include"canvas/evas_image.eo.h" + +#if 0 #define EVAS_OBJ_IMAGE_CLASS evas_object_image_class_get() const Eo_Class *evas_object_image_class_get(void) EINA_CONST; @@ -6671,6 +6674,7 @@ enum */ #define evas_obj_image_animated_frame_set(frame_index) EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_FRAME_SET), EO_TYPECHECK(int, frame_index) +#endif /** * @} */ diff --git a/src/lib/evas/canvas/evas_image.eo b/src/lib/evas/canvas/evas_image.eo new file mode 100644 index 0000000000..7cec701306 --- /dev/null +++ b/src/lib/evas/canvas/evas_image.eo @@ -0,0 +1,1154 @@ +class Evas_Image (Evas_Object) +{ + legacy_prefix: evas_object_image; + eo_prefix: evas_obj_image; + properties { + 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. + + @see evas_object_image_load_dpi_get() */ + } + get { + /*@ + 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 */ + } + values { + double dpi; /*@ The new DPI resolution. */ + } + } + source_clip { + set { + /*@ + Clip the proxy object with the source object's clipper. + + @see evas_object_clip_set() + @see evas_object_image_source_set() + @since 1.8 */ + } + get { + /*@ + 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 */ + } + values { + Eina_Bool source_clip; /*@ whether @p obj is clipped by the source clipper. + (@c EINA_TRUE) or not (@c EINA_FALSE) */ + } + } + source { + set { + /*@ + 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() */ + return Eina_Bool; + } + get { + /*@ + 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 */ + } + values { + Evas_Object *src; /*@ Source object to use for the proxy. */ + } + } + filled { + set { + /*@ + 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() */ + } + get { + /*@ + 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 */ + } + values { + Eina_Bool filled; /*@ @c EINA_TRUE, to make the fill property follow + object size or @c EINA_FALSE, otherwise. */ + } + } + 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 @b zero copies + at texture upload time, which is an "expensive" operation. + + @see evas_object_image_content_hint_get() */ + } + get { + /*@ + 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() */ + } + values { + Evas_Image_Content_Hint hint; /*@ The content hint value, one of the + #Evas_Image_Content_Hint ones. */ + } + } + 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. + + @see evas_object_image_load_region_get() */ + } + get { + /*@ + 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() */ + } + values { + int x; /*@ X-offset of the region to be loaded. */ + int y; /*@ Y-offset of the region to be loaded. */ + int w; /*@ Width of the region to be loaded. */ + int h; /*@ Height of the region to be loaded. */ + } + } + 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 @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() */ + } + get { + /*@ + 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. */ + } + values { + Eina_Bool alpha; /*@ Whether to use alpha channel (@c EINA_TRUE) data + or not (@c EINA_FALSE). */ + } + } + load_size { + set { + /*@ + Set the size of a given image object's source image, when loading + it. + + This function sets a new (loading) size for the given canvas + image. + + @see evas_object_image_load_size_get() */ + } + get { + /*@ + Get the size of a given image object's source image, when loading + it. + + @note Use @c NULL pointers on the size components you're not + interested in: they'll be ignored by the function. + + @see evas_object_image_load_size_set() for more details */ + } + values { + int w; /*@ The new width of the image's load size. */ + int h; /*@ The new height of the image's load size. */ + } + } + border { + set { + /*@ + 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 + + Full-size + @endhtmlonly + @image rtf image-borders.png + @image latex image-borders.eps width=\textwidth + @htmlonly + + Full-size + @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() */ + } + get { + /*@ + 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. */ + } + values { + int l; /*@ The border's left width. */ + int r; /*@ The border's right width. */ + int t; /*@ The border's top width. */ + int b; /*@ The border's bottom width. */ + } + } + smooth_scale { + set { + /*@ + Sets whether to use high-quality image scaling algorithm on the + given image object. + + 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. + + @note Image objects get created originally with smooth scaling @b + on. + + @see evas_object_image_smooth_scale_get() */ + } + get { + /*@ + Retrieves whether the given image object is using high-quality + image scaling algorithm. + + @return Whether smooth scale is being used. + + See @ref evas_object_image_smooth_scale_set() for more details. */ + } + values { + Eina_Bool smooth_scale; /*@ Whether to use smooth scale or not. */ + } + } + border_scale { + set { + /*@ + 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() */ + } + get { + /*@ + 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() */ + } + values { + double scale; /*@ The scale factor (default is @c 1.0 - i.e. no scaling) */ + } + } + 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. + + @see evas_object_image_pixels_get_callback_set() */ + } + get { + /*@ + Retrieves whether the given image object is dirty (needs to be redrawn). + + @return Whether the image is dirty. */ + } + values { + Eina_Bool dirty; /*@ Whether the image is dirty. */ + } + } + video_surface { + set { + /*@ + Set the video surface linked to a given image of the canvas + + This function links a video surface to a given canvas image. */ + } + get { + /*@ + 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. */ + surf: const; + } + values { + Evas_Video_Surface *surf; /*@ The new video surface. + @since 1.1 */ + } + } + video_surface_caps { + set { + /*@ Set the video surface capabilities to a given image of the canvas */ + } + get { + /*@ Get the video surface capabilities to a given image of the canvas */ + } + values { + unsigned int caps; /*@ in */ + } + } + load_orientation { + set { + /*@ + Define if the orientation information in the image file should be honored. + + @since 1.1 */ + } + get { + /*@ + Get if the orientation information in the image file should be honored. + + @since 1.1 */ + } + values { + Eina_Bool enable; /*@ @c EINA_TRUE means that it should honor the orientation information */ + } + } + fill_spread { + set { + /*@ + Sets the tiling mode for the given evas image object's fill. + EVAS_TEXTURE_RESTRICT, or EVAS_TEXTURE_PAD. */ + } + get { + /*@ + Retrieves the spread (tiling mode) for the given image object's + fill. + + @return The current spread mode of the image object. */ + } + values { + Evas_Fill_Spread spread; /*@ One of EVAS_TEXTURE_REFLECT, EVAS_TEXTURE_REPEAT, */ + } + } + file { + set { + /*@ + 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 */ + } + get { + /*@ + 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. */ + } + values { + const char *file; /*@ The image file path. */ + const char *key; /*@ The image key in @p file (if its an Eet one), or @c + NULL, otherwise. */ + } + } + border_center_fill { + set { + /*@ + 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() */ + } + get { + /*@ + 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. */ + } + values { + Evas_Border_Fill_Mode fill; /*@ Fill mode of the center region of @p obj (a value in + #Evas_Border_Fill_Mode). */ + } + } + size { + set { + /*@ + 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. */ + } + get { + /*@ + Retrieves the size of the given image object. + + See @ref evas_object_image_size_set() for more details. */ + } + values { + int w; /*@ The new width of the image. */ + int h; /*@ The new height of the image. */ + } + } + source_visible { + set { + /*@ + 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 */ + } + get { + /*@ + 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 */ + } + values { + Eina_Bool visible; /*@ @c EINA_TRUE is source object to be shown, @c EINA_FALSE + otherwise. */ + } + } + fill { + set { + /*@ + 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. */ + } + get { + /*@ + 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. */ + } + values { + Evas_Coord x; /*@ The x coordinate (from the top left corner of the bound + image) to start drawing from. */ + Evas_Coord y; /*@ The y coordinate (from the top left corner of the bound + image) to start drawing from. */ + Evas_Coord w; /*@ The width the bound image will be displayed at. */ + Evas_Coord h; /*@ The height the bound image will be displayed at. */ + } + } + 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 + + @return The native surface of the given canvas image. + + This function returns the native surface of a given canvas image. */ + /*surf: const;*/ + } + values { + Evas_Native_Surface *surf @nonull; /*@ The new native surface. */ + } + } + 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. + + @see evas_object_image_load_scale_down_get() */ + } + get { + /*@ + 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 */ + } + values { + int scale_down; /*@ The scale down factor. */ + } + } + 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. + + @see evas_object_image_scale_hint_get() */ + } + get { + /*@ + 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. */ + } + values { + Evas_Image_Scale_Hint hint; /*@ The scale hint, a value in + #Evas_Image_Scale_Hint. */ + } + } + source_events { + set { + /*@ + 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 */ + } + get { + /*@ + 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 */ + } + values { + Eina_Bool source; /*@ whether @p obj is to pass events (@c EINA_TRUE) or not + (@c EINA_FALSE) */ + } + } + colorspace { + set { + /*@ + Set the colorspace of a given image of the canvas. + + This function sets the colorspace of given canvas image. */ + } + get { + /*@ + 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. */ + } + values { + Evas_Colorspace cspace; /*@ The new color space. */ + } + } + 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. */ + } + values { + Evas_Object_Image_Pixels_Get_Cb func @nonull; /*@ The callback function. */ + void *data; /*@ The data pointer to be passed to @a func. */ + } + } + mmap { + set { + /*@ + 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 */ + } + values { + const Eina_File *f; /*@ The mmaped file */ + const char *key; /*@ The image key in @p file (if its an Eet one), or @c + NULL, otherwise. */ + } + } + 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 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. */ + } + values { + void *data; /*@ The raw data to replace. */ + } + } + 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 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 */ + } + values { + int frame_index; /*@ The index of current frame */ + } + } + region_support { + get { + /*@ + 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 */ + return Eina_Bool @warn_unused; + } + } + load_error { + get { + /*@ + 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. */ + return Evas_Load_Error @warn_unused; + } + } + animated_frame_count { + get { + /*@ + 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 */ + return int; + } + } + stride { + get { + /*@ + Retrieves the row stride of the given image object. + + @return The stride of the image (in bytes). + + The row stride is the number of bytes between the start of a row + and the start of the next row for image data. */ + return int @warn_unused; + } + } + animated { + get { + /*@ + Check if an image object can be animated (have multiple frames) + + @return whether obj support animation + + This returns if the image file of an image object is capable of animation + such as an animated gif file might. This is only useful to be called once + the image object file has been set. + + Example: + @code + extern Evas_Object *obj; + + if (evas_object_image_animated_get(obj)) + { + int frame_count; + int loop_count; + Evas_Image_Animated_Loop_Hint loop_type; + double duration; + + frame_count = evas_object_image_animated_frame_count_get(obj); + printf("This image has %d frames\n",frame_count); + + duration = evas_object_image_animated_frame_duration_get(obj,1,0); + printf("Frame 1's duration is %f. You had better set object's frame to 2 after this duration using timer\n"); + + loop_count = evas_object_image_animated_loop_count_get(obj); + printf("loop count is %d. You had better run loop %d times\n",loop_count,loop_count); + + loop_type = evas_object_image_animated_loop_type_get(obj); + if (loop_type == EVAS_IMAGE_ANIMATED_HINT_LOOP) + printf("You had better set frame like 1->2->3->1->2->3...\n"); + else if (loop_type == EVAS_IMAGE_ANIMATED_HINT_PINGPONG) + printf("You had better set frame like 1->2->3->2->1->2...\n"); + else + printf("Unknown loop type\n"); + + evas_object_image_animated_frame_set(obj,1); + printf("You set image object's frame to 1. You can see frame 1\n"); + } + @endcode + + @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 */ + return Eina_Bool; + } + } + animated_loop_type { + get { + /*@ + 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 */ + return Evas_Image_Animated_Loop_Hint; + } + } + animated_loop_count { + get { + /*@ + 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 */ + return int; + } + } + } + methods { + preload_begin { + /*@ Begin preloading an image object's image data in the background */ + } + 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. */ + + params { + @in int x; /*@ X-offset of the region to be updated. */ + @in int y; /*@ Y-offset of the region to be updated. */ + @in int w; /*@ Width of the region to be updated. */ + @in int h; /*@ Height of the region to be updated. */ + } + } + animated_frame_duration_get { + /*@ + 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 */ + + const; + return double; + params { + @in int start_frame; /*@ The first frame */ + @in int frame_num; /*@ Number of frames in the sequence */ + } + } + save { + /*@ + Save the given image object's contents to an (image) file. + + The extension suffix on @p file will determine which saver + module 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" */ + + const; + return Eina_Bool; + params { + @in const char *file @nonull; /*@ The filename to be used to save the image (extension + obligatory). */ + @in const char *key; /*@ The image key in the file (if an Eet one), or @c NULL, + otherwise. */ + @in const char *flags; /*@ String containing the flags to be used (@c NULL for + none). */ + } + } + data_set { + /*@ + 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() */ + + params { + @in void *data; /*@ The raw data, or @c NULL. */ + } + } + data_get { + /*@ + 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() */ + + const; + return void * @warn_unused; + params { + @in Eina_Bool for_writing; /*@ Whether the data being retrieved will be + modified (@c EINA_TRUE) or not (@c EINA_FALSE). */ + } + } + preload_cancel { + /*@ Cancel preloading an image object's image data in the background */ + } + data_convert { + /*@ + 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. */ + + return void * @warn_unused; + params { + @in Evas_Colorspace to_cspace; /*@ The colorspace to which the image raw data will be converted. */ + } + } + pixels_import { + /*@ + Import pixels from given source to a given canvas image object. + + This function imports pixels from a given source to a given canvas image. */ + + return Eina_Bool; + params { + @in Evas_Pixel_Import_Source *pixels @nonull; /*@ The pixel's source to be imported. */ + } + } + reload { + /*@ + Reload an image object's image data. + + This function reloads the image data bound to image object @p obj. */ + } + } + implements { + Eo_Base::constructor; + Eo_Base::destructor; + Eo_Base::dbg_info_get; + } +} \ No newline at end of file diff --git a/src/lib/evas/canvas/evas_object_image.c b/src/lib/evas/canvas/evas_object_image.c index dd45b0c94c..7adc3ceb56 100644 --- a/src/lib/evas/canvas/evas_object_image.c +++ b/src/lib/evas/canvas/evas_object_image.c @@ -21,8 +21,6 @@ #include -EAPI Eo_Op EVAS_OBJ_IMAGE_BASE_ID = EO_NOOP; - #define MY_CLASS EVAS_OBJ_IMAGE_CLASS #define MY_CLASS_NAME "Evas_Image" @@ -33,7 +31,7 @@ EAPI Eo_Op EVAS_OBJ_IMAGE_BASE_ID = EO_NOOP; static const char o_type[] = "image"; /* private struct for rectangle object internal data */ -typedef struct _Evas_Object_Image Evas_Object_Image; +typedef struct _Evas_Object_Image Evas_Image_Data; typedef struct _Evas_Object_Image_Load_Opts Evas_Object_Image_Load_Opts; typedef struct _Evas_Object_Image_Pixels Evas_Object_Image_Pixels; typedef struct _Evas_Object_Image_State Evas_Object_Image_State; @@ -138,7 +136,7 @@ struct _Evas_Object_Image /* private methods for image objects */ static void evas_object_image_unload(Evas_Object *eo_obj, Eina_Bool dirty); -static void evas_object_image_load(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, Evas_Object_Image *o); +static void evas_object_image_load(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, Evas_Image_Data *o); static Evas_Coord evas_object_image_figure_x_fill(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, Evas_Coord start, Evas_Coord size, Evas_Coord *size_ret); static Evas_Coord evas_object_image_figure_y_fill(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, Evas_Coord start, Evas_Coord size, Evas_Coord *size_ret); @@ -179,10 +177,10 @@ static int evas_object_image_get_opaque_rect(Evas_Object *eo_obj, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h); static int evas_object_image_can_map(Evas_Object *eo_obj); -static void *evas_object_image_data_convert_internal(Evas_Object_Image *o, void *data, Evas_Colorspace to_cspace); +static void *evas_object_image_data_convert_internal(Evas_Image_Data *o, void *data, Evas_Colorspace to_cspace); static void evas_object_image_filled_resize_listener(void *data, Evas *eo_e, Evas_Object *eo_obj, void *einfo); -static void _proxy_unset(Evas_Object *proxy, Evas_Object_Protected_Data *obj, Evas_Object_Image *o); +static void _proxy_unset(Evas_Object *proxy, Evas_Object_Protected_Data *obj, Evas_Image_Data *o); static void _proxy_set(Evas_Object *proxy, Evas_Object *src); static void _proxy_error(Evas_Object *proxy, void *context, void *output, void *surface, int x, int y, Eina_Bool do_async); @@ -269,7 +267,7 @@ Eina_Cow *evas_object_image_state_cow = NULL; } static void -_evas_object_image_cleanup(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, Evas_Object_Image *o) +_evas_object_image_cleanup(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, Evas_Image_Data *o) { EINA_COW_IMAGE_STATE_WRITE_BEGIN(o, state_write) { @@ -321,11 +319,10 @@ _init_cow(Eo *eo_obj) return EINA_TRUE; } -static void -_constructor(Eo *eo_obj, void *class_data, va_list *list EINA_UNUSED) +EOLIAN static void +_evas_image_constructor(Eo *eo_obj, Evas_Image_Data *o) { Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); - Evas_Object_Image *o = class_data; Evas *eo_e; Eo *parent; Evas_Colorspace cspace; @@ -398,7 +395,7 @@ evas_object_image_memfile_set(Evas_Object *eo_obj, void *data, int size, char *f static void _image_init_set(const Eina_File *f, const char *file, const char *key, - Eo *eo_obj, Evas_Object_Protected_Data *obj, Evas_Object_Image *o, + Eo *eo_obj, Evas_Object_Protected_Data *obj, Evas_Image_Data *o, Evas_Image_Load_Opts *lo) { if (o->cur->source) _proxy_unset(eo_obj, obj, o); @@ -469,7 +466,7 @@ _image_init_set(const Eina_File *f, const char *file, const char *key, } static void -_image_done_set(Eo *eo_obj, Evas_Object_Protected_Data *obj, Evas_Object_Image *o) +_image_done_set(Eo *eo_obj, Evas_Object_Protected_Data *obj, Evas_Image_Data *o) { Eina_Bool resize_call = EINA_FALSE; @@ -522,22 +519,12 @@ _image_done_set(Eo *eo_obj, Evas_Object_Protected_Data *obj, Evas_Object_Image * evas_object_change(eo_obj, obj); } -EAPI void -evas_object_image_mmap_set(Evas_Object *eo_obj, const Eina_File *f, const char *key) -{ - eo_do(eo_obj, evas_obj_image_mmap_set(f, key)); -} - -static void -_image_mmap_set(Eo *eo_obj, void *_pd, va_list *list) +EOLIAN static void +_evas_image_mmap_set(Eo *eo_obj, Evas_Image_Data *o, const Eina_File *f, const char *key) { Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); - Evas_Object_Image *o = _pd; Evas_Image_Load_Opts lo; - const Eina_File *f = va_arg(*list, const Eina_File *); - const char *key = va_arg(*list, const char*); - if (o->cur->u.f == f) { if ((!o->cur->key) && (!key)) @@ -555,25 +542,12 @@ _image_mmap_set(Eo *eo_obj, void *_pd, va_list *list) _image_done_set(eo_obj, obj, o); } -EAPI void -evas_object_image_file_set(Evas_Object *eo_obj, const char *file, const char *key) -{ - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - eo_do(eo_obj, evas_obj_image_file_set(file, key)); -} - -static void -_image_file_set(Eo *eo_obj, void *_pd, va_list *list) +EOLIAN static void +_evas_image_file_set(Eo *eo_obj, Evas_Image_Data *o, const char *file, const char *key) { Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); - Evas_Object_Image *o = _pd; Evas_Image_Load_Opts lo; - const char *file = va_arg(*list, const char*); - const char *key = va_arg(*list, const char*); - if ((o->cur->u.file) && (file) && (!strcmp(o->cur->u.file, file))) { if ((!o->cur->key) && (!key)) @@ -597,52 +571,22 @@ _image_file_set(Eo *eo_obj, void *_pd, va_list *list) _image_done_set(eo_obj, obj, o); } -EAPI void -evas_object_image_file_get(const Evas_Object *eo_obj, const char **file, const char **key) +EOLIAN static void +_evas_image_file_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o, const char **file, const char **key) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - if (file) *file = NULL; - if (key) *key = NULL; - return; - MAGIC_CHECK_END(); - eo_do((Eo *)eo_obj, evas_obj_image_file_get(file, key)); -} - -static void -_image_file_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) -{ - const Evas_Object_Image *o = _pd; - const char **file = va_arg(*list, const char**); - const char **key = va_arg(*list, const char**); if (file) *file = o->cur->u.file; if (key) *key = o->cur->key; } -EAPI Eina_Bool -evas_object_image_source_set(Evas_Object *eo_obj, Evas_Object *src) +EOLIAN static Eina_Bool +_evas_image_source_set(Eo *eo_obj, Evas_Image_Data *o, Evas_Object *eo_src) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return EINA_FALSE; - MAGIC_CHECK_END(); - Eina_Bool result = EINA_FALSE; - eo_do(eo_obj, evas_obj_image_source_set(src, &result)); - return result; -} - -static void -_image_source_set(Eo *eo_obj, void *_pd, va_list *list) -{ - Evas_Object_Image *o = _pd; Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); - Evas_Object *eo_src = va_arg(*list, Evas_Object *); - Eina_Bool *result = va_arg(*list, Eina_Bool *); - if (result) *result = EINA_FALSE; - if (obj->delete_me && eo_src) { WRN("Setting deleted object %p as image source %p", eo_src, eo_obj); - return; + return EINA_FALSE; } if (eo_src) { @@ -650,30 +594,26 @@ _image_source_set(Eo *eo_obj, void *_pd, va_list *list) if (src->delete_me) { WRN("Setting object %p to deleted image source %p", eo_src, eo_obj); - return; + return EINA_FALSE; } if (!src->layer) { CRI("No evas surface associated with source object (%p)", eo_obj); - return; + return EINA_FALSE; } if ((obj->layer && src->layer) && (obj->layer->evas != src->layer->evas)) { CRI("Setting object %p from Evas (%p) from another Evas (%p)", eo_src, src->layer->evas, obj->layer->evas); - return; + return EINA_FALSE; } if (eo_src == eo_obj) { CRI("Setting object %p as a source for itself", obj); - return; + return EINA_FALSE; } } - if (o->cur->source == eo_src) - { - if (result) *result = EINA_TRUE; - return; - } + if (o->cur->source == eo_src) return EINA_TRUE; _evas_object_image_cleanup(eo_obj, obj, o); /* Kill the image if any */ @@ -683,27 +623,13 @@ _image_source_set(Eo *eo_obj, void *_pd, va_list *list) if (eo_src) _proxy_set(eo_obj, eo_src); else _proxy_unset(eo_obj, obj, o); - if (result) *result = EINA_TRUE; + return EINA_TRUE; } - -EAPI Evas_Object * -evas_object_image_source_get(const Evas_Object *eo_obj) +EOLIAN static Evas_Object* +_evas_image_source_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return NULL; - MAGIC_CHECK_END(); - Evas_Object *source = NULL; - eo_do((Eo *)eo_obj, evas_obj_image_source_get(&source)); - return source; -} - -static void -_image_source_get(Eo *eo_obj EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list) -{ - const Evas_Object_Image *o = _pd; - Evas_Object **source = va_arg(*list, Evas_Object **); - if (source) *source = o->cur->source; + return o->cur->source; } EAPI Eina_Bool @@ -714,21 +640,9 @@ evas_object_image_source_unset(Evas_Object *eo_obj) return result; } -EAPI void -evas_object_image_source_clip_set(Evas_Object *eo_obj, Eina_Bool source_clip) +EOLIAN static void +_evas_image_source_clip_set(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o, Eina_Bool source_clip) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - - eo_do(eo_obj, evas_obj_image_source_clip_set(source_clip)); -} - -static void -_image_source_clip_set(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) -{ - Evas_Object_Image *o = _pd; - Eina_Bool source_clip = va_arg(*list, int); Evas_Object_Protected_Data *src_obj; source_clip = !!source_clip; @@ -741,42 +655,15 @@ _image_source_clip_set(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) evas_object_change(o->cur->source, src_obj); } -EAPI Eina_Bool -evas_object_image_source_clip_get(const Evas_Object *eo_obj) +EOLIAN static Eina_Bool +_evas_image_source_clip_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return EINA_FALSE; - MAGIC_CHECK_END(); - - Eina_Bool source_clip; - eo_do((Eo*)eo_obj, evas_obj_image_source_clip_get(&source_clip)); - - return source_clip; + return o->proxy_src_clip; } -static void -_image_source_clip_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +EOLIAN static void +_evas_image_source_events_set(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o, Eina_Bool source_events) { - Evas_Object_Image *o = _pd; - Eina_Bool *ret = va_arg(*list, Eina_Bool *); - *ret = o->proxy_src_clip; -} - -EAPI void -evas_object_image_source_events_set(Evas_Object *eo_obj, Eina_Bool source_events) -{ - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - - eo_do(eo_obj, evas_obj_image_source_events_set(source_events)); -} - -static void -_image_source_events_set(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) -{ - Evas_Object_Image *o = _pd; - Eina_Bool source_events = va_arg(*list, int); Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); source_events = !!source_events; @@ -791,33 +678,16 @@ _image_source_events_set(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) //FIXME: Feed mouse events here. } -EAPI Eina_Bool -evas_object_image_source_events_get(const Evas_Object *eo_obj) -{ - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return EINA_FALSE; - MAGIC_CHECK_END(); - - Eina_Bool source_events; - eo_do((Eo*)eo_obj, evas_obj_image_source_events_get(&source_events)); - - return source_events; -} - -static void -_image_source_events_get(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list) +EOLIAN static Eina_Bool +_evas_image_source_events_get(Eo *eo_obj, Evas_Image_Data *_pd EINA_UNUSED) { Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); - Eina_Bool *source_events = va_arg(*list, Eina_Bool *); - if (!source_events) return; - *source_events = obj->proxy->src_events; + return obj->proxy->src_events; } -static void -_dbg_info_get(Eo *eo_obj, void *_pd, va_list *list) +EOLIAN static void +_evas_image_eo_base_dbg_info_get(Eo *eo_obj, Evas_Image_Data *o, Eo_Dbg_Info *root) { - Evas_Object_Image *o = _pd; - Eo_Dbg_Info *root = (Eo_Dbg_Info *) va_arg(*list, Eo_Dbg_Info *); eo_do_super(eo_obj, MY_CLASS, eo_dbg_info_get(root)); Eo_Dbg_Info *group = EO_DBG_INFO_LIST_APPEND(root, MY_CLASS_NAME); @@ -842,22 +712,10 @@ _dbg_info_get(Eo *eo_obj, void *_pd, va_list *list) } } -EAPI void -evas_object_image_source_visible_set(Evas_Object *eo_obj, Eina_Bool visible) -{ - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - - eo_do(eo_obj, evas_obj_image_source_visible_set(visible)); -} - -static void -_image_source_visible_set(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +EOLIAN static void +_evas_image_source_visible_set(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o, Eina_Bool visible) { Evas_Object_Protected_Data *src_obj; - Evas_Object_Image *o = _pd; - Eina_Bool visible = va_arg(*list, int); if (!o->cur->source) return; @@ -877,52 +735,24 @@ _image_source_visible_set(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) //FIXME: Feed mouse events here. } -EAPI Eina_Bool -evas_object_image_source_visible_get(const Evas_Object *eo_obj) +EOLIAN static Eina_Bool +_evas_image_source_visible_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return EINA_FALSE; - MAGIC_CHECK_END(); - + Evas_Object_Protected_Data *src_obj; Eina_Bool visible; - eo_do((Eo*)eo_obj, evas_obj_image_source_visible_get(&visible)); + + if (!o->cur->source) visible = EINA_FALSE; + src_obj = eo_data_scope_get(o->cur->source, EVAS_OBJ_CLASS); + if (src_obj) visible = !src_obj->proxy->src_invisible; + else visible = EINA_FALSE; return visible; } -static void -_image_source_visible_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) -{ - Evas_Object_Protected_Data *src_obj; - Evas_Object_Image *o = _pd; - Eina_Bool *visible = va_arg(*list, Eina_Bool *); - - if (!visible) return; - if (!o->cur->source) *visible = EINA_FALSE; - src_obj = eo_data_scope_get(o->cur->source, EVAS_OBJ_CLASS); - if (src_obj) *visible = !src_obj->proxy->src_invisible; - else *visible = EINA_FALSE; -} - -EAPI void -evas_object_image_border_set(Evas_Object *eo_obj, int l, int r, int t, int b) -{ - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - eo_do(eo_obj, evas_obj_image_border_set(l, r, t, b)); -} - -static void -_image_border_set(Eo *eo_obj, void *_pd, va_list *list) +EOLIAN static void +_evas_image_border_set(Eo *eo_obj, Evas_Image_Data *o, int l, int r, int t, int b) { Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); - Evas_Object_Image *o = _pd; - - int l = va_arg(*list, int); - int r = va_arg(*list, int); - int t = va_arg(*list, int); - int b = va_arg(*list, int); if (l < 0) l = 0; if (r < 0) r = 0; @@ -945,47 +775,18 @@ _image_border_set(Eo *eo_obj, void *_pd, va_list *list) evas_object_change(eo_obj, obj); } -EAPI void -evas_object_image_border_get(const Evas_Object *eo_obj, int *l, int *r, int *t, int *b) +EOLIAN static void +_evas_image_border_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o, int *l, int *r, int *t, int *b) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - if (l) *l = 0; - if (r) *r = 0; - if (t) *t = 0; - if (b) *b = 0; - return; - MAGIC_CHECK_END(); - eo_do((Eo *)eo_obj, evas_obj_image_border_get(l, r, t, b)); -} - -static void -_image_border_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) -{ - const Evas_Object_Image *o = _pd; - int *l = va_arg(*list, int *); - int *r = va_arg(*list, int *); - int *t = va_arg(*list, int *); - int *b = va_arg(*list, int *); if (l) *l = o->cur->border.l; if (r) *r = o->cur->border.r; if (t) *t = o->cur->border.t; if (b) *b = o->cur->border.b; } -EAPI void -evas_object_image_border_center_fill_set(Evas_Object *eo_obj, Evas_Border_Fill_Mode fill) +EOLIAN static void +_evas_image_border_center_fill_set(Eo *eo_obj, Evas_Image_Data *o, Evas_Border_Fill_Mode fill) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - eo_do(eo_obj, evas_obj_image_border_center_fill_set(fill)); -} - -static void -_image_border_center_fill_set(Eo *eo_obj, void *_pd, va_list *list) -{ - Evas_Border_Fill_Mode fill = va_arg(*list, Evas_Border_Fill_Mode); - Evas_Object_Image *o = _pd; if (fill == o->cur->border.fill) return; EINA_COW_IMAGE_STATE_WRITE_BEGIN(o, state_write) state_write->border.fill = fill; @@ -996,41 +797,15 @@ _image_border_center_fill_set(Eo *eo_obj, void *_pd, va_list *list) evas_object_change(eo_obj, obj); } -EAPI Evas_Border_Fill_Mode -evas_object_image_border_center_fill_get(const Evas_Object *eo_obj) +EOLIAN static Evas_Border_Fill_Mode +_evas_image_border_center_fill_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return 0; - MAGIC_CHECK_END(); - Evas_Border_Fill_Mode fill = 0; - eo_do((Eo *)eo_obj, evas_obj_image_border_center_fill_get(&fill)); - return fill; + return o->cur->border.fill; } static void -_image_border_center_fill_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +_evas_image_filled_set(Eo *eo_obj, Evas_Image_Data* o, Eina_Bool setting) { - Evas_Border_Fill_Mode *fill = va_arg(*list, Evas_Border_Fill_Mode *); - const Evas_Object_Image *o = _pd; - if (fill) *fill = o->cur->border.fill; - return; -} - -EAPI void -evas_object_image_filled_set(Evas_Object *eo_obj, Eina_Bool setting) -{ - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - eo_do(eo_obj, evas_obj_image_filled_set(setting)); -} - -static void -_image_filled_set(Eo *eo_obj, void* _pd, va_list *list) -{ - Evas_Object_Image *o = _pd; - - Eina_Bool setting = va_arg(*list, int); setting = !!setting; if (o->filled == setting) return; @@ -1051,40 +826,16 @@ _image_filled_set(Eo *eo_obj, void* _pd, va_list *list) } } -EAPI Eina_Bool -evas_object_image_filled_get(const Evas_Object *eo_obj) +EOLIAN static Eina_Bool +_evas_image_filled_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return 0; - MAGIC_CHECK_END(); - Eina_Bool fill = EINA_FALSE; - eo_do((Eo *)eo_obj, evas_obj_image_filled_get(&fill)); - return fill; + return o->filled; } -static void -_image_filled_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) -{ - const Evas_Object_Image *o = _pd; - Eina_Bool *fill = va_arg(*list, Eina_Bool *); - if (fill) *fill = o->filled; -} - -EAPI void -evas_object_image_border_scale_set(Evas_Object *eo_obj, double scale) -{ - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - eo_do(eo_obj, evas_obj_image_border_scale_set(scale)); -} - -static void -_image_border_scale_set(Eo *eo_obj, void *_pd, va_list *list) +EOLIAN static void +_evas_image_border_scale_set(Eo *eo_obj, Evas_Image_Data *o, double scale) { Evas_Object_Protected_Data *obj; - Evas_Object_Image *o = _pd; - double scale = va_arg(*list, double); if (scale == o->cur->border.scale) return; EINA_COW_IMAGE_STATE_WRITE_BEGIN(o, state_write) @@ -1096,44 +847,16 @@ _image_border_scale_set(Eo *eo_obj, void *_pd, va_list *list) evas_object_change(eo_obj, obj); } -EAPI double -evas_object_image_border_scale_get(const Evas_Object *eo_obj) +EOLIAN static double +_evas_image_border_scale_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return 1.0; - MAGIC_CHECK_END(); - double scale = 1.0; - eo_do((Eo *)eo_obj, evas_obj_image_border_scale_get(&scale)); - return scale; + return o->cur->border.scale; } -static void -_image_border_scale_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) -{ - const Evas_Object_Image *o = _pd; - double *scale = va_arg(*list, double *); - if (scale) *scale = o->cur->border.scale; -} - -EAPI void -evas_object_image_fill_set(Evas_Object *eo_obj, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h) -{ - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - eo_do(eo_obj, evas_obj_image_fill_set(x, y, w, h)); -} - -static void -_image_fill_set(Eo *eo_obj, void *_pd, va_list *list) +EOLIAN static void +_evas_image_fill_set(Eo *eo_obj, Evas_Image_Data *o, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h) { Evas_Object_Protected_Data *obj; - Evas_Object_Image *o = _pd; - - Evas_Coord x = va_arg(*list, Evas_Coord); - Evas_Coord y = va_arg(*list, Evas_Coord); - Evas_Coord w = va_arg(*list, Evas_Coord); - Evas_Coord h = va_arg(*list, Evas_Coord); if (w == 0) return; if (h == 0) return; @@ -1160,51 +883,19 @@ _image_fill_set(Eo *eo_obj, void *_pd, va_list *list) evas_object_change(eo_obj, obj); } -EAPI void -evas_object_image_fill_get(const Evas_Object *eo_obj, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h) +EOLIAN static void +_evas_image_fill_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - if (x) *x = 0; - if (y) *y = 0; - if (w) *w = 0; - if (h) *h = 0; - return; - MAGIC_CHECK_END(); - eo_do((Eo *)eo_obj, evas_obj_image_fill_get(x, y, w, h)); -} - -static void -_image_fill_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) -{ - const Evas_Object_Image *o = _pd; - - Evas_Coord *x = va_arg(*list, Evas_Coord *); - Evas_Coord *y = va_arg(*list, Evas_Coord *); - Evas_Coord *w = va_arg(*list, Evas_Coord *); - Evas_Coord *h = va_arg(*list, Evas_Coord *); - if (x) *x = o->cur->fill.x; if (y) *y = o->cur->fill.y; if (w) *w = o->cur->fill.w; if (h) *h = o->cur->fill.h; } - -EAPI void -evas_object_image_fill_spread_set(Evas_Object *eo_obj, Evas_Fill_Spread spread) -{ - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - eo_do(eo_obj, evas_obj_image_fill_spread_set(spread)); -} - -static void -_image_fill_spread_set(Eo *eo_obj, void *_pd, va_list *list) +EOLIAN static void +_evas_image_fill_spread_set(Eo *eo_obj, Evas_Image_Data *o, Evas_Fill_Spread spread) { Evas_Object_Protected_Data *obj; - Evas_Object_Image *o = _pd; - Evas_Fill_Spread spread = va_arg(*list, Evas_Fill_Spread); if (spread == (Evas_Fill_Spread)o->cur->spread) return; @@ -1217,42 +908,17 @@ _image_fill_spread_set(Eo *eo_obj, void *_pd, va_list *list) evas_object_change(eo_obj, obj); } -EAPI Evas_Fill_Spread -evas_object_image_fill_spread_get(const Evas_Object *eo_obj) +EOLIAN static Evas_Fill_Spread +_evas_image_fill_spread_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return EVAS_TEXTURE_REPEAT; - MAGIC_CHECK_END(); - Evas_Fill_Spread spread = EVAS_TEXTURE_REPEAT; - eo_do((Eo *)eo_obj, evas_obj_image_fill_spread_get(&spread)); - return spread; + return (Evas_Fill_Spread)o->cur->spread;; } -static void -_image_fill_spread_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) -{ - const Evas_Object_Image *o = _pd; - Evas_Fill_Spread *spread = va_arg(*list, Evas_Fill_Spread *); - if (spread) *spread = (Evas_Fill_Spread)o->cur->spread; -} - -EAPI void -evas_object_image_size_set(Evas_Object *eo_obj, int w, int h) -{ - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - eo_do(eo_obj, evas_obj_image_size_set(w, h)); -} - -static void -_image_size_set(Eo *eo_obj, void *_pd, va_list *list) +EOLIAN static void +_evas_image_size_set(Eo *eo_obj, Evas_Image_Data *o, int w, int h) { Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); - int w = va_arg(*list, int); - int h = va_arg(*list, int); - Evas_Object_Image *o = _pd; int stride = 0; _evas_object_image_cleanup(eo_obj, obj, o); @@ -1318,84 +984,29 @@ _image_size_set(Eo *eo_obj, void *_pd, va_list *list) evas_object_change(eo_obj, obj); } -EAPI void -evas_object_image_size_get(const Evas_Object *eo_obj, int *w, int *h) +EOLIAN static void +_evas_image_size_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o, int *w, int *h) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - if (w) *w = 0; - if (h) *h = 0; - return; - MAGIC_CHECK_END(); - eo_do((Eo *)eo_obj, evas_obj_image_size_get(w, h)); -} - -static void -_image_size_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) -{ - const Evas_Object_Image *o = _pd; - int *w = va_arg(*list, int *); - int *h = va_arg(*list, int *); if (w) *w = o->cur->image.w; if (h) *h = o->cur->image.h; } -EAPI int -evas_object_image_stride_get(const Evas_Object *eo_obj) +EOLIAN static int +_evas_image_stride_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return 0; - MAGIC_CHECK_END(); - int stride = 0; - eo_do((Eo *)eo_obj, evas_obj_image_stride_get(&stride)); - return stride; + return o->cur->image.stride;; } -static void -_image_stride_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +EOLIAN static Evas_Load_Error +_evas_image_load_error_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o) { - int *stride = va_arg(*list, int *); - const Evas_Object_Image *o = _pd; - if (stride) *stride = o->cur->image.stride; + return o->load_error; } -EAPI Evas_Load_Error -evas_object_image_load_error_get(const Evas_Object *eo_obj) -{ - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return 0; - MAGIC_CHECK_END(); - Evas_Load_Error load_error = 0; - eo_do((Eo *)eo_obj, evas_obj_image_load_error_get(&load_error)); - return load_error; -} - -static void -_image_load_error_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) -{ - Evas_Load_Error *load_error = va_arg(*list, Evas_Load_Error *); - const Evas_Object_Image *o = _pd; - if (load_error) *load_error = o->load_error; -} - -EAPI void * -evas_object_image_data_convert(Evas_Object *eo_obj, Evas_Colorspace to_cspace) -{ - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return NULL; - MAGIC_CHECK_END(); - void *data = NULL; - eo_do(eo_obj, evas_obj_image_data_convert(to_cspace, &data)); - return data; -} - -static void -_image_data_convert(Eo *eo_obj, void *_pd, va_list *list) +EOLIAN static void* +_evas_image_data_convert(Eo *eo_obj, Evas_Image_Data *o, Evas_Colorspace to_cspace) { Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); - Evas_Object_Image *o = _pd; - Evas_Colorspace to_cspace = va_arg(*list, Evas_Colorspace); - void **ret_data = va_arg(*list, void **); - if (ret_data) *ret_data = NULL; DATA32 *data; void* result = NULL; @@ -1404,10 +1015,10 @@ _image_data_convert(Eo *eo_obj, void *_pd, va_list *list) o->preloading = EINA_FALSE; obj->layer->evas->engine.func->image_data_preload_cancel(obj->layer->evas->engine.data.output, o->engine_data, eo_obj); } - if (!o->engine_data) return; + if (!o->engine_data) return NULL; if (o->video_surface) o->pixels->video.update_pixels(o->pixels->video.data, eo_obj, &o->pixels->video); - if (o->cur->cspace == to_cspace) return; + if (o->cur->cspace == to_cspace) return NULL; data = NULL; o->engine_data = obj->layer->evas->engine.func->image_data_get(obj->layer->evas->engine.data.output, o->engine_data, 0, &data, &o->load_error); result = evas_object_image_data_convert_internal(o, data, to_cspace); @@ -1416,27 +1027,16 @@ _image_data_convert(Eo *eo_obj, void *_pd, va_list *list) o->engine_data = obj->layer->evas->engine.func->image_data_put(obj->layer->evas->engine.data.output, o->engine_data, data); } - if (ret_data) *ret_data = result; + return result; } -EAPI void -evas_object_image_data_set(Evas_Object *eo_obj, void *data) -{ - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - eo_do(eo_obj, evas_obj_image_data_set(data)); -} - -static void -_image_data_set(Eo *eo_obj, void *_pd, va_list *list) +EOLIAN static void +_evas_image_data_set(Eo *eo_obj, Evas_Image_Data *o, void *data) { Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); - Evas_Object_Image *o = _pd; void *p_data; Eina_Bool resize_call = EINA_FALSE; - void *data = va_arg(*list, void *); evas_render_rendering_wait(obj->layer->evas); @@ -1522,30 +1122,13 @@ _image_data_set(Eo *eo_obj, void *_pd, va_list *list) if (resize_call) evas_object_inform_call_image_resize(eo_obj); } -EAPI void * -evas_object_image_data_get(const Evas_Object *eo_obj, Eina_Bool for_writing) +EOLIAN static void* +_evas_image_data_get(Eo *eo_obj, Evas_Image_Data *_pd EINA_UNUSED, Eina_Bool for_writing) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return NULL; - MAGIC_CHECK_END(); - void *data = NULL; - eo_do((Eo *)eo_obj, evas_obj_image_data_get(for_writing, &data)); - return data; -} - -static void -_image_data_get(Eo *eo_obj, void *_pd, va_list *list) -{ - Evas_Object_Image *o = (Evas_Object_Image *) _pd; - Eina_Bool for_writing = va_arg(*list, int); - void **ret_data = va_arg(*list, void **); + Evas_Image_Data *o = (Evas_Image_Data *) _pd; DATA32 *data; - if (!o->engine_data) - { - if (ret_data) *ret_data = NULL; - return; - } + if (!o->engine_data) return NULL; Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); @@ -1563,11 +1146,7 @@ _image_data_get(Eo *eo_obj, void *_pd, va_list *list) o->engine_data = obj->layer->evas->engine.func->image_data_get(obj->layer->evas->engine.data.output, o->engine_data, for_writing, &data, &o->load_error); /* if we fail to get engine_data, we have to return NULL */ - if (!o->engine_data) - { - if (ret_data) *ret_data = NULL; - return; - } + if (!o->engine_data) return NULL; if (o->engine_data) { @@ -1594,7 +1173,7 @@ _image_data_get(Eo *eo_obj, void *_pd, va_list *list) EVAS_OBJECT_WRITE_IMAGE_FREE_FILE_AND_KEY(o); } - if (ret_data) *ret_data = data; + return data; } EAPI void @@ -1612,7 +1191,7 @@ evas_object_image_preload(Evas_Object *eo_obj, Eina_Bool cancel) static void _image_preload_internal(Eo *eo_obj, void *_pd, Eina_Bool cancel) { - Evas_Object_Image *o = _pd; + Evas_Image_Data *o = _pd; if (!o->engine_data) { @@ -1645,33 +1224,22 @@ _image_preload_internal(Eo *eo_obj, void *_pd, Eina_Bool cancel) } } -static void -_image_preload_begin(Eo *eo_obj, void *_pd, va_list *list EINA_UNUSED) +EOLIAN static void +_evas_image_preload_begin(Eo *eo_obj, Evas_Image_Data *_pd EINA_UNUSED) { _image_preload_internal(eo_obj, _pd, EINA_FALSE); } -static void -_image_preload_cancel(Eo *eo_obj, void *_pd, va_list *list EINA_UNUSED) +EOLIAN static void +_evas_image_preload_cancel(Eo *eo_obj, Evas_Image_Data *_pd EINA_UNUSED) { _image_preload_internal(eo_obj, _pd, EINA_TRUE); } -EAPI void -evas_object_image_data_copy_set(Evas_Object *eo_obj, void *data) -{ - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - eo_do(eo_obj, evas_obj_image_data_copy_set(data)); -} - -static void -_image_data_copy_set(Eo *eo_obj, void *_pd, va_list *list) +EOLIAN static void +_evas_image_data_copy_set(Eo *eo_obj, Evas_Image_Data *o, void *data) { Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); - Evas_Object_Image *o = _pd; - void *data = va_arg(*list, void *); if (!data) return; _evas_object_image_cleanup(eo_obj, obj, o); @@ -1722,26 +1290,12 @@ _image_data_copy_set(Eo *eo_obj, void *_pd, va_list *list) EVAS_OBJECT_WRITE_IMAGE_FREE_FILE_AND_KEY(o); } -EAPI void -evas_object_image_data_update_add(Evas_Object *eo_obj, int x, int y, int w, int h) +EOLIAN static void +_evas_image_data_update_add(Eo *eo_obj, Evas_Image_Data *o, int x, int y, int w, int h) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - eo_do(eo_obj, evas_obj_image_data_update_add(x, y, w, h)); -} - -static void -_image_data_update_add(Eo *eo_obj, void *_pd, va_list *list) -{ - Evas_Object_Image *o = _pd; Eina_Rectangle *r; int cnt; - int x = va_arg(*list, int); - int y = va_arg(*list, int); - int w = va_arg(*list, int); - int h = va_arg(*list, int); RECTS_CLIP_TO_RECT(x, y, w, h, 0, 0, o->cur->image.w, o->cur->image.h); if ((w <= 0) || (h <= 0)) return; if (!o->written) return; @@ -1777,21 +1331,10 @@ _image_data_update_add(Eo *eo_obj, void *_pd, va_list *list) evas_object_change(eo_obj, obj); } -EAPI void -evas_object_image_alpha_set(Evas_Object *eo_obj, Eina_Bool has_alpha) -{ - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - eo_do(eo_obj, evas_obj_image_alpha_set(has_alpha)); -} - -static void -_image_alpha_set(Eo *eo_obj, void *_pd, va_list *list) +EOLIAN static void +_evas_image_alpha_set(Eo *eo_obj, Evas_Image_Data *o, Eina_Bool has_alpha) { Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); - Evas_Object_Image *o = _pd; - Eina_Bool has_alpha = va_arg(*list, int); if ((o->preloading) && (o->engine_data)) { @@ -1843,41 +1386,16 @@ _image_alpha_set(Eo *eo_obj, void *_pd, va_list *list) EVAS_OBJECT_WRITE_IMAGE_FREE_FILE_AND_KEY(o); } - -EAPI Eina_Bool -evas_object_image_alpha_get(const Evas_Object *eo_obj) +EOLIAN static Eina_Bool +_evas_image_alpha_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return 0; - MAGIC_CHECK_END(); - Eina_Bool has_alpha = EINA_FALSE; - eo_do((Eo *)eo_obj, evas_obj_image_alpha_get(&has_alpha)); - return has_alpha; + return o->cur->has_alpha; } -static void -_image_alpha_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) -{ - Eina_Bool *has_alpha = va_arg(*list, Eina_Bool *); - const Evas_Object_Image *o = _pd; - *has_alpha = o->cur->has_alpha; -} - -EAPI void -evas_object_image_smooth_scale_set(Evas_Object *eo_obj, Eina_Bool smooth_scale) -{ - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - eo_do(eo_obj, evas_obj_image_smooth_scale_set(smooth_scale)); -} - -static void -_image_smooth_scale_set(Eo *eo_obj, void *_pd, va_list *list) +EOLIAN static void +_evas_image_smooth_scale_set(Eo *eo_obj, Evas_Image_Data *o, Eina_Bool smooth_scale) { Evas_Object_Protected_Data *obj; - Eina_Bool smooth_scale = va_arg(*list, int); - Evas_Object_Image *o = _pd; if (((smooth_scale) && (o->cur->smooth_scale)) || ((!smooth_scale) && (!o->cur->smooth_scale))) @@ -1891,39 +1409,16 @@ _image_smooth_scale_set(Eo *eo_obj, void *_pd, va_list *list) evas_object_change(eo_obj, obj); } -EAPI Eina_Bool -evas_object_image_smooth_scale_get(const Evas_Object *eo_obj) +EOLIAN static Eina_Bool +_evas_image_smooth_scale_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return 0; - MAGIC_CHECK_END(); - Eina_Bool smooth_scale = EINA_FALSE; - eo_do((Eo *)eo_obj, evas_obj_image_smooth_scale_get(&smooth_scale)); - return smooth_scale; + return o->cur->smooth_scale; } -static void -_image_smooth_scale_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) -{ - Eina_Bool *smooth_scale = va_arg(*list, Eina_Bool *); - const Evas_Object_Image *o = _pd; - if (smooth_scale) *smooth_scale = o->cur->smooth_scale; -} - -EAPI void -evas_object_image_reload(Evas_Object *eo_obj) -{ - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - eo_do(eo_obj, evas_obj_image_reload()); -} - -static void -_image_reload(Eo *eo_obj, void *_pd, va_list *list EINA_UNUSED) +EOLIAN static void +_evas_image_reload(Eo *eo_obj, Evas_Image_Data *o) { Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); - Evas_Object_Image *o = _pd; if ((o->preloading) && (o->engine_data)) { @@ -1952,30 +1447,13 @@ _image_reload(Eo *eo_obj, void *_pd, va_list *list EINA_UNUSED) evas_object_change(eo_obj, obj); } -EAPI Eina_Bool -evas_object_image_save(const Evas_Object *eo_obj, const char *file, const char *key, const char *flags) +EOLIAN static Eina_Bool +_evas_image_save(Eo *eo_obj, Evas_Image_Data *o, const char *file, const char *key, const char *flags) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return 0; - MAGIC_CHECK_END(); - Eina_Bool result = EINA_FALSE; - eo_do((Eo *)eo_obj, evas_obj_image_save(file, key, flags, &result)); - return result; -} - -static void _image_save(Eo *eo_obj, void *_pd, va_list *list) -{ - const char *file = va_arg(*list, const char *); - const char *key = va_arg(*list, const char *); - const char *flags = va_arg(*list, const char *); - Eina_Bool *result = va_arg(*list, Eina_Bool *); - if (result) *result = 0; - DATA32 *data = NULL; int quality = 80, compress = 9, ok = 0; RGBA_Image *im; - Evas_Object_Image *o = _pd; - if (!o->engine_data) return; + if (!o->engine_data) return 0; Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); o->engine_data = obj->layer->evas->engine.func->image_data_get(obj->layer->evas->engine.data.output, o->engine_data, 0, &data, &o->load_error); if (flags) @@ -2023,32 +1501,16 @@ static void _image_save(Eo *eo_obj, void *_pd, va_list *list) o->engine_data = obj->layer->evas->engine.func->image_data_put(obj->layer->evas->engine.data.output, o->engine_data, data); - if (result) *result = ok; + return ok; } -EAPI Eina_Bool -evas_object_image_pixels_import(Evas_Object *eo_obj, Evas_Pixel_Import_Source *pixels) -{ - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return EINA_FALSE; - MAGIC_CHECK_END(); - Eina_Bool result = EINA_FALSE; - eo_do(eo_obj, evas_obj_image_pixels_import(pixels, &result)); - return result; -} - -static void -_image_pixels_import(Eo *eo_obj, void *_pd, va_list *list) +EOLIAN static Eina_Bool +_evas_image_pixels_import(Eo *eo_obj, Evas_Image_Data *o, Evas_Pixel_Import_Source *pixels) { Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); - Evas_Object_Image *o = _pd; - - Evas_Pixel_Import_Source *pixels = va_arg(*list, Evas_Pixel_Import_Source *); - Eina_Bool *result = va_arg(*list, Eina_Bool *); - if (result) *result = 0; _evas_object_image_cleanup(eo_obj, obj, o); - if ((pixels->w != o->cur->image.w) || (pixels->h != o->cur->image.h)) return; + if ((pixels->w != o->cur->image.w) || (pixels->h != o->cur->image.h)) return 0; switch (pixels->format) { @@ -2105,29 +1567,15 @@ _image_pixels_import(Eo *eo_obj, void *_pd, va_list *list) } break; default: - return; + return 0; break; } - if (result) *result = 1; - return; + return 1; } -EAPI void -evas_object_image_pixels_get_callback_set(Evas_Object *eo_obj, Evas_Object_Image_Pixels_Get_Cb func, void *data) +EOLIAN static void +_evas_image_pixels_get_callback_set(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o, Evas_Object_Image_Pixels_Get_Cb func, void *data) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - eo_do(eo_obj, evas_obj_image_pixels_get_callback_set(func, data)); -} - -static void -_image_pixels_get_callback_set(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) -{ - Evas_Object_Image_Pixels_Get_Cb func = va_arg(*list, Evas_Object_Image_Pixels_Get_Cb); - void *data = va_arg(*list, void *); - Evas_Object_Image *o = _pd; - EINA_COW_PIXEL_WRITE_BEGIN(o, pixi_write) { pixi_write->func.get_pixels = func; @@ -2136,21 +1584,10 @@ _image_pixels_get_callback_set(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) EINA_COW_PIXEL_WRITE_END(o, pixi_write); } -EAPI void -evas_object_image_pixels_dirty_set(Evas_Object *eo_obj, Eina_Bool dirty) +EOLIAN static void +_evas_image_pixels_dirty_set(Eo *eo_obj, Evas_Image_Data *o, Eina_Bool dirty) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - eo_do(eo_obj, evas_obj_image_pixels_dirty_set(dirty)); -} - -static void -_image_pixels_dirty_set(Eo *eo_obj, void *_pd, va_list *list) -{ - Eina_Bool dirty = va_arg(*list, int); Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); - Evas_Object_Image *o = _pd; if (dirty) o->dirty_pixels = EINA_TRUE; else o->dirty_pixels = EINA_FALSE; @@ -2158,42 +1595,15 @@ _image_pixels_dirty_set(Eo *eo_obj, void *_pd, va_list *list) evas_object_change(eo_obj, obj); } -EAPI Eina_Bool -evas_object_image_pixels_dirty_get(const Evas_Object *eo_obj) +EOLIAN static Eina_Bool +_evas_image_pixels_dirty_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return 0; - MAGIC_CHECK_END(); - Eina_Bool dirty = EINA_FALSE; - eo_do((Eo *)eo_obj, evas_obj_image_pixels_dirty_get(&dirty)); - return dirty; + return (o->dirty_pixels ? 1 : 0); } -static void -_image_pixels_dirty_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +EOLIAN static void +_evas_image_load_dpi_set(Eo *eo_obj, Evas_Image_Data *o, double dpi) { - Eina_Bool *dirty = va_arg(*list, Eina_Bool *); - const Evas_Object_Image *o = _pd; - - *dirty = (o->dirty_pixels ? 1 : 0); -} - -EAPI void -evas_object_image_load_dpi_set(Evas_Object *eo_obj, double dpi) -{ - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - eo_do(eo_obj, evas_obj_image_load_dpi_set(dpi)); -} - -static void -_image_load_dpi_set(Eo *eo_obj, void *_pd, va_list *list) -{ - double dpi = va_arg(*list, double); - - Evas_Object_Image *o = _pd; - if (dpi == o->load_opts->dpi) return; EINA_COW_LOAD_OPTS_WRITE_BEGIN(o, low) @@ -2211,42 +1621,15 @@ _image_load_dpi_set(Eo *eo_obj, void *_pd, va_list *list) } } -EAPI double -evas_object_image_load_dpi_get(const Evas_Object *eo_obj) +EOLIAN static double +_evas_image_load_dpi_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return 0.0; - MAGIC_CHECK_END(); - double dpi = 0.0; - eo_do((Eo *)eo_obj, evas_obj_image_load_dpi_get(&dpi)); - return dpi; + return o->load_opts->dpi; } -static void -_image_load_dpi_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +EOLIAN static void +_evas_image_load_size_set(Eo *eo_obj, Evas_Image_Data *o, int w, int h) { - const Evas_Object_Image *o = _pd; - double *dpi = va_arg(*list, double *); - *dpi = o->load_opts->dpi; -} - -EAPI void -evas_object_image_load_size_set(Evas_Object *eo_obj, int w, int h) -{ - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - eo_do(eo_obj, evas_obj_image_load_size_set(w, h)); -} - -static void -_image_load_size_set(Eo *eo_obj, void *_pd, va_list *list) -{ - int w = va_arg(*list, int); - int h = va_arg(*list, int); - - Evas_Object_Image *o = _pd; - if ((o->load_opts->w == w) && (o->load_opts->h == h)) return; EINA_COW_LOAD_OPTS_WRITE_BEGIN(o, low) @@ -2268,42 +1651,16 @@ _image_load_size_set(Eo *eo_obj, void *_pd, va_list *list) o->proxyerror = 0; } -EAPI void -evas_object_image_load_size_get(const Evas_Object *eo_obj, int *w, int *h) +EOLIAN static void +_evas_image_load_size_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o, int *w, int *h) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - eo_do((Eo *)eo_obj, evas_obj_image_load_size_get(w, h)); -} - -static void -_image_load_size_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) -{ - int *w = va_arg(*list, int *); - int *h = va_arg(*list, int *); - const Evas_Object_Image *o = _pd; - if (w) *w = o->load_opts->w; if (h) *h = o->load_opts->h; } -EAPI void -evas_object_image_load_scale_down_set(Evas_Object *eo_obj, int scale_down) +EOLIAN static void +_evas_image_load_scale_down_set(Eo *eo_obj, Evas_Image_Data *o, int scale_down) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - eo_do(eo_obj, evas_obj_image_load_scale_down_set(scale_down)); -} - -static void -_image_load_scale_down_set(Eo *eo_obj, void *_pd, va_list *list) -{ - int scale_down = va_arg(*list, int); - - Evas_Object_Image *o = _pd; - if (o->load_opts->scale_down_by == scale_down) return; EINA_COW_LOAD_OPTS_WRITE_BEGIN(o, low) low->scale_down_by = scale_down; @@ -2320,44 +1677,15 @@ _image_load_scale_down_set(Eo *eo_obj, void *_pd, va_list *list) } } -EAPI int -evas_object_image_load_scale_down_get(const Evas_Object *eo_obj) +EOLIAN static int +_evas_image_load_scale_down_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return 0; - MAGIC_CHECK_END(); - int scale_down = 0; - eo_do((Eo *)eo_obj, evas_obj_image_load_scale_down_get(&scale_down)); - return scale_down; + return o->load_opts->scale_down_by; } -static void -_image_load_scale_down_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +EOLIAN static void +_evas_image_load_region_set(Eo *eo_obj, Evas_Image_Data *o, int x, int y, int w, int h) { - int *scale_down = va_arg(*list, int *); - const Evas_Object_Image *o = _pd; - *scale_down = o->load_opts->scale_down_by; -} - -EAPI void -evas_object_image_load_region_set(Evas_Object *eo_obj, int x, int y, int w, int h) -{ - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - eo_do(eo_obj, evas_obj_image_load_region_set(x, y, w, h)); -} - -static void -_image_load_region_set(Eo *eo_obj, void *_pd, va_list *list) -{ - int x = va_arg(*list, int); - int y = va_arg(*list, int); - int w = va_arg(*list, int); - int h = va_arg(*list, int); - - Evas_Object_Image *o = _pd; - if ((o->load_opts->region.x == x) && (o->load_opts->region.y == y) && (o->load_opts->region.w == w) && (o->load_opts->region.h == h)) return; @@ -2381,45 +1709,18 @@ _image_load_region_set(Eo *eo_obj, void *_pd, va_list *list) } } -EAPI void -evas_object_image_load_region_get(const Evas_Object *eo_obj, int *x, int *y, int *w, int *h) +EOLIAN static void +_evas_image_load_region_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o, int *x, int *y, int *w, int *h) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - eo_do((Eo *)eo_obj, evas_obj_image_load_region_get(x, y, w, h)); -} - -static void -_image_load_region_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) -{ - int *x = va_arg(*list, int *); - int *y = va_arg(*list, int *); - int *w = va_arg(*list, int *); - int *h = va_arg(*list, int *); - const Evas_Object_Image *o = _pd; - if (x) *x = o->load_opts->region.x; if (y) *y = o->load_opts->region.y; if (w) *w = o->load_opts->region.w; if (h) *h = o->load_opts->region.h; } -EAPI void -evas_object_image_load_orientation_set(Evas_Object *eo_obj, Eina_Bool enable) +EOLIAN static void +_evas_image_load_orientation_set(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o, Eina_Bool enable) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - eo_do(eo_obj, evas_obj_image_load_orientation_set(enable)); -} - -static void -_image_load_orientation_set(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) -{ - Eina_Bool enable = va_arg(*list, int); - Evas_Object_Image *o = _pd; - if (o->load_opts->orientation == !!enable) return; EINA_COW_LOAD_OPTS_WRITE_BEGIN(o, low) @@ -2427,40 +1728,16 @@ _image_load_orientation_set(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) EINA_COW_LOAD_OPTS_WRITE_END(o, low); } -EAPI Eina_Bool -evas_object_image_load_orientation_get(const Evas_Object *eo_obj) +EOLIAN static Eina_Bool +_evas_image_load_orientation_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return EINA_FALSE; - MAGIC_CHECK_END(); - Eina_Bool enable = EINA_FALSE; - eo_do((Eo *)eo_obj, evas_obj_image_load_orientation_get(&enable)); - return enable; + return o->load_opts->orientation;; } -static void -_image_load_orientation_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +EOLIAN static void +_evas_image_colorspace_set(Eo *eo_obj, Evas_Image_Data *o, Evas_Colorspace cspace) { - Eina_Bool *enable = va_arg(*list, Eina_Bool *); - const Evas_Object_Image *o = _pd; - *enable = o->load_opts->orientation; -} - -EAPI void -evas_object_image_colorspace_set(Evas_Object *eo_obj, Evas_Colorspace cspace) -{ - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - eo_do(eo_obj, evas_obj_image_colorspace_set(cspace)); -} - -static void -_image_colorspace_set(Eo *eo_obj, void *_pd, va_list *list) -{ - Evas_Colorspace cspace = va_arg(*list, Evas_Colorspace); Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); - Evas_Object_Image *o = _pd; _evas_object_image_cleanup(eo_obj, obj, o); @@ -2472,40 +1749,16 @@ _image_colorspace_set(Eo *eo_obj, void *_pd, va_list *list) obj->layer->evas->engine.func->image_colorspace_set(obj->layer->evas->engine.data.output, o->engine_data, cspace); } -EAPI Evas_Colorspace -evas_object_image_colorspace_get(const Evas_Object *eo_obj) +EOLIAN static Evas_Colorspace +_evas_image_colorspace_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return EVAS_COLORSPACE_ARGB8888; - MAGIC_CHECK_END(); - Evas_Colorspace cspace = EVAS_COLORSPACE_ARGB8888; - eo_do((Eo *)eo_obj, evas_obj_image_colorspace_get(&cspace)); - return cspace; + return o->cur->cspace; } -static void -_image_colorspace_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +EOLIAN static void +_evas_image_video_surface_set(Eo *eo_obj, Evas_Image_Data *o, Evas_Video_Surface *surf) { - Evas_Colorspace *cspace = va_arg(*list, Evas_Colorspace *); - const Evas_Object_Image *o = _pd; - *cspace = o->cur->cspace; -} - -EAPI void -evas_object_image_video_surface_set(Evas_Object *eo_obj, Evas_Video_Surface *surf) -{ - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - eo_do(eo_obj, evas_obj_image_video_surface_set(surf)); -} - -static void -_image_video_surface_set(Eo *eo_obj, void *_pd, va_list *list) -{ - Evas_Video_Surface *surf = va_arg(*list, Evas_Video_Surface *); Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); - Evas_Object_Image *o = _pd; _evas_object_image_cleanup(eo_obj, obj, o); if (o->video_surface) @@ -2559,41 +1812,16 @@ _image_video_surface_set(Eo *eo_obj, void *_pd, va_list *list) } } -EAPI const Evas_Video_Surface * -evas_object_image_video_surface_get(const Evas_Object *eo_obj) +EOLIAN static const Evas_Video_Surface* +_evas_image_video_surface_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return NULL; - MAGIC_CHECK_END(); - const Evas_Video_Surface *surf = NULL; - eo_do((Eo *)eo_obj, evas_obj_image_video_surface_get(&surf)); - return surf; + return (!o->video_surface ? NULL : &o->pixels->video); } -static void -_image_video_surface_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +EOLIAN static void +_evas_image_video_surface_caps_set(Eo *eo_obj, Evas_Image_Data *o, unsigned int caps) { - const Evas_Video_Surface **surf = va_arg(*list, const Evas_Video_Surface **); - const Evas_Object_Image *o = _pd; - - *surf = (!o->video_surface ? NULL : &o->pixels->video); -} - -EAPI void -evas_object_image_video_surface_caps_set(Evas_Object *eo_obj, unsigned int caps) -{ - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - eo_do(eo_obj, evas_obj_image_video_surface_caps_set(caps)); -} - -static void -_image_video_surface_caps_set(Eo *eo_obj, void *_pd, va_list *list) -{ - unsigned int caps = va_arg(*list, unsigned int); Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); - Evas_Object_Image *o = _pd; _evas_object_image_cleanup(eo_obj, obj, o); @@ -2605,24 +1833,10 @@ _image_video_surface_caps_set(Eo *eo_obj, void *_pd, va_list *list) EINA_COW_PIXEL_WRITE_END(o, pixi_write) } -EAPI unsigned int -evas_object_image_video_surface_caps_get(const Evas_Object *eo_obj) +EOLIAN static unsigned int +_evas_image_video_surface_caps_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return 0; - MAGIC_CHECK_END(); - unsigned int caps = ~0x0; - eo_do((Eo *)eo_obj, evas_obj_image_video_surface_caps_get(&caps)); - return caps; -} - -static void -_image_video_surface_caps_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) -{ - unsigned int *caps = va_arg(*list, unsigned int *); - const Evas_Object_Image *o = _pd; - - *caps = (!o->video_surface ? 0 : o->pixels->video_caps); + return (!o->video_surface ? 0 : o->pixels->video_caps); } static void @@ -2645,13 +1859,10 @@ evas_object_image_native_surface_set(Evas_Object *eo_obj, Evas_Native_Surface *s eo_do(eo_obj, evas_obj_image_native_surface_set(surf)); } -static void -_image_native_surface_set(Eo *eo_obj, void *_pd, va_list *list) +EOLIAN static void +_evas_image_native_surface_set(Eo *eo_obj, Evas_Image_Data *o, Evas_Native_Surface *surf) { - Evas_Native_Surface *surf = va_arg(*list, Evas_Native_Surface *); - Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); - Evas_Object_Image *o = _pd; evas_render_rendering_wait(obj->layer->evas); @@ -2663,45 +1874,24 @@ _image_native_surface_set(Eo *eo_obj, void *_pd, va_list *list) o->engine_data = obj->layer->evas->engine.func->image_native_set(obj->layer->evas->engine.data.output, o->engine_data, surf); } -EAPI Evas_Native_Surface * -evas_object_image_native_surface_get(const Evas_Object *eo_obj) +EOLIAN static Evas_Native_Surface* +_evas_image_native_surface_get(Eo *eo_obj, Evas_Image_Data *o) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return NULL; - MAGIC_CHECK_END(); - Evas_Native_Surface *surf = NULL; - eo_do((Eo *)eo_obj, evas_obj_image_native_surface_get(&surf)); + Evas_Native_Surface *surf; + + Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); + + surf = + (!obj->layer->evas->engine.func->image_native_get ? NULL : + obj->layer->evas->engine.func->image_native_get(obj->layer->evas->engine.data.output, o->engine_data)); + return surf; } -static void -_image_native_surface_get(Eo *eo_obj, void *_pd, va_list *list) +EOLIAN static void +_evas_image_scale_hint_set(Eo *eo_obj, Evas_Image_Data *o, Evas_Image_Scale_Hint hint) { - Evas_Native_Surface **surf = va_arg(*list, Evas_Native_Surface **); - Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); - const Evas_Object_Image *o = _pd; - - *surf = - (!obj->layer->evas->engine.func->image_native_get ? NULL : - obj->layer->evas->engine.func->image_native_get(obj->layer->evas->engine.data.output, o->engine_data)); -} - -EAPI void -evas_object_image_scale_hint_set(Evas_Object *eo_obj, Evas_Image_Scale_Hint hint) -{ - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - eo_do(eo_obj, evas_obj_image_scale_hint_set(hint)); -} - -static void -_image_scale_hint_set(Eo *eo_obj, void *_pd, va_list *list) -{ - Evas_Object_Image *o = _pd; - Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); - Evas_Image_Scale_Hint hint = va_arg(*list, Evas_Image_Scale_Hint); if (o->scale_hint == hint) return; o->scale_hint = hint; if (o->engine_data) @@ -2728,40 +1918,16 @@ _image_scale_hint_set(Eo *eo_obj, void *_pd, va_list *list) } } -EAPI Evas_Image_Scale_Hint -evas_object_image_scale_hint_get(const Evas_Object *eo_obj) +EOLIAN static Evas_Image_Scale_Hint +_evas_image_scale_hint_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return EVAS_IMAGE_SCALE_HINT_NONE; - MAGIC_CHECK_END(); - Evas_Image_Scale_Hint hint = EVAS_IMAGE_SCALE_HINT_NONE; - eo_do((Eo *)eo_obj, evas_obj_image_scale_hint_get(&hint)); - return hint; + return o->scale_hint;; } -static void -_image_scale_hint_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +EOLIAN static void +_evas_image_content_hint_set(Eo *eo_obj, Evas_Image_Data *o, Evas_Image_Content_Hint hint) { - const Evas_Object_Image *o = _pd; - Evas_Image_Scale_Hint *hint = va_arg(*list, Evas_Image_Scale_Hint *); - *hint = o->scale_hint; -} - -EAPI void -evas_object_image_content_hint_set(Evas_Object *eo_obj, Evas_Image_Content_Hint hint) -{ - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - eo_do(eo_obj, evas_obj_image_content_hint_set(hint)); -} - -static void -_image_content_hint_set(Eo *eo_obj, void *_pd, va_list *list) -{ - Evas_Object_Image *o = _pd; Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); - Evas_Image_Content_Hint hint = va_arg(*list, Evas_Image_Content_Hint); if (o->content_hint == hint) return; o->content_hint = hint; if (o->engine_data) @@ -2802,201 +1968,114 @@ evas_object_image_alpha_mask_set(Evas_Object *eo_obj, Eina_Bool ismask) } #define FRAME_MAX 1024 -EAPI Evas_Image_Content_Hint -evas_object_image_content_hint_get(const Evas_Object *eo_obj) +EOLIAN static Evas_Image_Content_Hint +_evas_image_content_hint_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return EVAS_IMAGE_CONTENT_HINT_NONE; - MAGIC_CHECK_END(); - Evas_Image_Content_Hint hint = EVAS_IMAGE_CONTENT_HINT_NONE; - eo_do((Eo *)eo_obj, evas_obj_image_content_hint_get(&hint)); - return hint; + return o->content_hint; } -static void -_image_content_hint_get(Eo *eo_obj EINA_UNUSED, void *_pd, va_list *list) +EOLIAN static Eina_Bool +_evas_image_region_support_get(Eo *eo_obj, Evas_Image_Data *o) { - const Evas_Object_Image *o = _pd; - Evas_Image_Content_Hint *hint = va_arg(*list, Evas_Image_Content_Hint *); + Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); - *hint = o->content_hint; -} + Eina_Bool region; + region = obj->layer->evas->engine.func->image_can_region_get( + obj->layer->evas->engine.data.output, + o->engine_data); -EAPI Eina_Bool -evas_object_image_region_support_get(const Evas_Object *eo_obj) -{ - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return EINA_FALSE; - MAGIC_CHECK_END(); - Eina_Bool region = EINA_FALSE; - eo_do((Eo *)eo_obj, evas_obj_image_region_support_get(®ion)); return region; } -static void -_image_region_support_get(Eo *eo_obj, void *_pd, va_list *list) -{ - Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); - const Evas_Object_Image *o = _pd; - - Eina_Bool *region = va_arg(*list, Eina_Bool *); - *region = obj->layer->evas->engine.func->image_can_region_get( - obj->layer->evas->engine.data.output, - o->engine_data); -} - /* animated feature */ -EAPI Eina_Bool -evas_object_image_animated_get(const Evas_Object *eo_obj) +EOLIAN static Eina_Bool +_evas_image_animated_get(Eo *eo_obj, Evas_Image_Data *o) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return EINA_FALSE; - MAGIC_CHECK_END(); - Eina_Bool animated = EINA_FALSE; - eo_do((Eo *)eo_obj, evas_obj_image_animated_get(&animated)); - return animated; -} - -static void -_image_animated_get(Eo *eo_obj, void *_pd, va_list *list) -{ - Eina_Bool *animated = va_arg(*list, Eina_Bool *); + Eina_Bool animated; Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); - const Evas_Object_Image *o = _pd; - *animated = + animated = obj->layer->evas->engine.func->image_animated_get ? obj->layer->evas->engine.func->image_animated_get(obj->layer->evas->engine.data.output, o->engine_data) : EINA_FALSE; + + return animated; } -EAPI int -evas_object_image_animated_frame_count_get(const Evas_Object *eo_obj) +EOLIAN static int +_evas_image_animated_frame_count_get(Eo *eo_obj, Evas_Image_Data *o) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return -1; - MAGIC_CHECK_END(); - int frame_count = -1; - eo_do((Eo *)eo_obj, evas_obj_image_animated_frame_count_get(&frame_count)); - return frame_count; -} + int frame_count; + frame_count = -1; -static void -_image_animated_frame_count_get(Eo *eo_obj, void *_pd, va_list *list) -{ - const Evas_Object_Image *o = _pd; - int *frame_count = va_arg(*list, int *); - *frame_count = -1; - - if (!evas_object_image_animated_get(eo_obj)) return; + if (!evas_object_image_animated_get(eo_obj)) return frame_count; Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); if (obj->layer->evas->engine.func->image_animated_frame_count_get) - *frame_count = obj->layer->evas->engine.func->image_animated_frame_count_get(obj->layer->evas->engine.data.output, o->engine_data); + frame_count = obj->layer->evas->engine.func->image_animated_frame_count_get(obj->layer->evas->engine.data.output, o->engine_data); + + return frame_count; } -EAPI Evas_Image_Animated_Loop_Hint -evas_object_image_animated_loop_type_get(const Evas_Object *eo_obj) +EOLIAN static Evas_Image_Animated_Loop_Hint +_evas_image_animated_loop_type_get(Eo *eo_obj, Evas_Image_Data *o) { - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return EVAS_IMAGE_ANIMATED_HINT_NONE; - MAGIC_CHECK_END(); - Evas_Image_Animated_Loop_Hint hint = EVAS_IMAGE_ANIMATED_HINT_NONE; - eo_do((Eo *)eo_obj, evas_obj_image_animated_loop_type_get(&hint)); + Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); + + Evas_Image_Animated_Loop_Hint hint; + hint = EVAS_IMAGE_ANIMATED_HINT_NONE; + if (!evas_object_image_animated_get(eo_obj)) return hint; + + if (obj->layer->evas->engine.func->image_animated_loop_type_get) + hint = obj->layer->evas->engine.func->image_animated_loop_type_get(obj->layer->evas->engine.data.output, o->engine_data); + return hint; } -static void -_image_animated_loop_type_get(Eo *eo_obj, void *_pd, va_list *list) +EOLIAN static int +_evas_image_animated_loop_count_get(Eo *eo_obj, Evas_Image_Data *o) { - const Evas_Object_Image *o = _pd; Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); - Evas_Image_Animated_Loop_Hint *hint = va_arg(*list, Evas_Image_Animated_Loop_Hint *); - *hint = EVAS_IMAGE_ANIMATED_HINT_NONE; - if (!evas_object_image_animated_get(eo_obj)) return; + int loop_count; + loop_count = -1; + if (!evas_object_image_animated_get(eo_obj)) return loop_count; - if (obj->layer->evas->engine.func->image_animated_loop_type_get) - *hint = obj->layer->evas->engine.func->image_animated_loop_type_get(obj->layer->evas->engine.data.output, o->engine_data); -} - -EAPI int -evas_object_image_animated_loop_count_get(const Evas_Object *eo_obj) -{ - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return -1; - MAGIC_CHECK_END(); - int loop_count = -1; - eo_do((Eo *)eo_obj, evas_obj_image_animated_loop_count_get(&loop_count)); - return loop_count; -} - -static void -_image_animated_loop_count_get(Eo *eo_obj, void *_pd, va_list *list) -{ - const Evas_Object_Image *o = _pd; - Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); - - int *loop_count = va_arg(*list, int *); - *loop_count = -1; - if (!evas_object_image_animated_get(eo_obj)) return; - - *loop_count = + loop_count = obj->layer->evas->engine.func->image_animated_loop_count_get ? obj->layer->evas->engine.func->image_animated_loop_count_get(obj->layer->evas->engine.data.output, o->engine_data) : -1; + + return loop_count; } -EAPI double -evas_object_image_animated_frame_duration_get(const Evas_Object *eo_obj, int start_frame, int frame_num) -{ - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return -1; - MAGIC_CHECK_END(); - double frame_duration = -1; - eo_do((Eo *)eo_obj, evas_obj_image_animated_frame_duration_get(start_frame, frame_num, &frame_duration)); - return frame_duration; -} - -static void -_image_animated_frame_duration_get(Eo *eo_obj, void *_pd, va_list *list) +EOLIAN static double +_evas_image_animated_frame_duration_get(Eo *eo_obj, Evas_Image_Data *o, int start_frame, int frame_num) { Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); - const Evas_Object_Image *o = _pd; int frame_count = 0; - int start_frame = va_arg(*list, int); - int frame_num = va_arg(*list, int); - double *frame_duration = va_arg(*list, double *); - *frame_duration = -1; + double frame_duration; + frame_duration = -1; - if (!obj->layer->evas->engine.func->image_animated_frame_count_get) return; + if (!obj->layer->evas->engine.func->image_animated_frame_count_get) return frame_duration; frame_count = obj->layer->evas->engine.func->image_animated_frame_count_get(obj->layer->evas->engine.data.output, o->engine_data); - if ((start_frame + frame_num) > frame_count) return; + if ((start_frame + frame_num) > frame_count) return frame_duration; if (obj->layer->evas->engine.func->image_animated_frame_duration_get) - *frame_duration = obj->layer->evas->engine.func->image_animated_frame_duration_get(obj->layer->evas->engine.data.output, o->engine_data, start_frame, frame_num); + frame_duration = obj->layer->evas->engine.func->image_animated_frame_duration_get(obj->layer->evas->engine.data.output, o->engine_data, start_frame, frame_num); + + return frame_duration; } -EAPI void -evas_object_image_animated_frame_set(Evas_Object *eo_obj, int frame_index) -{ - MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ); - return; - MAGIC_CHECK_END(); - eo_do(eo_obj, evas_obj_image_animated_frame_set(frame_index)); -} - -static void -_image_animated_frame_set(Eo *eo_obj, void *_pd, va_list *list) +EOLIAN static void +_evas_image_animated_frame_set(Eo *eo_obj, Evas_Image_Data *o, int frame_index) { Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); - Evas_Object_Image *o = _pd; int frame_count = 0; if (!o->cur->u.file) return; - int frame_index = va_arg(*list, int); if (o->cur->frame == frame_index) return; if (!evas_object_image_animated_get(eo_obj)) return; @@ -3059,7 +2138,7 @@ _evas_image_cache_reload(Eo *eo_e, Evas_Public_Data *e) { if (eo_isa(obj->object, MY_CLASS)) { - Evas_Object_Image *o = eo_data_scope_get(obj->object, MY_CLASS); + Evas_Image_Data *o = eo_data_scope_get(obj->object, MY_CLASS); evas_object_image_load(obj->object, obj, o); o->changed = EINA_TRUE; evas_object_change(obj->object, obj); @@ -3099,7 +2178,7 @@ _evas_image_max_size_get(Eo *eo_e EINA_UNUSED, Evas_Public_Data *e, int *maxw, i /* all nice and private */ static void -_proxy_unset(Evas_Object *proxy, Evas_Object_Protected_Data *cur_proxy, Evas_Object_Image *o) +_proxy_unset(Evas_Object *proxy, Evas_Object_Protected_Data *cur_proxy, Evas_Image_Data *o) { Evas_Object_Protected_Data *cur_source; @@ -3158,7 +2237,7 @@ _proxy_set(Evas_Object *eo_proxy, Evas_Object *eo_src) { Evas_Object_Protected_Data *src = eo_data_scope_get(eo_src, EVAS_OBJ_CLASS); Evas_Object_Protected_Data *proxy = eo_data_scope_get(eo_proxy, EVAS_OBJ_CLASS); - Evas_Object_Image *o = eo_data_scope_get(eo_proxy, MY_CLASS); + Evas_Image_Data *o = eo_data_scope_get(eo_proxy, MY_CLASS); evas_object_image_file_set(eo_proxy, NULL, NULL); @@ -3190,7 +2269,7 @@ _proxy_error(Evas_Object *eo_proxy, void *context, void *output, void *surface, int x, int y, Eina_Bool do_async) { Evas_Func *func; - Evas_Object_Image *o = eo_data_scope_get(eo_proxy, MY_CLASS); + Evas_Image_Data *o = eo_data_scope_get(eo_proxy, MY_CLASS); if (!o->proxyerror) printf("Err: Argh! Recursive proxies.\n"); o->proxyerror = 1; @@ -3294,7 +2373,7 @@ _proxy_subrender(Evas *eo_e, Evas_Object *eo_source, Evas_Object *eo_proxy, Evas static void evas_object_image_unload(Evas_Object *eo_obj, Eina_Bool dirty) { - Evas_Object_Image *o; + Evas_Image_Data *o; Eina_Bool resize_call = EINA_FALSE; o = eo_data_scope_get(eo_obj, MY_CLASS); @@ -3340,7 +2419,7 @@ evas_object_image_unload(Evas_Object *eo_obj, Eina_Bool dirty) } static void -evas_object_image_load(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, Evas_Object_Image *o) +evas_object_image_load(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, Evas_Image_Data *o) { Evas_Image_Load_Opts lo; @@ -3472,8 +2551,8 @@ evas_object_image_init(Evas_Object *eo_obj) obj->type = o_type; } -static void -_destructor(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) +EOLIAN static void +_evas_image_destructor(Eo *eo_obj, Evas_Image_Data *_pd EINA_UNUSED) { Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); @@ -3485,7 +2564,7 @@ _destructor(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) void _evas_object_image_free(Evas_Object *obj) { - Evas_Object_Image *o; + Evas_Image_Data *o; if (!eo_isa(obj, MY_CLASS)) return; @@ -3501,7 +2580,7 @@ _evas_object_image_free(Evas_Object *obj) static void evas_object_image_free(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj) { - Evas_Object_Image *o = eo_data_scope_get(eo_obj, MY_CLASS); + Evas_Image_Data *o = eo_data_scope_get(eo_obj, MY_CLASS); Eina_Rectangle *r; /* free obj */ @@ -3600,7 +2679,7 @@ evas_draw_image_map_async_check(Evas_Object_Protected_Data *obj, } static void * -evas_process_dirty_pixels(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, Evas_Object_Image *o, +evas_process_dirty_pixels(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, Evas_Image_Data *o, void *output, void *pixels) { int direct_override = 0; @@ -3668,7 +2747,7 @@ evas_process_dirty_pixels(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, obj->cur->geometry.y == y && obj->cur->geometry.w == w && obj->cur->geometry.h == h)) - CRI("Evas_Object_Image geometry did change during pixels get callback !"); + CRI("Evas_Image_Data geometry did change during pixels get callback !"); o->engine_data = obj->layer->evas->engine.func->image_dirty_region (obj->layer->evas->engine.data.output, o->engine_data, @@ -3694,7 +2773,7 @@ static void evas_object_image_render(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, void *type_private_data, void *output, void *context, void *surface, int x, int y, Eina_Bool do_async) { - Evas_Object_Image *o = type_private_data; + Evas_Image_Data *o = type_private_data; int imagew, imageh, uvw, uvh; void *pixels; @@ -3820,9 +2899,9 @@ evas_object_image_render(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, v uvh = imageh; } else if (source->type == o_type && - ((Evas_Object_Image *)eo_data_scope_get(o->cur->source, MY_CLASS))->engine_data) + ((Evas_Image_Data *)eo_data_scope_get(o->cur->source, MY_CLASS))->engine_data) { - Evas_Object_Image *oi; + Evas_Image_Data *oi; oi = eo_data_scope_get(o->cur->source, MY_CLASS); pixels = oi->engine_data; imagew = oi->cur->image.w; @@ -4082,7 +3161,7 @@ evas_object_image_render_pre(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, void *type_private_data) { - Evas_Object_Image *o = type_private_data; + Evas_Image_Data *o = type_private_data; int is_v = 0, was_v = 0; /* dont pre-render the obj twice! */ @@ -4360,7 +3439,7 @@ evas_object_image_render_post(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj EINA_UNUSED, void *type_private_data) { - Evas_Object_Image *o = type_private_data; + Evas_Image_Data *o = type_private_data; Eina_Rectangle *r; /* this moves the current data to the previous state parts of the object */ @@ -4387,21 +3466,21 @@ evas_object_image_render_post(Evas_Object *eo_obj, static unsigned int evas_object_image_id_get(Evas_Object *eo_obj) { - Evas_Object_Image *o = eo_data_scope_get(eo_obj, MY_CLASS); + Evas_Image_Data *o = eo_data_scope_get(eo_obj, MY_CLASS); if (!o) return 0; return MAGIC_OBJ_IMAGE; } static unsigned int evas_object_image_visual_id_get(Evas_Object *eo_obj) { - Evas_Object_Image *o = eo_data_scope_get(eo_obj, MY_CLASS); + Evas_Image_Data *o = eo_data_scope_get(eo_obj, MY_CLASS); if (!o) return 0; return MAGIC_OBJ_IMAGE; } static void *evas_object_image_engine_data_get(Evas_Object *eo_obj) { - Evas_Object_Image *o = eo_data_scope_get(eo_obj, MY_CLASS); + Evas_Image_Data *o = eo_data_scope_get(eo_obj, MY_CLASS); if (!o) return NULL; return o->engine_data; } @@ -4415,7 +3494,7 @@ evas_object_image_is_opaque(Evas_Object *eo_obj EINA_UNUSED, /* currently fully opaque over the entire rectangle it occupies */ /* disable caching due tyo maps screwing with this o->cur.opaque_valid = 0;*/ - Evas_Object_Image *o = type_private_data; + Evas_Image_Data *o = type_private_data; if (o->cur->opaque_valid) { @@ -4517,7 +3596,7 @@ evas_object_image_was_opaque(Evas_Object *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj, void *type_private_data) { - Evas_Object_Image *o = type_private_data; + Evas_Image_Data *o = type_private_data; /* this returns 1 if the internal object data implies that the object was */ /* previously fully opaque over the entire rectangle it occupies */ @@ -4623,7 +3702,7 @@ evas_object_image_is_inside(Evas_Object *eo_obj, void *type_private_data, Evas_Coord px, Evas_Coord py) { - Evas_Object_Image *o = type_private_data; + Evas_Image_Data *o = type_private_data; int imagew, imageh, uvw, uvh; void *pixels; Evas_Func *eng = obj->layer->evas->engine.func; @@ -4653,9 +3732,9 @@ evas_object_image_is_inside(Evas_Object *eo_obj, uvh = imageh; } else if (source->type == o_type && - ((Evas_Object_Image *)eo_data_scope_get(o->cur->source, MY_CLASS))->engine_data) + ((Evas_Image_Data *)eo_data_scope_get(o->cur->source, MY_CLASS))->engine_data) { - Evas_Object_Image *oi; + Evas_Image_Data *oi; oi = eo_data_scope_get(o->cur->source, MY_CLASS); pixels = oi->engine_data; imagew = oi->cur->image.w; @@ -4978,7 +4057,7 @@ evas_object_image_has_opaque_rect(Evas_Object *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj, void *type_private_data) { - Evas_Object_Image *o = type_private_data; + Evas_Image_Data *o = type_private_data; if ((obj->map->cur.map) && (obj->map->cur.usemap)) return 0; if (((o->cur->border.l | o->cur->border.r | o->cur->border.t | o->cur->border.b) != 0) && @@ -4999,7 +4078,7 @@ evas_object_image_get_opaque_rect(Evas_Object *eo_obj EINA_UNUSED, void *type_private_data, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h) { - Evas_Object_Image *o = type_private_data; + Evas_Image_Data *o = type_private_data; if (o->cur->border.scale == 1.0) { @@ -5029,7 +4108,7 @@ evas_object_image_can_map(Evas_Object *obj EINA_UNUSED) } static void * -evas_object_image_data_convert_internal(Evas_Object_Image *o, void *data, Evas_Colorspace to_cspace) +evas_object_image_data_convert_internal(Evas_Image_Data *o, void *data, Evas_Colorspace to_cspace) { void *out = NULL; @@ -5098,21 +4177,21 @@ evas_object_image_filled_resize_listener(void *data EINA_UNUSED, Evas *e EINA_UN Evas_Object * _evas_object_image_source_get(Evas_Object *eo_obj) { - Evas_Object_Image *o = eo_data_scope_get(eo_obj, MY_CLASS); + Evas_Image_Data *o = eo_data_scope_get(eo_obj, MY_CLASS); return o->cur->source; } Eina_Bool _evas_object_image_preloading_get(const Evas_Object *eo_obj) { - Evas_Object_Image *o = eo_data_scope_get(eo_obj, MY_CLASS); + Evas_Image_Data *o = eo_data_scope_get(eo_obj, MY_CLASS); return o->preloading; } void _evas_object_image_preloading_set(Evas_Object *eo_obj, Eina_Bool preloading) { - Evas_Object_Image *o = eo_data_scope_get(eo_obj, MY_CLASS); + Evas_Image_Data *o = eo_data_scope_get(eo_obj, MY_CLASS); o->preloading = preloading; } @@ -5120,7 +4199,7 @@ void _evas_object_image_preloading_check(Evas_Object *eo_obj) { Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); - Evas_Object_Image *o = eo_data_scope_get(eo_obj, MY_CLASS); + Evas_Image_Data *o = eo_data_scope_get(eo_obj, MY_CLASS); if (obj->layer->evas->engine.func->image_load_error_get) o->load_error = obj->layer->evas->engine.func->image_load_error_get (obj->layer->evas->engine.data.output, o->engine_data); @@ -5129,7 +4208,7 @@ _evas_object_image_preloading_check(Evas_Object *eo_obj) Evas_Object * _evas_object_image_video_parent_get(Evas_Object *eo_obj) { - Evas_Object_Image *o = eo_data_scope_get(eo_obj, MY_CLASS); + Evas_Image_Data *o = eo_data_scope_get(eo_obj, MY_CLASS); return o->video_surface ? o->pixels->video.parent : NULL; } @@ -5137,7 +4216,7 @@ void _evas_object_image_video_overlay_show(Evas_Object *eo_obj) { Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); - Evas_Object_Image *o = eo_data_scope_get(eo_obj, MY_CLASS); + Evas_Image_Data *o = eo_data_scope_get(eo_obj, MY_CLASS); if (obj->cur->cache.clip.x != obj->prev->cache.clip.x || obj->cur->cache.clip.y != obj->prev->cache.clip.y || @@ -5176,7 +4255,7 @@ void _evas_object_image_video_overlay_hide(Evas_Object *eo_obj) { Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); - Evas_Object_Image *o = eo_data_scope_get(eo_obj, MY_CLASS); + Evas_Image_Data *o = eo_data_scope_get(eo_obj, MY_CLASS); if (o->video_visible || o->created) { @@ -5193,7 +4272,7 @@ void _evas_object_image_video_overlay_do(Evas_Object *eo_obj) { Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); - Evas_Object_Image *o = eo_data_scope_get(eo_obj, MY_CLASS); + Evas_Image_Data *o = eo_data_scope_get(eo_obj, MY_CLASS); Evas_Public_Data *e = obj->layer->evas; if (o->delayed.video_move) @@ -5218,180 +4297,6 @@ _evas_object_image_video_overlay_do(Evas_Object *eo_obj) o->delayed.video_hide = EINA_FALSE; } -static void -_class_constructor(Eo_Class *klass) -{ - const Eo_Op_Func_Description func_desc[] = { - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _constructor), - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_DESTRUCTOR), _destructor), - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_DBG_INFO_GET), _dbg_info_get), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_FILE_SET), _image_file_set), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_MMAP_SET), _image_mmap_set), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_FILE_GET), _image_file_get), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_SOURCE_SET), _image_source_set), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_SOURCE_GET), _image_source_get), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_BORDER_SET), _image_border_set), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_BORDER_GET), _image_border_get), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_BORDER_CENTER_FILL_SET), _image_border_center_fill_set), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_BORDER_CENTER_FILL_GET), _image_border_center_fill_get), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_FILLED_SET), _image_filled_set), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_FILLED_GET), _image_filled_get), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_BORDER_SCALE_SET), _image_border_scale_set), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_BORDER_SCALE_GET), _image_border_scale_get), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_FILL_SET), _image_fill_set), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_FILL_GET), _image_fill_get), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_FILL_SPREAD_SET), _image_fill_spread_set), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_FILL_SPREAD_GET), _image_fill_spread_get), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_SIZE_SET), _image_size_set), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_SIZE_GET), _image_size_get), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_STRIDE_GET), _image_stride_get), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_LOAD_ERROR_GET), _image_load_error_get), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_DATA_CONVERT), _image_data_convert), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_DATA_SET), _image_data_set), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_DATA_GET), _image_data_get), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_PRELOAD_BEGIN), _image_preload_begin), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_PRELOAD_CANCEL), _image_preload_cancel), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_DATA_COPY_SET), _image_data_copy_set), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_DATA_UPDATE_ADD), _image_data_update_add), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_ALPHA_SET), _image_alpha_set), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_ALPHA_GET), _image_alpha_get), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_SMOOTH_SCALE_SET), _image_smooth_scale_set), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_SMOOTH_SCALE_GET), _image_smooth_scale_get), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_RELOAD), _image_reload), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_SAVE), _image_save), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_PIXELS_IMPORT), _image_pixels_import), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_PIXELS_GET_CALLBACK_SET), _image_pixels_get_callback_set), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_PIXELS_DIRTY_SET), _image_pixels_dirty_set), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_PIXELS_DIRTY_GET), _image_pixels_dirty_get), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_LOAD_DPI_SET), _image_load_dpi_set), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_LOAD_DPI_GET), _image_load_dpi_get), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_LOAD_SIZE_SET), _image_load_size_set), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_LOAD_SIZE_GET), _image_load_size_get), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_LOAD_SCALE_DOWN_SET), _image_load_scale_down_set), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_LOAD_SCALE_DOWN_GET), _image_load_scale_down_get), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_LOAD_REGION_SET), _image_load_region_set), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_LOAD_REGION_GET), _image_load_region_get), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_LOAD_ORIENTATION_SET), _image_load_orientation_set), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_LOAD_ORIENTATION_GET), _image_load_orientation_get), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_COLORSPACE_SET), _image_colorspace_set), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_COLORSPACE_GET), _image_colorspace_get), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_VIDEO_SURFACE_SET), _image_video_surface_set), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_VIDEO_SURFACE_GET), _image_video_surface_get), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_VIDEO_SURFACE_CAPS_SET), _image_video_surface_caps_set), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_VIDEO_SURFACE_CAPS_GET), _image_video_surface_caps_get), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_NATIVE_SURFACE_SET), _image_native_surface_set), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_NATIVE_SURFACE_GET), _image_native_surface_get), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_SCALE_HINT_SET), _image_scale_hint_set), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_SCALE_HINT_GET), _image_scale_hint_get), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_CONTENT_HINT_SET), _image_content_hint_set), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_CONTENT_HINT_GET), _image_content_hint_get), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_REGION_SUPPORT_GET), _image_region_support_get), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_GET), _image_animated_get), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_FRAME_COUNT_GET), _image_animated_frame_count_get), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_LOOP_TYPE_GET), _image_animated_loop_type_get), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_LOOP_COUNT_GET), _image_animated_loop_count_get), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_FRAME_DURATION_GET), _image_animated_frame_duration_get), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_FRAME_SET), _image_animated_frame_set), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_SOURCE_VISIBLE_SET), _image_source_visible_set), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_SOURCE_VISIBLE_GET), _image_source_visible_get), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_SOURCE_EVENTS_SET), _image_source_events_set), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_SOURCE_EVENTS_GET), _image_source_events_get), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_SOURCE_CLIP_SET), _image_source_clip_set), - EO_OP_FUNC(EVAS_OBJ_IMAGE_ID(EVAS_OBJ_IMAGE_SUB_ID_SOURCE_CLIP_GET), _image_source_clip_get), - EO_OP_FUNC_SENTINEL - }; - - eo_class_funcs_set(klass, func_desc); -} - -static const Eo_Op_Description op_desc[] = { - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_FILE_SET, "Set the source file from where an image object must fetch the real"), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_MMAP_SET, "Set the source mmaped file from where an image object must fetch the real"), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_FILE_GET, "Retrieve the source file from where an image object is to fetch the"), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_SOURCE_SET, "Set the source object on an image object to used as a @b proxy."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_SOURCE_GET, "Get the current source object of an image object."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_BORDER_SET, "Set the dimensions for an image object's border."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_BORDER_GET, "Retrieve the dimensions for an image object's border, a region."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_BORDER_CENTER_FILL_SET, "Sets how the center part of the given image object."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_BORDER_CENTER_FILL_GET, "Retrieves how the center part of the given image object."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_FILLED_SET, "Set whether the image object's fill property should track the object's size."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_FILLED_GET, "Retrieve whether the image object's fill property should track the object's size."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_BORDER_SCALE_SET, "Sets the scaling factor (multiplier) for the borders of an image object"), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_BORDER_SCALE_GET, "Retrieves the scaling factor (multiplier) for the borders of an image object"), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_FILL_SET, "Set how to fill an image object's drawing rectangle given the (real) image bound to it."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_FILL_GET, "Retrieve how an image object is to fill its drawing rectangle, given the (real) image bound to it."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_FILL_SPREAD_SET, "Sets the tiling mode for the given evas image object's fill."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_FILL_SPREAD_GET, "Retrieves the spread (tiling mode) for the given image object's fill."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_SIZE_SET, "Sets the size of the given image object."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_SIZE_GET, "Retrieves the size of the given image object."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_STRIDE_GET, "Retrieves the row stride of the given image object."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_LOAD_ERROR_GET, "Retrieves a number representing any error."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_DATA_CONVERT, "Converts the raw image data of the given image object to the specified colorspace."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_DATA_SET, "Sets the raw image data of the given image object."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_DATA_GET, "Get a pointer to the raw image data of the given image object."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_PRELOAD_BEGIN, "Begin preload an image object's image data in the background."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_PRELOAD_CANCEL, "Cancel preload an image object's image data in the background."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_DATA_COPY_SET, "Replaces the raw image data of the given image object."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_DATA_UPDATE_ADD, "Mark a sub-region of the given image object to be redrawn."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_ALPHA_SET, "Enable or disable alpha channel usage on the given image object."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_ALPHA_GET, "Retrieve whether alpha channel data is being used on the given image object"), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_SMOOTH_SCALE_SET, "Sets whether to use high-quality image scaling algorithm on the given image object."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_SMOOTH_SCALE_GET, "Retrieves whether the given image object is using high-quality image scaling algorithm."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_RELOAD, "Reload an image object's image data."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_SAVE, "Save the given image object's contents to an (image) file."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_PIXELS_IMPORT, "Import pixels from given source to a given canvas image object."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_PIXELS_GET_CALLBACK_SET, "Set the callback function to get pixels from a canvas' image."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_PIXELS_DIRTY_SET, "Mark whether the given image object is dirty and needs to request its pixels."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_PIXELS_DIRTY_GET, "Retrieves whether the given image object is dirty (needs to be redrawn)."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_LOAD_DPI_SET, "Set the DPI resolution of an image object's source image."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_LOAD_DPI_GET, "Get the DPI resolution of a loaded image object in the canvas."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_LOAD_SIZE_SET, "Set the size of a given image object's source image, when loading it."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_LOAD_SIZE_GET, "Get the size of a given image object's source image, when loading it."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_LOAD_SCALE_DOWN_SET, "Set the scale down factor of a given image object's source image, when loading it."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_LOAD_SCALE_DOWN_GET, "get the scale down factor of a given image object's source image, when loading it."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_LOAD_REGION_SET, "Inform a given image object to load a selective region of its source image."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_LOAD_REGION_GET, "Retrieve the coordinates of a given image object's selective load region."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_LOAD_ORIENTATION_SET, "Define if the orientation information in the image file should be honored."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_LOAD_ORIENTATION_GET, "Get if the orientation information in the image file should be honored."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_COLORSPACE_SET, "Set the colorspace of a given image of the canvas."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_COLORSPACE_GET, "Get the colorspace of a given image of the canvas."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_VIDEO_SURFACE_SET, "Set the video surface linked to a given image of the canvas."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_VIDEO_SURFACE_GET, "Get the video surface linekd to a given image of the canvas."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_VIDEO_SURFACE_CAPS_SET, "Set the surface capabilities (clip, resize, scale) of the video surface associated with this image."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_VIDEO_SURFACE_CAPS_GET, "Get the surface capabilities (clip, resize, scale) of the video surface associated with this image."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_NATIVE_SURFACE_SET, "Set the native surface of a given image of the canvas."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_NATIVE_SURFACE_GET, "Get the native surface of a given image of the canvas."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_SCALE_HINT_SET, "Set the scale hint of a given image of the canvas."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_SCALE_HINT_GET, "Get the scale hint of a given image of the canvas."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_CONTENT_HINT_SET, "Set the content hint setting of a given image object of the canvas."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_CONTENT_HINT_GET, "Get the content hint setting of a given image object of the canvas."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_REGION_SUPPORT_GET, "Get the support state of a given image"), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_GET, "Check if an image object can be animated (have multiple frames)"), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_FRAME_COUNT_GET, "Get the total number of frames of the image object."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_LOOP_TYPE_GET, "Get the kind of looping the image object does."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_LOOP_COUNT_GET, "Get the number times the animation of the object loops."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_FRAME_DURATION_GET, "Get the duration of a sequence of frames."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_ANIMATED_FRAME_SET, "Set the frame to current frame of an image object."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_SOURCE_VISIBLE_SET, "Set the source object visibility of a given image object being used as a proxy."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_SOURCE_VISIBLE_GET, "Get the source object visibility of a given image object being used as a proxy."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_SOURCE_EVENTS_SET, "Set the events to be repeated to the source object."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_SOURCE_EVENTS_GET, "Get the state of the source events."), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_SOURCE_CLIP_SET, "Apply the source object's clip to the proxy"), - EO_OP_DESCRIPTION(EVAS_OBJ_IMAGE_SUB_ID_SOURCE_CLIP_GET, "Get the state of the source clip"), - EO_OP_DESCRIPTION_SENTINEL -}; - -static const Eo_Class_Description class_desc = { - EO_VERSION, - MY_CLASS_NAME, - EO_CLASS_TYPE_REGULAR, - EO_CLASS_DESCRIPTION_OPS(&EVAS_OBJ_IMAGE_BASE_ID, op_desc, EVAS_OBJ_IMAGE_SUB_ID_LAST), - NULL, - sizeof(Evas_Object_Image), - _class_constructor, - NULL -}; - -EO_DEFINE_CLASS(evas_object_image_class_get, &class_desc, EVAS_OBJ_CLASS, NULL); - /* vim:set ts=8 sw=3 sts=3 expandtab cino=>5n-2f0^-2{2(0W1st0 :*/ + +#include "canvas/evas_image.eo.c"