pthread_libs=""
build_pthreads="no"
has_pthreads="no"
+need_pthreads="no"
+# basic pthread support
+AC_CHECK_HEADER(pthread.h,
+ [
+ has_pthreads="yes"
+ ],
+ [
+ has_pthreads="no"
+ ]
+)
+
# sched_getaffinity pthread_attr_setaffinity_np
AC_CHECK_HEADERS(pthread.h sched.h,
[
AC_CHECK_LIB(pthread, pthread_attr_setaffinity_np,
[
AC_CHECK_LIB(pthread, pthread_barrier_wait,
- [
- build_pthreads="yes"
- has_pthreads="yes"
- ],
+ [ build_pthreads="yes" ],
[ build_pthreads="no" ]
)
],
AC_MSG_RESULT(yes)
AC_DEFINE(BUILD_PTHREAD, 1, [Build Threaded Rendering])
build_pthreads="yes"
- pthread_cflags=""
- pthread_libs="-lpthread"
+ need_pthreads="yes"
else
if "x$use_strict" = "xyes"; then
AC_MSG_ERROR(pthreads headers or functions not found (strict dependencies checking))
AC_MSG_RESULT($build_pthreads)
if test "x$build_pthreads" = "xyes" ; then
AC_DEFINE(BUILD_PTHREAD, 1, [Build Threaded Rendering])
- pthread_cflags=""
- pthread_libs="-lpthread"
+ need_pthreads="yes"
fi
]
)
AC_MSG_RESULT(yes)
AC_DEFINE(BUILD_ASYNC_EVENTS, 1, [Build async events support])
build_async_events="yes"
+ need_pthreads="yes"
else
AC_MSG_RESULT(no)
build_async_events="no"
fi
#######################################
+## Async image preload
+build_async_preload="auto"
+AC_MSG_CHECKING(whether to build Async Image Preload support)
+AC_ARG_ENABLE(async-preload,
+ AC_HELP_STRING([--enable-async-preload], [enable async image preloading support]),
+ [ build_async_preload=$enableval ]
+)
+AC_MSG_RESULT($build_async_preload)
+
+AC_MSG_CHECKING(whether we can build Async Image Preload support)
+if test \( "x$build_async_preload" = "xyes" -o "x$build_async_preload" = "xauto" \) -a "x$build_async_events" = "xyes"; then
+ AC_MSG_RESULT(yes)
+ AC_DEFINE(BUILD_ASYNC_PRELOAD, 1, [Build async image preload support])
+ build_async_preload="yes"
+ need_pthreads="yes"
+else
+ AC_MSG_RESULT(no)
+ build_async_preload="no"
+fi
+
+#######################################
+## Link with pthread if needed
+AC_MSG_CHECKING(whether we should link with pthread)
+if test "x$need_pthreads" = "xyes"; then
+ AC_MSG_RESULT(yes)
+ pthread_cflags=""
+ pthread_libs="-lpthread"
+else
+ AC_MSG_RESULT(no)
+fi
+
+#######################################
## MMX
build_cpu_mmx="no"
case $host_cpu in
echo " MAGIC_DEBUG.............: $want_evas_magic_debug"
echo
echo "Async Events..............: $build_async_events"
+echo "Async Image Preload.......: $build_async_preload"
echo
echo "ARGB Software Engine Options:"
echo " Sampling Scaler.........: $scaler_sample"
EVAS_CALLBACK_RESTACK, /**< Restack Event */
EVAS_CALLBACK_DEL, /**< Object Being Deleted (called before Free) */
EVAS_CALLBACK_HOLD, /**< Events go on/off hold */
- EVAS_CALLBACK_CHANGED_SIZE_HINTS /**< Size hints changed event */
+ EVAS_CALLBACK_CHANGED_SIZE_HINTS, /**< Size hints changed event */
+ EVAS_CALLBACK_IMAGE_PRELOADED /**< Image as been preloaded */
} Evas_Callback_Type; /**< The type of event to trigger the callback */
typedef enum _Evas_Button_Flags
EAPI Evas_Bool evas_object_image_alpha_get (const Evas_Object *obj);
EAPI void evas_object_image_smooth_scale_set(Evas_Object *obj, Evas_Bool smooth_scale);
EAPI Evas_Bool evas_object_image_smooth_scale_get(const Evas_Object *obj);
+ EAPI void evas_object_image_preload (const Evas_Object *obj, Evas_Bool cancel);
EAPI void evas_object_image_reload (Evas_Object *obj);
EAPI Evas_Bool evas_object_image_save (const Evas_Object *obj, const char *file, const char *key, const char *flags);
EAPI Evas_Bool evas_object_image_pixels_import (Evas_Object *obj, Evas_Pixel_Import_Source *pixels);
EAPI int evas_async_events_fd_get (void);
EAPI int evas_async_events_process (void);
- EAPI Evas_Bool evas_async_events_put (void *target, Evas_Callback_Type type, void *event_info, void (*func)(void *target, Evas_Callback_Type type, void *event_info));
+ EAPI Evas_Bool evas_async_events_put (const void *target, Evas_Callback_Type type, void *event_info, void (*func)(void *target, Evas_Callback_Type type, void *event_info));
EAPI void evas_object_intercept_show_callback_add (Evas_Object *obj, void (*func) (void *data, Evas_Object *obj), const void *data);
EAPI void *evas_object_intercept_show_callback_del (Evas_Object *obj, void (*func) (void *data, Evas_Object *obj));
#include "evas_common.h"
#include "evas_private.h"
+#ifdef BUILD_ASYNC_PRELOAD
+#include <pthread.h>
+
+static Evas_List *preload = NULL;
+static Image_Entry *current = NULL;
+
+static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
+static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t mutex_surface_alloc = PTHREAD_MUTEX_INITIALIZER;
+static pthread_t tid;
+
+static Evas_Bool running = 0;
+
+static void* _evas_cache_background_load(void *);
+#endif
+
#define FREESTRC(Var) \
if (Var) \
{ \
if (ie->allocated.w == wmin && ie->allocated.h == hmin)
return ;
+#ifdef BUILD_ASYNC_PRELOAD
+ pthread_mutex_lock(&mutex_surface_alloc);
+#endif
+
if (cache->func.surface_alloc(ie, wmin, hmin))
{
wmin = 0;
hmin = 0;
}
+
+#ifdef BUILD_ASYNC_PRELOAD
+ pthread_mutex_unlock(&mutex_surface_alloc);
+#endif
+
ie->w = wmin;
ie->h = hmin;
ie->allocated.w = wmin;
ie->allocated.h = hmin;
}
+#ifdef BUILD_ASYNC_PRELOAD
+static int
+_evas_cache_image_entry_preload_add(Evas_Cache_Image *cache,
+ Image_Entry *ie,
+ const void *target)
+{
+ int ret = 0;
+
+ pthread_mutex_lock(&mutex);
+
+ if (!ie->flags.preload)
+ {
+ preload = evas_list_append(preload, ie);
+ ie->flags.preload = 1;
+ ie->target = target;
+
+ if (!running)
+ {
+ if (pthread_create(&tid, NULL, _evas_cache_background_load, NULL) == 0)
+ running = 1;
+ }
+
+ ret = 1;
+ }
+
+ pthread_mutex_unlock(&mutex);
+
+ return ret;
+}
+
+static int
+_evas_cache_image_entry_preload_remove(Evas_Cache_Image *cache,
+ Image_Entry *ie)
+{
+ int ret = 0;
+
+ if (running)
+ {
+ pthread_mutex_lock(&mutex);
+
+ if (ie->flags.preload)
+ {
+ if (current == ie)
+ {
+ /* Wait until ie is processed. */
+ pthread_cond_wait(&cond, &mutex);
+ }
+ else
+ {
+ preload = evas_list_remove(preload, ie);
+ ie->flags.preload = 0;
+ ret = 1;
+ }
+ }
+
+ pthread_mutex_unlock(&mutex);
+ }
+
+ return ret;
+}
+#endif
+
EAPI int
evas_cache_image_usage_get(Evas_Cache_Image *cache)
{
if (im->references == 0)
{
+#ifdef BUILD_ASYNC_PRELOAD
+ _evas_cache_image_entry_preload_remove(cache, im);
+#endif
+
if (im->flags.dirty)
{
_evas_cache_image_entry_delete(cache, im);
if (im->flags.loaded) return ;
+#ifdef BUILD_ASYNC_PRELOAD
+ /* We check a first time, to prevent useless lock. */
+ _evas_cache_image_entry_preload_remove(cache, im);
+ if (im->flags.loaded) return ;
+#endif
+
cache = im->cache;
error = cache->func.load(im);
im->flags.loaded = 1;
}
+EAPI void
+evas_cache_image_preload_data(Image_Entry *im, const void *target)
+{
+#ifdef BUILD_ASYNC_PRELOAD
+ Evas_Cache_Image *cache;
+
+ assert(im);
+ assert(im->cache);
+
+ if (im->flags.loaded) return ;
+
+ cache = im->cache;
+
+ _evas_cache_image_entry_preload_add(cache, im, target);
+#else
+ evas_cache_image_load_data(im);
+
+ evas_async_events_put(target, EVAS_CALLBACK_IMAGE_PRELOADED, NULL, evas_object_event_callback_call);
+#endif
+}
+
+EAPI void
+evas_cache_image_preload_cancel(Image_Entry *im)
+{
+#ifdef BUILD_ASYNC_PRELOAD
+ Evas_Cache_Image *cache;
+
+ assert(im);
+ assert(im->cache);
+
+ _evas_cache_image_entry_preload_remove(cache, im);
+#else
+ (void) im;
+#endif
+}
+
EAPI int
evas_cache_image_flush(Evas_Cache_Image *cache)
{
assert(cache);
-// printf("cache->limit = %i (used = %i)\n", cache->limit, cache->usage);
if (cache->limit == -1)
return -1;
return cache->func.surface_pixels(im);
}
+
+#ifdef BUILD_ASYNC_PRELOAD
+static void*
+_evas_cache_background_load(void *data)
+{
+ (void) data;
+
+ restart:
+ while (preload)
+ {
+ pthread_mutex_lock(&mutex);
+
+ current = evas_list_data(preload);
+ preload = evas_list_remove(preload, current);
+
+ pthread_mutex_unlock(&mutex);
+
+ if (current)
+ {
+ Evas_Cache_Image *cache;
+ int error;
+
+ cache = current->cache;
+
+ error = cache->func.load(current);
+ if (cache->func.debug)
+ cache->func.debug("load", current);
+
+ if (error)
+ {
+ _evas_cache_image_entry_surface_alloc(cache, current,
+ current->w, current->h);
+ current->flags.loaded = 0;
+ }
+ else
+ {
+ current->flags.loaded = 1;
+ }
+
+ current->flags.preload = 0;
+ }
+
+ evas_async_events_put(current->target, EVAS_CALLBACK_IMAGE_PRELOADED, NULL, evas_object_event_callback_call);
+
+ current = NULL;
+ pthread_cond_signal(&cond);
+ }
+
+ pthread_mutex_lock(&mutex);
+ if (preload)
+ {
+ pthread_mutex_unlock(&mutex);
+ goto restart;
+ }
+
+ running = 0;
+ pthread_mutex_unlock(&mutex);
+
+ return NULL;
+}
+#endif
struct _Evas_Event_Async
{
void (*func)(void *target, Evas_Callback_Type type, void *event_info);
- void *target;
+ const void *target;
Evas_Callback_Type type;
void *event_info;
};
size += check;
if (size == sizeof(current))
{
- if (current.func) current.func(current.target, current.type, current.event_info);
+ if (current.func) current.func((void*) current.target, current.type, current.event_info);
size = 0;
count++;
}
}
EAPI Evas_Bool
-evas_async_events_put(void *target, Evas_Callback_Type type, void *event_info, void (*func)(void *target, Evas_Callback_Type type, void *event_info))
+evas_async_events_put(const void *target, Evas_Callback_Type type, void *event_info, void (*func)(void *target, Evas_Callback_Type type, void *event_info))
{
#ifdef BUILD_ASYNC_EVENTS
Evas_Event_Async new;
return result;
#else
- return 0;
+ func(target, type, event_info);
+
+ return 1;
#endif
}
evas_init(void)
{
if (initcount == 0)
- evas_module_init();
+ {
+ evas_module_init();
+ evas_async_events_init();
+ }
return ++initcount;
}
initcount--;
if (initcount == 0)
{
+ evas_async_events_shutdown();
evas_font_dir_cache_free();
evas_common_shutdown();
evas_module_shutdown();
}
/**
+ * Preload image in the background
+ *
+ * This function request the preload of the data image in the background. The
+ * worked is queued before being processed.
+ *
+ * If cancel is set, it will remove the image from the workqueue.
+ *
+ * @param obj The given image object.
+ * @param cancel 0 means add to the workqueue, 1 remove it.
+ * @ingroup Evas_Object_Image_Data
+ */
+EAPI void
+evas_object_image_preload(const Evas_Object *obj, Evas_Bool cancel)
+{
+ Evas_Object_Image *o;
+ DATA32 *data;
+
+ MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
+ return ;
+ MAGIC_CHECK_END();
+ o = (Evas_Object_Image *)(obj->object_data);
+ MAGIC_CHECK(o, Evas_Object_Image, MAGIC_OBJ_IMAGE);
+ return ;
+ MAGIC_CHECK_END();
+ if (!o->engine_data) return ;
+ if (cancel)
+ obj->layer->evas->engine.func->image_data_preload_cancel(obj->layer->evas->engine.data.output,
+ o->engine_data);
+ else
+ obj->layer->evas->engine.func->image_data_preload_request(obj->layer->evas->engine.data.output,
+ o->engine_data,
+ obj);
+}
+
+/**
* Replaces the raw image data of the given image object.
*
* This function lets the application replace an image object's internal pixel
Evas_Bool cached : 1;
Evas_Bool alpha : 1;
Evas_Bool alpha_sparse : 1;
+#ifdef BUILD_ASYNC_PRELOAD
+ Evas_Bool preload : 1;
+#endif
};
struct _Image_Entry
const char *file;
const char *key;
+ const void *target;
+
time_t timestamp;
time_t laststat;
void *(*image_dirty_region) (void *data, void *image, int x, int y, int w, int h);
void *(*image_data_get) (void *data, void *image, int to_write, DATA32 **image_data);
void *(*image_data_put) (void *data, void *image, DATA32 *image_data);
+ void (*image_data_preload_request) (void *data, void *image, const void *target);
+ void (*image_data_preload_cancel) (void *data, void *image);
void *(*image_alpha_set) (void *data, void *image, int has_alpha);
int (*image_alpha_get) (void *data, void *image);
void *(*image_border_set) (void *data, void *image, int l, int r, int t, int b);
static void *eng_image_dirty_region(void *data, void *image, int x, int y, int w, int h);
static void *eng_image_data_get(void *data, void *image, int to_write, DATA32 **image_data);
static void *eng_image_data_put(void *data, void *image, DATA32 *image_data);
+static void eng_image_data_preload_request(void *data, void *image, void *target);
+static void eng_image_data_preload_cancel(void *data, void *image);
static void *eng_image_alpha_set(void *data, void *image, int has_alpha);
static int eng_image_alpha_get(void *data, void *image);
static void *eng_image_border_set(void *data, void *image, int l, int r, int t, int b);
eng_image_dirty_region,
eng_image_data_get,
eng_image_data_put,
+ eng_image_data_preload_request,
+ eng_image_data_preload_cancel,
eng_image_alpha_set,
eng_image_alpha_get,
eng_image_border_set,
return image;
}
+static void
+eng_image_data_preload_request(void *data, void *image, void *target)
+{
+ Render_Engine *re;
+
+ /* FIXME */
+ re = (Render_Engine *)data;
+ return image;
+}
+
+static void
+eng_image_data_preload_cancel(void *data, void *image)
+{
+ Render_Engine *re;
+
+ /* FIXME */
+ re = (Render_Engine *)data;
+ return image;
+}
+
static void *
eng_image_alpha_set(void *data, void *image, int has_alpha)
{
return deie;
}
+static void
+evas_engine_dfb_image_data_preload_request(void *data, void *image, void *target)
+{
+ DirectFB_Engine_Image_Entry *deie = image;
+ RGBA_Image *im;
+
+ if (!deie) return ;
+ im = (RGBA_Image*) deie->cache_entry.src;
+ if (!im) return ;
+ evas_cache_image_preload_data(&im->cache_entry, target);
+}
+
+static void
+evas_engine_dfb_image_data_preload_cancel(void *data, void *image)
+{
+ DirectFB_Engine_Image_Entry *deie = image;
+ RGBA_Image *im;
+
+ if (!deie) return ;
+ im = (RGBA_Image*) deie->cache_entry.src;
+ if (!im) return ;
+ evas_cache_image_preload_cancel(&im->cache_entry);
+}
+
static void *
evas_engine_dfb_image_alpha_set(void *data, void *image, int has_alpha)
{
ORD(image_dirty_region);
ORD(image_data_get);
ORD(image_data_put);
+ ORD(image_data_preload_request);
+ ORD(image_data_preload_cancel);
ORD(image_alpha_set);
ORD(image_alpha_get);
ORD(image_draw);
}
static void
+eng_image_data_preload_request(void *data, void *image, void *target)
+{
+ Evas_GL_Image *gim = image;
+ RGBA_Image *im;
+
+ if (!gim) return ;
+ im = (RGBA_Image*) gim->im;
+ if (!im) return ;
+ evas_cache_image_preload_data(&im->cache_entry, target);
+}
+
+static void
+eng_image_data_preload_cancel(void *data, void *image)
+{
+ Evas_GL_Image *gim = image;
+ RGBA_Image *im;
+
+ if (!gim) return ;
+ im = (RGBA_Image*) gim->im;
+ if (!im) return ;
+ evas_cache_image_preload_cancel(&im->cache_entry);
+}
+
+static void
eng_image_draw(void *data, void *context, void *surface, void *image, int src_x, int src_y, int src_w, int src_h, int dst_x, int dst_y, int dst_w, int dst_h, int smooth)
{
Render_Engine *re;
ORD(image_dirty_region);
ORD(image_data_get);
ORD(image_data_put);
+ ORD(image_data_preload_request);
+ ORD(image_data_preload_cancel);
ORD(image_alpha_set);
ORD(image_alpha_get);
ORD(image_border_set);
}
static void
+eng_image_data_preload_request(void *data, void *image, void *target)
+{
+ Evas_GL_Image *gim = image;
+ RGBA_Image *im;
+
+ if (!gim) return ;
+ im = (RGBA_Image*) gim->im;
+ if (!im) return ;
+ evas_cache_image_preload_data(&im->cache_entry, target);
+}
+
+static void
+eng_image_data_preload_cancel(void *data, void *image)
+{
+ Evas_GL_Image *gim = image;
+ RGBA_Image *im;
+
+ if (!gim) return ;
+ im = (RGBA_Image*) gim->im;
+ if (!im) return ;
+ evas_cache_image_preload_cancel(&im->cache_entry);
+}
+
+static void
eng_image_draw(void *data, void *context, void *surface, void *image, int src_x, int src_y, int src_w, int src_h, int dst_x, int dst_y, int dst_w, int dst_h, int smooth)
{
Render_Engine *re;
ORD(image_dirty_region);
ORD(image_data_get);
ORD(image_data_put);
+ ORD(image_data_preload_request);
+ ORD(image_data_preload_cancel);
ORD(image_alpha_set);
ORD(image_alpha_get);
ORD(image_border_set);
return new_im;
}
-#include <assert.h>
+static void
+eng_image_data_preload_request(void *data, void *image, void *target)
+{
+ Soft16_Image *im = image;
+
+ if (!im) return ;
+ evas_cache_image_preload_data(&im->cache_entry, target);
+}
+
+static void
+eng_image_data_preload_cancel(void *data, void *image)
+{
+ Soft16_Image *im = image;
+
+ if (!im) return ;
+ evas_cache_image_preload_cancel(&im->cache_entry);
+}
static void
eng_image_draw(void *data, void *context, void *surface, void *image, int src_x, int src_y, int src_w, int src_h, int dst_x, int dst_y, int dst_w, int dst_h, int smooth)
eng_image_dirty_region,
eng_image_data_get,
eng_image_data_put,
+ eng_image_data_preload_request,
+ eng_image_data_preload_cancel,
eng_image_alpha_set,
eng_image_alpha_get,
eng_image_border_set,
return eim_new;
}
+static void
+evas_engine_sdl16_image_data_preload_request(void *data, void *image, const void *target)
+{
+ SDL_Engine_Image_Entry *eim = image;
+ Soft16_Image *im;
+
+ if (!eim) return ;
+ im = (Soft16_Image *) eim->cache_entry.src;
+ if (!im) return ;
+ evas_cache_image_preload_data(&im->cache_entry, target);
+}
+
+static void
+evas_engine_sdl16_image_data_preload_cancel(void *data, void *image)
+{
+ SDL_Engine_Image_Entry *eim = image;
+ Soft16_Image *im;
+
+ if (!eim) return ;
+ im = (Soft16_Image *) eim->cache_entry.src;
+ if (!im) return ;
+ evas_cache_image_preload_cancel(&im->cache_entry);
+}
+
static void*
evas_engine_sdl16_image_alpha_set(void *data, void *image, int has_alpha)
{
ORD(image_dirty_region);
ORD(image_data_get);
ORD(image_data_put);
+ ORD(image_data_preload_request);
+ ORD(image_data_preload_cancel);
ORD(image_alpha_set);
ORD(image_border_set);
ORD(image_border_get);
}
static void
+eng_image_data_preload_request(void *data, void *image, void *target)
+{
+ RGBA_Image *im = image;
+
+ if (!im) return ;
+ evas_cache_image_preload_data(&im->cache_entry, target);
+}
+
+static void
+eng_image_data_preload_cancel(void *data, void *image)
+{
+ RGBA_Image *im = image;
+
+ if (!im) return ;
+ evas_cache_image_preload_cancel(&im->cache_entry);
+}
+
+static void
eng_image_draw(void *data, void *context, void *surface, void *image, int src_x, int src_y, int src_w, int src_h, int dst_x, int dst_y, int dst_w, int dst_h, int smooth)
{
RGBA_Image *im;
eng_image_dirty_region,
eng_image_data_get,
eng_image_data_put,
+ eng_image_data_preload_request,
+ eng_image_data_preload_cancel,
eng_image_alpha_set,
eng_image_alpha_get,
eng_image_border_set,
return eim;
}
+static void
+evas_engine_sdl_image_data_preload_request(void *data, void *image, const void *target)
+{
+ SDL_Engine_Image_Entry *eim = image;
+ RGBA_Image *im;
+
+ if (!eim) return ;
+ im = (RGBA_Image*) eim->cache_entry.src;
+ if (!im) return ;
+ evas_cache_image_preload_data(&im->cache_entry, target);
+}
+
+static void
+evas_engine_sdl_image_data_preload_cancel(void *data, void *image)
+{
+ SDL_Engine_Image_Entry *eim = image;
+ RGBA_Image *im;
+
+ if (!eim) return ;
+ im = (RGBA_Image*) eim->cache_entry.src;
+ if (!im) return ;
+ evas_cache_image_preload_cancel(&im->cache_entry);
+}
+
static void*
evas_engine_sdl_image_alpha_set(void *data, void *image, int has_alpha)
{
ORD(image_dirty_region);
ORD(image_data_get);
ORD(image_data_put);
+ ORD(image_data_preload_request);
+ ORD(image_data_preload_cancel);
ORD(image_alpha_set);
ORD(image_alpha_get);
ORD(image_border_set);
}
static void
+eng_image_data_preload_request(void *data, void *image, const void *target)
+{
+ XR_Image *xim = image;
+ RGBA_Image *im;
+
+ if (!xim) return ;
+ im = (RGBA_Image*) xim->im;
+ if (!im) return ;
+ evas_cache_image_preload_data(&im->cache_entry, target);
+}
+
+static void
+eng_image_data_preload_cancel(void *data, void *image)
+{
+ XR_Image *xim = image;
+ RGBA_Image *im;
+
+ if (!xim) return ;
+ im = (RGBA_Image*) xim->im;
+ if (!im) return ;
+ evas_cache_image_preload_cancel(&im->cache_entry);
+}
+
+static void
eng_image_draw(void *data, void *context, void *surface, void *image, int src_x, int src_y, int src_w, int src_h, int dst_x, int dst_y, int dst_w, int dst_h, int smooth)
{
if ((!image) || (!surface)) return;
ORD(image_dirty_region);
ORD(image_data_get);
ORD(image_data_put);
+ ORD(image_data_preload_request);
+ ORD(image_data_preload_cancel);
ORD(image_alpha_set);
ORD(image_alpha_get);
ORD(image_border_set);
return image;
}
+static void
+eng_image_data_preload_request(void *data, void *image, void *target)
+{
+ XR_Image *xim = image;
+ RGBA_Image *im;
+
+ if (!xim) return ;
+ im = (RGBA_Image*) xim->im;
+ if (!im) return ;
+ evas_cache_image_preload_data(&im->cache_entry, target);
+}
+
+static void
+eng_image_data_preload_cancel(void *data, void *image)
+{
+ XR_Image *xim = image;
+ RGBA_Image *im;
+
+ if (!xim) return ;
+ im = (RGBA_Image*) xim->im;
+ if (!im) return ;
+ evas_cache_image_preload_data(&im->cache_entry, target);
+}
+
static void *
eng_image_alpha_set(void *data, void *image, int has_alpha)
{
ORD(image_dirty_region);
ORD(image_data_get);
ORD(image_data_put);
+ ORD(image_data_preload_request);
+ ORD(image_data_preload_cancel);
ORD(image_alpha_set);
ORD(image_alpha_get);
ORD(image_border_set);
projects / profile / ivi / evas.git / commitdiff