1
2 #include "evas_image_private.h"
3 #include "evas_image_eo.h"
4
5 #define EVAS_IMAGE_API(_o, ...) do { \
6 if (EINA_UNLIKELY(!efl_isa(_o, EFL_CANVAS_IMAGE_INTERNAL_CLASS))) { \
7 EINA_SAFETY_ERROR("object is not an image!"); \
8 return __VA_ARGS__; \
9 } } while (0)
10
11 #define EVAS_IMAGE_LEGACY_API(_o, ...) do { \
12 EVAS_OBJECT_LEGACY_API(_o, __VA_ARGS__); \
13 EVAS_IMAGE_API(_o, __VA_ARGS__); \
14 } while (0)
15
16 typedef struct _Evas_Image_Legacy_Pixels_Entry Evas_Image_Legacy_Pixels_Entry;
17
18 struct _Evas_Image_Legacy_Pixels_Entry
19 {
20 Eo *object;
21 void *image;
22 };
23
24 EAPI Evas_Object *
evas_object_image_add(Evas * eo_e)25 evas_object_image_add(Evas *eo_e)
26 {
27 eo_e = evas_find(eo_e);
28 EINA_SAFETY_ON_FALSE_RETURN_VAL(efl_isa(eo_e, EVAS_CANVAS_CLASS), NULL);
29 return efl_add(EVAS_IMAGE_CLASS, eo_e,
30 efl_gfx_fill_auto_set(efl_added, EINA_FALSE),
31 efl_canvas_object_legacy_ctor(efl_added));
32 }
33
34 EAPI Evas_Object *
evas_object_image_filled_add(Evas * eo_e)35 evas_object_image_filled_add(Evas *eo_e)
36 {
37 eo_e = evas_find(eo_e);
38 EINA_SAFETY_ON_FALSE_RETURN_VAL(efl_isa(eo_e, EVAS_CANVAS_CLASS), NULL);
39 return efl_add(EVAS_IMAGE_CLASS, eo_e,
40 efl_canvas_object_legacy_ctor(efl_added));
41 }
42
43 EAPI void
evas_object_image_memfile_set(Evas_Object * eo_obj,void * data,int size,char * format EINA_UNUSED,char * key)44 evas_object_image_memfile_set(Evas_Object *eo_obj, void *data, int size, char *format EINA_UNUSED, char *key)
45 {
46 Eina_File *f;
47
48 EVAS_IMAGE_API(eo_obj);
49
50 f = eina_file_virtualize(NULL, data, size, EINA_TRUE);
51 if (!f) return ;
52 efl_file_simple_mmap_load(eo_obj, f, key);
53 eina_file_close(f); // close matching open OK
54 }
55
56 EAPI void
evas_object_image_fill_set(Evas_Object * obj,Evas_Coord x,Evas_Coord y,Evas_Coord w,Evas_Coord h)57 evas_object_image_fill_set(Evas_Object *obj,
58 Evas_Coord x, Evas_Coord y,
59 Evas_Coord w, Evas_Coord h)
60 {
61 EVAS_IMAGE_API(obj);
62 _evas_image_fill_set(obj, efl_data_scope_get(obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS), x, y, w, h);
63 }
64
65 EAPI void
evas_object_image_preload(Evas_Object * eo_obj,Eina_Bool cancel)66 evas_object_image_preload(Evas_Object *eo_obj, Eina_Bool cancel)
67 {
68 EVAS_IMAGE_API(eo_obj);
69 if (cancel) _evas_image_load_async_cancel(eo_obj);
70 else _evas_image_load_async_start(eo_obj);
71 }
72
73 EAPI Eina_Bool
evas_object_image_filled_get(const Evas_Object * eo_obj)74 evas_object_image_filled_get(const Evas_Object *eo_obj)
75 {
76 EVAS_IMAGE_API(eo_obj, EINA_FALSE);
77 return efl_gfx_fill_auto_get(eo_obj);
78 }
79
80 EAPI void
evas_object_image_filled_set(Evas_Object * eo_obj,Eina_Bool value)81 evas_object_image_filled_set(Evas_Object *eo_obj, Eina_Bool value)
82 {
83 EVAS_IMAGE_API(eo_obj);
84 efl_gfx_fill_auto_set(eo_obj, value);
85 }
86
87 EAPI void
evas_object_image_fill_get(const Evas_Object * obj,Evas_Coord * x,Evas_Coord * y,Evas_Coord * w,Evas_Coord * h)88 evas_object_image_fill_get(const Evas_Object *obj,
89 Evas_Coord *x, Evas_Coord *y,
90 Evas_Coord *w, Evas_Coord *h)
91 {
92 Eina_Rect r;
93
94 EVAS_IMAGE_API(obj);
95 r = efl_gfx_fill_get(obj);
96 if (x) *x = r.x;
97 if (y) *y = r.y;
98 if (w) *w = r.w;
99 if (h) *h = r.h;
100 }
101
102 EAPI void
evas_object_image_alpha_set(Evas_Object * obj,Eina_Bool alpha)103 evas_object_image_alpha_set(Evas_Object *obj, Eina_Bool alpha)
104 {
105 EVAS_IMAGE_API(obj);
106 efl_gfx_buffer_alpha_set(obj, alpha);
107 }
108
109 EAPI Eina_Bool
evas_object_image_alpha_get(const Evas_Object * obj)110 evas_object_image_alpha_get(const Evas_Object *obj)
111 {
112 EVAS_IMAGE_API(obj, EINA_FALSE);
113 return efl_gfx_buffer_alpha_get(obj);
114 }
115
116 EAPI void
evas_object_image_border_set(Evas_Object * obj,int l,int r,int t,int b)117 evas_object_image_border_set(Evas_Object *obj, int l, int r, int t, int b)
118 {
119 EVAS_IMAGE_API(obj);
120 efl_gfx_image_border_insets_set(obj, l, r, t, b);
121 }
122
123 EAPI void
evas_object_image_border_get(const Evas_Object * obj,int * l,int * r,int * t,int * b)124 evas_object_image_border_get(const Evas_Object *obj, int *l, int *r, int *t, int *b)
125 {
126 EVAS_IMAGE_API(obj);
127 efl_gfx_image_border_insets_get(obj, l, r, t, b);
128 }
129
130 EAPI void
evas_object_image_border_scale_set(Evas_Object * obj,double scale)131 evas_object_image_border_scale_set(Evas_Object *obj, double scale)
132 {
133 EVAS_IMAGE_API(obj);
134 efl_gfx_image_border_insets_scale_set(obj, scale);
135 }
136
137 EAPI double
evas_object_image_border_scale_get(const Evas_Object * obj)138 evas_object_image_border_scale_get(const Evas_Object *obj)
139 {
140 EVAS_IMAGE_API(obj, 0.0);
141 return efl_gfx_image_border_insets_scale_get(obj);
142 }
143
144 EAPI void
evas_object_image_border_center_fill_set(Evas_Object * obj,Evas_Border_Fill_Mode fill)145 evas_object_image_border_center_fill_set(Evas_Object *obj, Evas_Border_Fill_Mode fill)
146 {
147 EVAS_IMAGE_API(obj);
148 efl_gfx_image_center_fill_mode_set(obj, (Efl_Gfx_Center_Fill_Mode) fill);
149 }
150
151 EAPI Evas_Border_Fill_Mode
evas_object_image_border_center_fill_get(const Evas_Object * obj)152 evas_object_image_border_center_fill_get(const Evas_Object *obj)
153 {
154 EVAS_IMAGE_API(obj, EVAS_BORDER_FILL_NONE);
155 return (Evas_Border_Fill_Mode) efl_gfx_image_center_fill_mode_get(obj);
156 }
157
158 EAPI void
evas_object_image_size_get(const Evas_Object * obj,int * w,int * h)159 evas_object_image_size_get(const Evas_Object *obj, int *w, int *h)
160 {
161 Eina_Size2D sz;
162 EVAS_IMAGE_API(obj);
163 sz = efl_gfx_view_size_get(obj);
164 if (w) *w = sz.w;
165 if (h) *h = sz.h;
166 }
167
168 EAPI Evas_Colorspace
evas_object_image_colorspace_get(const Evas_Object * obj)169 evas_object_image_colorspace_get(const Evas_Object *obj)
170 {
171 EVAS_IMAGE_API(obj, EVAS_COLORSPACE_ARGB8888);
172 return (Evas_Colorspace) efl_gfx_buffer_colorspace_get(obj);
173 }
174
175 EAPI int
evas_object_image_stride_get(const Evas_Object * obj)176 evas_object_image_stride_get(const Evas_Object *obj)
177 {
178 EVAS_IMAGE_API(obj, 0);
179 Evas_Image_Data *o = efl_data_scope_get(obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
180 return o->cur->image.stride;
181 }
182
183 EAPI void
evas_object_image_data_update_add(Evas_Object * obj,int x,int y,int w,int h)184 evas_object_image_data_update_add(Evas_Object *obj, int x, int y, int w, int h)
185 {
186 Eina_Rect r;
187
188 EVAS_IMAGE_API(obj);
189 r = EINA_RECT(x, y, w, h);
190 efl_gfx_buffer_update_add(obj, &r);
191 }
192
193 EAPI void
evas_object_image_file_set(Evas_Object * obj,const char * file,const char * key)194 evas_object_image_file_set(Evas_Object *obj, const char *file, const char *key)
195 {
196 EVAS_IMAGE_API(obj);
197 efl_file_simple_load(obj, file, key);
198 }
199
200 EAPI void
evas_object_image_file_get(const Evas_Object * obj,const char ** file,const char ** key)201 evas_object_image_file_get(const Evas_Object *obj, const char **file, const char **key)
202 {
203 EVAS_IMAGE_API(obj);
204 efl_file_simple_get(obj, file, key);
205 }
206
207 EAPI void
evas_object_image_mmap_set(Evas_Object * obj,const Eina_File * f,const char * key)208 evas_object_image_mmap_set(Evas_Object *obj, const Eina_File *f, const char *key)
209 {
210 EVAS_IMAGE_API(obj);
211 efl_file_simple_mmap_load(obj, f, key);
212 }
213
214 EAPI void
evas_object_image_mmap_get(const Evas_Object * obj,const Eina_File ** f,const char ** key)215 evas_object_image_mmap_get(const Evas_Object *obj, const Eina_File **f, const char **key)
216 {
217 EVAS_IMAGE_API(obj);
218 efl_file_simple_mmap_get(obj, f, key);
219 }
220
221 EAPI Eina_Bool
evas_object_image_save(const Evas_Object * obj,const char * file,const char * key,const char * flags)222 evas_object_image_save(const Evas_Object *obj, const char *file, const char *key, const char *flags)
223 {
224 char *encoding = NULL;
225 Efl_File_Save_Info info;
226 Eina_Error ret;
227
228 EVAS_IMAGE_API(obj, EINA_FALSE);
229
230 if (flags)
231 {
232 char *p, *pp;
233 char *tflags;
234 int quality = 80, compress = 9;
235
236 tflags = alloca(strlen(flags) + 1);
237 strcpy(tflags, flags);
238 p = tflags;
239 while (p)
240 {
241 pp = strchr(p, ' ');
242 if (pp) *pp = 0;
243 sscanf(p, "quality=%4i", &quality);
244 sscanf(p, "compress=%4i", &compress);
245 sscanf(p, "encoding=%ms", &encoding);
246 if (pp) p = pp + 1;
247 else break;
248 }
249 info.quality = quality;
250 info.compression = compress;
251 info.encoding = encoding;
252
253 }
254 ret = efl_file_save(obj, file, key, flags ? &info : NULL);
255 free(encoding);
256 return ret;
257 }
258
259 EAPI Eina_Bool
evas_object_image_animated_get(const Evas_Object * obj)260 evas_object_image_animated_get(const Evas_Object *obj)
261 {
262 EVAS_IMAGE_API(obj, EINA_FALSE);
263 return _evas_image_animated_get(obj);
264 }
265
266 EAPI void
evas_object_image_animated_frame_set(Evas_Object * obj,int frame_index)267 evas_object_image_animated_frame_set(Evas_Object *obj, int frame_index)
268 {
269 EVAS_IMAGE_API(obj);
270 _evas_image_animated_frame_set(obj, frame_index);
271 }
272
273 EAPI int
evas_object_image_animated_frame_get(Evas_Object * obj)274 evas_object_image_animated_frame_get(Evas_Object *obj)
275 {
276 EVAS_IMAGE_API(obj, 0);
277 return _evas_image_animated_frame_get(obj);
278 }
279
280 EAPI int
evas_object_image_animated_frame_count_get(const Evas_Object * obj)281 evas_object_image_animated_frame_count_get(const Evas_Object *obj)
282 {
283 EVAS_IMAGE_API(obj, 0);
284 return _evas_image_animated_frame_count_get(obj);
285 }
286
287 EAPI Evas_Image_Animated_Loop_Hint
evas_object_image_animated_loop_type_get(const Evas_Object * obj)288 evas_object_image_animated_loop_type_get(const Evas_Object *obj)
289 {
290 EVAS_IMAGE_API(obj, EVAS_IMAGE_ANIMATED_HINT_NONE);
291 return (Evas_Image_Animated_Loop_Hint) _evas_image_animated_loop_type_get(obj);
292 }
293
294 EAPI int
evas_object_image_animated_loop_count_get(const Evas_Object * obj)295 evas_object_image_animated_loop_count_get(const Evas_Object *obj)
296 {
297 EVAS_IMAGE_API(obj, 0);
298 return _evas_image_animated_loop_count_get(obj);
299 }
300
301 EAPI double
evas_object_image_animated_frame_duration_get(const Evas_Object * obj,int start_frame,int frame_num)302 evas_object_image_animated_frame_duration_get(const Evas_Object *obj, int start_frame, int frame_num)
303 {
304 EVAS_IMAGE_API(obj, 0.0);
305 return _evas_image_animated_frame_duration_get(obj, start_frame, frame_num);
306 }
307
308 EAPI void
evas_object_image_load_size_set(Evas_Object * obj,int w,int h)309 evas_object_image_load_size_set(Evas_Object *obj, int w, int h)
310 {
311 EVAS_IMAGE_API(obj);
312 _evas_image_load_size_set(obj, w, h);
313 }
314
315 EAPI void
evas_object_image_load_size_get(const Evas_Object * obj,int * w,int * h)316 evas_object_image_load_size_get(const Evas_Object *obj, int *w, int *h)
317 {
318 EVAS_IMAGE_API(obj);
319 _evas_image_load_size_get(obj, w, h);
320 }
321
322 EAPI void
evas_object_image_load_dpi_set(Evas_Object * obj,double dpi)323 evas_object_image_load_dpi_set(Evas_Object *obj, double dpi)
324 {
325 EVAS_IMAGE_API(obj);
326 _evas_image_load_dpi_set(obj, dpi);
327 }
328
329 EAPI double
evas_object_image_load_dpi_get(const Evas_Object * obj)330 evas_object_image_load_dpi_get(const Evas_Object *obj)
331 {
332 EVAS_IMAGE_API(obj, 0.0);
333 return _evas_image_load_dpi_get(obj);
334 }
335
336 EAPI void
evas_object_image_load_region_set(Evas_Object * obj,int x,int y,int w,int h)337 evas_object_image_load_region_set(Evas_Object *obj, int x, int y, int w, int h)
338 {
339 EVAS_IMAGE_API(obj);
340 _evas_image_load_region_set(obj, x, y, w, h);
341 }
342
343 EAPI void
evas_object_image_load_region_get(const Evas_Object * obj,int * x,int * y,int * w,int * h)344 evas_object_image_load_region_get(const Evas_Object *obj, int *x, int *y, int *w, int *h)
345 {
346 EVAS_IMAGE_API(obj);
347 _evas_image_load_region_get(obj, x, y, w, h);
348 }
349
350 EAPI Eina_Bool
evas_object_image_region_support_get(const Evas_Object * obj)351 evas_object_image_region_support_get(const Evas_Object *obj)
352 {
353 EVAS_IMAGE_API(obj, EINA_FALSE);
354 return _evas_image_load_region_support_get(obj);
355 }
356
357 EAPI void
evas_object_image_load_orientation_set(Evas_Object * obj,Eina_Bool enable)358 evas_object_image_load_orientation_set(Evas_Object *obj, Eina_Bool enable)
359 {
360 EVAS_IMAGE_API(obj);
361 _evas_image_load_orientation_set(obj, enable);
362 }
363
364 EAPI Eina_Bool
evas_object_image_load_orientation_get(const Evas_Object * obj)365 evas_object_image_load_orientation_get(const Evas_Object *obj)
366 {
367 EVAS_IMAGE_API(obj, EINA_FALSE);
368 return _evas_image_load_orientation_get(obj);
369 }
370
371 EAPI void
evas_object_image_load_scale_down_set(Evas_Object * obj,int scale_down)372 evas_object_image_load_scale_down_set(Evas_Object *obj, int scale_down)
373 {
374 EVAS_IMAGE_API(obj);
375 _evas_image_load_scale_down_set(obj, scale_down);
376 }
377
378 EAPI int
evas_object_image_load_scale_down_get(const Evas_Object * obj)379 evas_object_image_load_scale_down_get(const Evas_Object *obj)
380 {
381 EVAS_IMAGE_API(obj, 1);
382 return _evas_image_load_scale_down_get(obj);
383 }
384
385 EAPI void
evas_object_image_load_head_skip_set(Evas_Object * obj,Eina_Bool skip)386 evas_object_image_load_head_skip_set(Evas_Object *obj, Eina_Bool skip)
387 {
388 EVAS_IMAGE_API(obj);
389 _evas_image_load_head_skip_set(obj, skip);
390 }
391
392 EAPI Eina_Bool
evas_object_image_load_head_skip_get(const Evas_Object * obj)393 evas_object_image_load_head_skip_get(const Evas_Object *obj)
394 {
395 EVAS_IMAGE_API(obj, EINA_FALSE);
396 return _evas_image_load_head_skip_get(obj);
397 }
398
399 EAPI Evas_Load_Error
evas_object_image_load_error_get(const Evas_Object * obj)400 evas_object_image_load_error_get(const Evas_Object *obj)
401 {
402 EVAS_IMAGE_API(obj, EVAS_LOAD_ERROR_GENERIC);
403 return _efl_gfx_image_load_error_to_evas_load_error(efl_gfx_image_load_error_get(obj));
404 }
405
406 EAPI void
evas_object_image_smooth_scale_set(Evas_Object * obj,Eina_Bool smooth_scale)407 evas_object_image_smooth_scale_set(Evas_Object *obj, Eina_Bool smooth_scale)
408 {
409 EVAS_IMAGE_API(obj);
410 efl_gfx_image_smooth_scale_set(obj, smooth_scale);
411 }
412
413 EAPI Eina_Bool
evas_object_image_smooth_scale_get(const Evas_Object * obj)414 evas_object_image_smooth_scale_get(const Evas_Object *obj)
415 {
416 EVAS_IMAGE_API(obj, EINA_FALSE);
417 return efl_gfx_image_smooth_scale_get(obj);
418 }
419
420 EAPI void
evas_object_image_orient_set(Evas_Object * obj,Evas_Image_Orient orient)421 evas_object_image_orient_set(Evas_Object *obj, Evas_Image_Orient orient)
422 {
423 EVAS_IMAGE_API(obj);
424
425 Evas_Image_Data *o = efl_data_scope_get(obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
426 _evas_image_orientation_set(obj, o, orient);
427 }
428
429 EAPI Evas_Image_Orient
evas_object_image_orient_get(const Evas_Object * obj)430 evas_object_image_orient_get(const Evas_Object *obj)
431 {
432 EVAS_IMAGE_API(obj, EVAS_IMAGE_ORIENT_NONE);
433
434 Evas_Image_Data *o = efl_data_scope_get(obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
435
436 return o->cur->orient;
437 }
438
439 EAPI void
evas_object_image_snapshot_set(Evas_Object * eo,Eina_Bool s)440 evas_object_image_snapshot_set(Evas_Object *eo, Eina_Bool s)
441 {
442 EVAS_IMAGE_API(eo);
443
444 Evas_Object_Protected_Data *obj = efl_data_scope_get(eo, EFL_CANVAS_OBJECT_CLASS);
445
446 if (obj->cur->snapshot == s) return;
447
448 EINA_COW_STATE_WRITE_BEGIN(obj, state_write, cur)
449 state_write->snapshot = !!s;
450 EINA_COW_STATE_WRITE_END(obj, state_write, cur);
451 }
452
453 EAPI Eina_Bool
evas_object_image_snapshot_get(const Evas_Object * eo)454 evas_object_image_snapshot_get(const Evas_Object *eo)
455 {
456 EVAS_IMAGE_API(eo, EINA_FALSE);
457
458 Evas_Object_Protected_Data *obj = efl_data_scope_get(eo, EFL_CANVAS_OBJECT_CLASS);
459 return obj->cur->snapshot;
460 }
461
462 EAPI Eina_Bool
evas_object_image_source_set(Evas_Object * eo,Evas_Object * src)463 evas_object_image_source_set(Evas_Object *eo, Evas_Object *src)
464 {
465 EVAS_IMAGE_API(eo, EINA_FALSE);
466 return _evas_image_proxy_source_set(eo, src);
467 }
468
469 EAPI Evas_Object *
evas_object_image_source_get(const Evas_Object * eo)470 evas_object_image_source_get(const Evas_Object *eo)
471 {
472 EVAS_IMAGE_API(eo, NULL);
473 return _evas_image_proxy_source_get(eo);
474 }
475
476 EAPI Eina_Bool
evas_object_image_source_unset(Evas_Object * eo_obj)477 evas_object_image_source_unset(Evas_Object *eo_obj)
478 {
479 EVAS_IMAGE_API(eo_obj, EINA_FALSE);
480 return _evas_image_proxy_source_set(eo_obj, NULL);
481 }
482
483 EAPI void
evas_object_image_source_clip_set(Evas_Object * eo,Eina_Bool source_clip)484 evas_object_image_source_clip_set(Evas_Object *eo, Eina_Bool source_clip)
485 {
486 EVAS_IMAGE_API(eo);
487 _evas_image_proxy_source_clip_set(eo, source_clip);
488 }
489
490 EAPI Eina_Bool
evas_object_image_source_clip_get(const Evas_Object * eo)491 evas_object_image_source_clip_get(const Evas_Object *eo)
492 {
493 EVAS_IMAGE_API(eo, EINA_FALSE);
494 return _evas_image_proxy_source_clip_get(eo);
495 }
496
497 EAPI void
evas_object_image_source_events_set(Evas_Object * eo,Eina_Bool repeat)498 evas_object_image_source_events_set(Evas_Object *eo, Eina_Bool repeat)
499 {
500 EVAS_IMAGE_API(eo);
501 _evas_image_proxy_source_events_set(eo, repeat);
502 }
503
504 EAPI Eina_Bool
evas_object_image_source_events_get(const Evas_Object * eo)505 evas_object_image_source_events_get(const Evas_Object *eo)
506 {
507 EVAS_IMAGE_API(eo, EINA_FALSE);
508 return _evas_image_proxy_source_events_get(eo);
509 }
510
511 EAPI void
evas_object_image_content_hint_set(Evas_Object * obj,Evas_Image_Content_Hint hint)512 evas_object_image_content_hint_set(Evas_Object *obj, Evas_Image_Content_Hint hint)
513 {
514 EVAS_IMAGE_API(obj);
515 efl_gfx_image_content_hint_set(obj, (Efl_Gfx_Image_Content_Hint)hint);
516 }
517
518 EAPI Evas_Image_Content_Hint
evas_object_image_content_hint_get(const Evas_Object * obj)519 evas_object_image_content_hint_get(const Evas_Object *obj)
520 {
521 EVAS_IMAGE_API(obj, EVAS_IMAGE_CONTENT_HINT_NONE);
522 return (Evas_Image_Content_Hint)efl_gfx_image_content_hint_get(obj);
523 }
524
525 EAPI void
evas_object_image_scale_hint_set(Evas_Object * obj,Evas_Image_Scale_Hint hint)526 evas_object_image_scale_hint_set(Evas_Object *obj, Evas_Image_Scale_Hint hint)
527 {
528 EVAS_IMAGE_API(obj);
529 return efl_gfx_image_scale_hint_set(obj, (Efl_Gfx_Image_Scale_Hint) hint);
530 }
531
532 EAPI Evas_Image_Scale_Hint
evas_object_image_scale_hint_get(const Evas_Object * obj)533 evas_object_image_scale_hint_get(const Evas_Object *obj)
534 {
535 EVAS_IMAGE_API(obj, EVAS_IMAGE_SCALE_HINT_NONE);
536 return (Evas_Image_Scale_Hint) efl_gfx_image_scale_hint_get(obj);
537 }
538
539 EAPI void
evas_object_image_native_surface_set(Evas_Object * eo_obj,Evas_Native_Surface * surf)540 evas_object_image_native_surface_set(Evas_Object *eo_obj, Evas_Native_Surface *surf)
541 {
542 EVAS_IMAGE_API(eo_obj);
543
544 Eina_Bool ret;
545
546 ret = _evas_image_native_surface_set(eo_obj, surf);
547
548 if (surf && !ret)
549 {
550 Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
551
552 o->load_error = EFL_GFX_IMAGE_LOAD_ERROR_GENERIC;
553 }
554 }
555
556 EAPI Evas_Native_Surface *
evas_object_image_native_surface_get(const Evas_Object * eo_obj)557 evas_object_image_native_surface_get(const Evas_Object *eo_obj)
558 {
559 EVAS_IMAGE_API(eo_obj, NULL);
560 return _evas_image_native_surface_get(eo_obj);
561 }
562
563 EAPI void
evas_object_image_pixels_get_callback_set(Eo * eo_obj,Evas_Object_Image_Pixels_Get_Cb func,void * data)564 evas_object_image_pixels_get_callback_set(Eo *eo_obj, Evas_Object_Image_Pixels_Get_Cb func, void *data)
565 {
566 EVAS_IMAGE_API(eo_obj);
567
568 Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
569 Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
570
571 evas_object_async_block(obj);
572 EINA_COW_PIXEL_WRITE_BEGIN(o, pixi_write)
573 {
574 pixi_write->func.get_pixels = func;
575 pixi_write->func.get_pixels_data = data;
576 }
577 EINA_COW_PIXEL_WRITE_END(o, pixi_write);
578 }
579
580 EAPI void
evas_object_image_pixels_dirty_set(Eo * eo_obj,Eina_Bool dirty)581 evas_object_image_pixels_dirty_set(Eo *eo_obj, Eina_Bool dirty)
582 {
583 EVAS_IMAGE_API(eo_obj);
584
585 Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
586 Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
587
588 evas_object_async_block(obj);
589 if (dirty)
590 {
591 o->dirty_pixels = EINA_TRUE;
592 o->changed = EINA_TRUE;
593 }
594 else o->dirty_pixels = EINA_FALSE;
595
596 evas_object_change(eo_obj, obj);
597 }
598
599 EAPI Eina_Bool
evas_object_image_pixels_dirty_get(const Eo * eo_obj)600 evas_object_image_pixels_dirty_get(const Eo *eo_obj)
601 {
602 EVAS_IMAGE_API(eo_obj, EINA_FALSE);
603
604 Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
605
606 return (o->dirty_pixels ? 1 : 0);
607 }
608
609 EAPI void
evas_object_image_data_set(Eo * eo_obj,void * data)610 evas_object_image_data_set(Eo *eo_obj, void *data)
611 {
612 EVAS_IMAGE_API(eo_obj);
613
614 Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
615 Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
616 void *p_data, *pixels;
617 Eina_Bool resize_call = EINA_FALSE;
618
619
620 evas_object_async_block(obj);
621 evas_render_rendering_wait(obj->layer->evas);
622
623 _evas_image_cleanup(eo_obj, obj, o);
624 p_data = o->engine_data;
625 if (data)
626 {
627 // r/o FBO data_get: only free the image, don't update pixels
628 if ((pixels = eina_hash_find(o->pixels->images_to_free, data)) != NULL)
629 {
630 eina_hash_del(o->pixels->images_to_free, data, pixels);
631 return;
632 }
633
634 if (o->engine_data)
635 {
636 o->engine_data = ENFN->image_data_put(ENC, o->engine_data, data);
637 }
638 else
639 {
640 o->engine_data = ENFN->image_new_from_data(ENC,
641 o->cur->image.w,
642 o->cur->image.h,
643 data,
644 o->cur->has_alpha,
645 o->cur->cspace);
646 }
647 if (o->engine_data)
648 {
649 int stride = 0;
650
651 if (ENFN->image_scale_hint_set)
652 ENFN->image_scale_hint_set(ENC, o->engine_data, o->scale_hint);
653
654 if (ENFN->image_content_hint_set)
655 ENFN->image_content_hint_set(ENC, o->engine_data, o->content_hint);
656
657 if (ENFN->image_stride_get)
658 ENFN->image_stride_get(ENC, o->engine_data, &stride);
659 else
660 stride = o->cur->image.w * 4;
661
662 if (o->cur->image.stride != stride)
663 {
664 EINA_COW_IMAGE_STATE_WRITE_BEGIN(o, state_write)
665 state_write->image.stride = stride;
666 EINA_COW_IMAGE_STATE_WRITE_END(o, state_write);
667 }
668 }
669 o->written = EINA_TRUE;
670 }
671 else
672 {
673 if (o->engine_data)
674 {
675 ENFN->image_free(ENC, o->engine_data);
676 o->engine_data = NULL;
677 o->changed = EINA_TRUE;
678 evas_object_change(eo_obj, obj);
679 }
680 o->load_error = EFL_GFX_IMAGE_LOAD_ERROR_NONE;
681 if ((o->cur->image.w != 0) || (o->cur->image.h != 0))
682 resize_call = EINA_TRUE;
683
684 EINA_COW_IMAGE_STATE_WRITE_BEGIN(o, state_write)
685 {
686 state_write->image.w = 0;
687 state_write->image.h = 0;
688 state_write->image.stride = 0;
689 }
690 EINA_COW_IMAGE_STATE_WRITE_END(o, state_write);
691 }
692 /* FIXME - in engine call above
693 if (o->engine_data)
694 o->engine_data = ENFN->image_alpha_set(ENC, o->engine_data, o->cur->has_alpha);
695 */
696 if (o->pixels_checked_out > 0) o->pixels_checked_out--;
697 if (p_data != o->engine_data)
698 {
699 o->pixels_checked_out = 0;
700 }
701 if (resize_call) evas_object_inform_call_image_resize(eo_obj);
702 }
703
704 static void
_image_to_free_del_cb(void * data)705 _image_to_free_del_cb(void *data)
706 {
707 Evas_Image_Legacy_Pixels_Entry *px_entry = data;
708 Evas_Object_Protected_Data *obj;
709
710 obj = efl_data_scope_safe_get(px_entry->object, EFL_CANVAS_OBJECT_CLASS);
711 EINA_SAFETY_ON_NULL_RETURN(obj);
712 ENFN->image_free(ENC, px_entry->image);
713 free(px_entry);
714 }
715
716 EAPI void*
evas_object_image_data_get(const Eo * eo_obj,Eina_Bool for_writing)717 evas_object_image_data_get(const Eo *eo_obj, Eina_Bool for_writing)
718 {
719 EVAS_IMAGE_API(eo_obj, NULL);
720
721 Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
722 Evas_Image_Legacy_Pixels_Entry *px_entry = NULL;
723 Eina_Bool tofree = 0;
724 void *pixels = NULL;
725 int stride = 0;
726 DATA32 *data;
727 int load_error;
728
729 if (!o->engine_data) return NULL;
730
731 Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
732
733 if (for_writing) evas_object_async_block(obj);
734 if (for_writing) evas_render_rendering_wait(obj->layer->evas);
735
736 data = NULL;
737 if (ENFN->image_scale_hint_set)
738 ENFN->image_scale_hint_set(ENC, o->engine_data, o->scale_hint);
739 if (ENFN->image_content_hint_set)
740 ENFN->image_content_hint_set(ENC, o->engine_data, o->content_hint);
741 pixels = ENFN->image_data_get(ENC, o->engine_data, for_writing, &data, &load_error, &tofree);
742 o->load_error = _evas_load_error_to_efl_gfx_image_load_error(load_error);
743
744 /* if we fail to get engine_data, we have to return NULL */
745 if (!pixels || !data) goto error;
746
747 if (!tofree)
748 {
749 o->engine_data = pixels;
750 if (ENFN->image_stride_get)
751 ENFN->image_stride_get(ENC, o->engine_data, &stride);
752 else
753 stride = o->cur->image.w * 4;
754
755 if (o->cur->image.stride != stride)
756 {
757 EINA_COW_IMAGE_STATE_WRITE_BEGIN(o, state_write)
758 state_write->image.stride = stride;
759 EINA_COW_IMAGE_STATE_WRITE_END(o, state_write);
760 }
761
762 o->pixels_checked_out++;
763 }
764 else
765 {
766 Eina_Hash *hash = o->pixels->images_to_free;
767
768 if (!hash)
769 {
770 hash = eina_hash_pointer_new(_image_to_free_del_cb);
771 if (!hash) goto error;
772 EINA_COW_PIXEL_WRITE_BEGIN(o, pixi_write)
773 pixi_write->images_to_free = hash;
774 EINA_COW_PIXEL_WRITE_END(o, pixi_write);
775 }
776
777 px_entry = calloc(1, sizeof(*px_entry));
778 px_entry->object = (Eo *) eo_obj;
779 px_entry->image = pixels;
780 if (!eina_hash_add(hash, data, px_entry))
781 goto error;
782 }
783
784 if (for_writing)
785 {
786 o->written = EINA_TRUE;
787 }
788
789 return data;
790
791 error:
792 free(px_entry);
793 if (tofree && pixels)
794 ENFN->image_free(ENC, pixels);
795 return NULL;
796 }
797
798 EAPI void
evas_object_image_data_copy_set(Eo * eo_obj,void * data)799 evas_object_image_data_copy_set(Eo *eo_obj, void *data)
800 {
801 EVAS_IMAGE_API(eo_obj);
802
803 Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
804 Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
805
806 if (!data) return;
807 evas_object_async_block(obj);
808 _evas_image_cleanup(eo_obj, obj, o);
809 if ((o->cur->image.w <= 0) ||
810 (o->cur->image.h <= 0)) return;
811 if (o->engine_data)
812 ENFN->image_free(ENC, o->engine_data);
813 o->engine_data = ENFN->image_new_from_copied_data(ENC,
814 o->cur->image.w,
815 o->cur->image.h,
816 data,
817 o->cur->has_alpha,
818 o->cur->cspace);
819 if (o->engine_data)
820 {
821 int stride = 0;
822
823 o->engine_data =
824 ENFN->image_alpha_set(ENC, o->engine_data, o->cur->has_alpha);
825 if (ENFN->image_scale_hint_set)
826 ENFN->image_scale_hint_set(ENC, o->engine_data, o->scale_hint);
827 if (ENFN->image_content_hint_set)
828 ENFN->image_content_hint_set(ENC, o->engine_data, o->content_hint);
829 if (ENFN->image_stride_get)
830 ENFN->image_stride_get(ENC, o->engine_data, &stride);
831 else
832 stride = o->cur->image.w * 4;
833
834 if (o->cur->image.stride != stride)
835 {
836 EINA_COW_IMAGE_STATE_WRITE_BEGIN(o, state_write)
837 state_write->image.stride = stride;
838 EINA_COW_IMAGE_STATE_WRITE_END(o, state_write);
839 }
840 o->written = EINA_TRUE;
841 }
842 o->pixels_checked_out = 0;
843 }
844
845 /* Evas_Object equivalent: pixels_set(null, w, h, cspace) to (re)allocate an image */
846 EAPI void
evas_object_image_size_set(Evas_Object * eo_obj,int w,int h)847 evas_object_image_size_set(Evas_Object *eo_obj, int w, int h)
848 {
849 EVAS_IMAGE_API(eo_obj);
850
851 Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
852 Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
853 int stride = 0;
854
855 evas_object_async_block(obj);
856 _evas_image_cleanup(eo_obj, obj, o);
857 if (w < 1) w = 1;
858 if (h < 1) h = 1;
859 if (w >= 32768) return;
860 if (h >= 32768) return;
861 if ((w == o->cur->image.w) &&
862 (h == o->cur->image.h)) return;
863
864 EINA_COW_IMAGE_STATE_WRITE_BEGIN(o, state_write)
865 {
866 state_write->image.w = w;
867 state_write->image.h = h;
868 }
869 EINA_COW_IMAGE_STATE_WRITE_END(o, state_write);
870
871 if (o->engine_data)
872 o->engine_data = ENFN->image_size_set(ENC, o->engine_data, w, h);
873 else
874 o->engine_data = ENFN->image_new_from_copied_data
875 (ENC, w, h, NULL, o->cur->has_alpha, o->cur->cspace);
876
877 if (o->engine_data)
878 {
879 if (ENFN->image_scale_hint_set)
880 ENFN->image_scale_hint_set(ENC, o->engine_data, o->scale_hint);
881 if (ENFN->image_content_hint_set)
882 ENFN->image_content_hint_set(ENC, o->engine_data, o->content_hint);
883 if (ENFN->image_stride_get)
884 ENFN->image_stride_get(ENC, o->engine_data, &stride);
885 else
886 stride = w * 4;
887 }
888 else
889 stride = w * 4;
890 EINA_COW_IMAGE_STATE_WRITE_BEGIN(o, cur_write)
891 {
892 cur_write->image.stride = stride;
893
894 /* FIXME - in engine call above
895 if (o->engine_data)
896 o->engine_data = ENFN->image_alpha_set(ENC, o->engine_data, o->cur->has_alpha);
897 */
898 EINA_COW_WRITE_BEGIN(evas_object_image_state_cow, o->prev, Evas_Object_Image_State, prev_write)
899 EVAS_OBJECT_IMAGE_FREE_FILE_AND_KEY(cur_write, prev_write);
900 EINA_COW_WRITE_END(evas_object_image_state_cow, o->prev, prev_write);
901 }
902 EINA_COW_IMAGE_STATE_WRITE_END(o, cur_write);
903
904 o->written = EINA_TRUE;
905 o->changed = EINA_TRUE;
906 evas_object_inform_call_image_resize(eo_obj);
907 evas_object_change(eo_obj, obj);
908 }
909
910 /* Evas_Object equivalent: pixels_set(null, w, h, cspace) to (re)allocate an image */
911 EAPI void
evas_object_image_colorspace_set(Evas_Object * eo_obj,Evas_Colorspace cspace)912 evas_object_image_colorspace_set(Evas_Object *eo_obj, Evas_Colorspace cspace)
913 {
914 EVAS_IMAGE_API(eo_obj);
915
916 Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
917 Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
918
919 evas_object_async_block(obj);
920 _evas_image_cleanup(eo_obj, obj, o);
921
922 EINA_COW_IMAGE_STATE_WRITE_BEGIN(o, state_write)
923 state_write->cspace = cspace;
924 EINA_COW_IMAGE_STATE_WRITE_END(o, state_write);
925
926 if (o->engine_data)
927 ENFN->image_colorspace_set(ENC, o->engine_data, cspace);
928 }
929
930 /* old video surfaces */
931
932 EAPI void
evas_object_image_video_surface_set(Evas_Object * eo_obj,Evas_Video_Surface * surf)933 evas_object_image_video_surface_set(Evas_Object *eo_obj, Evas_Video_Surface *surf)
934 {
935 EVAS_IMAGE_LEGACY_API(eo_obj);
936
937 Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
938 Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
939 evas_object_async_block(obj);
940
941 _evas_image_cleanup(eo_obj, obj, o);
942 if (o->video_surface)
943 {
944 o->video_surface = EINA_FALSE;
945 obj->layer->evas->video_objects = eina_list_remove(obj->layer->evas->video_objects, eo_obj);
946 }
947
948 if (surf)
949 {
950 if (surf->version != EVAS_VIDEO_SURFACE_VERSION) return;
951
952 if (!surf->update_pixels ||
953 !surf->move ||
954 !surf->resize ||
955 !surf->hide ||
956 !surf->show)
957 return;
958
959 o->created = EINA_TRUE;
960 o->video_surface = EINA_TRUE;
961
962 EINA_COW_PIXEL_WRITE_BEGIN(o, pixi_write)
963 pixi_write->video = *surf;
964 EINA_COW_PIXEL_WRITE_END(o, pixi_write)
965
966 obj->layer->evas->video_objects = eina_list_append(obj->layer->evas->video_objects, eo_obj);
967 }
968 else
969 {
970 if (!o->video_surface &&
971 !o->pixels->video.update_pixels &&
972 !o->pixels->video.move &&
973 !o->pixels->video.resize &&
974 !o->pixels->video.hide &&
975 !o->pixels->video.show &&
976 !o->pixels->video.data)
977 return;
978
979 o->video_surface = EINA_FALSE;
980 EINA_COW_PIXEL_WRITE_BEGIN(o, pixi_write)
981 {
982 pixi_write->video.update_pixels = NULL;
983 pixi_write->video.move = NULL;
984 pixi_write->video.resize = NULL;
985 pixi_write->video.hide = NULL;
986 pixi_write->video.show = NULL;
987 pixi_write->video.data = NULL;
988 }
989 EINA_COW_PIXEL_WRITE_END(o, pixi_write)
990 }
991 }
992
993 EAPI const Evas_Video_Surface*
evas_object_image_video_surface_get(const Evas_Object * eo_obj)994 evas_object_image_video_surface_get(const Evas_Object *eo_obj)
995 {
996 EVAS_IMAGE_LEGACY_API(eo_obj, NULL);
997
998 Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
999 return (!o->video_surface ? NULL : &o->pixels->video);
1000 }
1001
1002 EAPI void
evas_object_image_video_surface_caps_set(Evas_Object * eo_obj,unsigned int caps)1003 evas_object_image_video_surface_caps_set(Evas_Object *eo_obj, unsigned int caps)
1004 {
1005 EVAS_IMAGE_LEGACY_API(eo_obj);
1006
1007 Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
1008 Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
1009 evas_object_async_block(obj);
1010
1011 _evas_image_cleanup(eo_obj, obj, o);
1012
1013 if (caps == o->pixels->video_caps)
1014 return;
1015
1016 EINA_COW_PIXEL_WRITE_BEGIN(o, pixi_write)
1017 pixi_write->video_caps = caps;
1018 EINA_COW_PIXEL_WRITE_END(o, pixi_write)
1019 }
1020
1021 EAPI unsigned int
evas_object_image_video_surface_caps_get(const Evas_Object * eo_obj)1022 evas_object_image_video_surface_caps_get(const Evas_Object *eo_obj)
1023 {
1024 EVAS_IMAGE_LEGACY_API(eo_obj, 0);
1025
1026 Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
1027
1028 /* The generic hardware plane code calls this function on
1029 * non-video surfaces, return stacking check for those to
1030 * allow them to use common video surface code */
1031 return (!o->video_surface ? EVAS_VIDEO_SURFACE_STACKING_CHECK : o->pixels->video_caps);
1032 }
1033
1034 /* deprecated */
1035 EAPI void
evas_object_image_fill_spread_set(Evas_Object * obj EINA_UNUSED,Evas_Fill_Spread spread)1036 evas_object_image_fill_spread_set(Evas_Object *obj EINA_UNUSED, Evas_Fill_Spread spread)
1037 {
1038 /* not implemented! */
1039 if (spread != EFL_GFX_FILL_REPEAT)
1040 WRN("Fill spread support is not implemented!");
1041 }
1042
1043 /* deprecated */
1044 EAPI Evas_Fill_Spread
evas_object_image_fill_spread_get(const Evas_Object * obj EINA_UNUSED)1045 evas_object_image_fill_spread_get(const Evas_Object *obj EINA_UNUSED)
1046 {
1047 return EFL_GFX_FILL_REPEAT;
1048 }
1049
1050 /* deprecated */
1051 EAPI void
evas_object_image_source_visible_set(Evas_Object * eo,Eina_Bool visible)1052 evas_object_image_source_visible_set(Evas_Object *eo, Eina_Bool visible)
1053 {
1054 /* FIXME: I'd love to remove this feature and replace by no_render.
1055 * But they are not 100% equivalent: if all proxies are removed, then the
1056 * source becomes visible again. This has some advantages for some apps but
1057 * it's complete hell to handle in evas render side.
1058 * -- jpeg, 2016/03/07
1059 */
1060
1061 EVAS_IMAGE_LEGACY_API(eo);
1062
1063 Evas_Object_Protected_Data *obj = efl_data_scope_get(eo, EFL_CANVAS_OBJECT_CLASS);
1064 Evas_Object_Protected_Data *src_obj;
1065 Evas_Image_Data *o;
1066
1067 o = efl_data_scope_get(eo, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
1068 if (!o->cur->source) return;
1069
1070 visible = !!visible;
1071 src_obj = efl_data_scope_get(o->cur->source, EFL_CANVAS_OBJECT_CLASS);
1072 if (src_obj->proxy->src_invisible == !visible) return;
1073
1074 evas_object_async_block(obj);
1075 EINA_COW_WRITE_BEGIN(evas_object_proxy_cow, src_obj->proxy, Evas_Object_Proxy_Data, proxy_write)
1076 proxy_write->src_invisible = !visible;
1077 EINA_COW_WRITE_END(evas_object_proxy_cow, src_obj->proxy, proxy_write);
1078
1079 src_obj->changed_src_visible = EINA_TRUE;
1080 evas_object_smart_member_cache_invalidate(o->cur->source, EINA_FALSE,
1081 EINA_FALSE, EINA_TRUE);
1082 evas_object_change(o->cur->source, src_obj);
1083 if ((!visible) || (!src_obj->proxy->src_events)) return;
1084 //FIXME: Feed mouse events here.
1085 }
1086
1087 /* deprecated */
1088 EAPI Eina_Bool
evas_object_image_source_visible_get(const Evas_Object * eo)1089 evas_object_image_source_visible_get(const Evas_Object *eo)
1090 {
1091 /* FIXME: see evas_object_image_source_visible_set */
1092
1093 EVAS_IMAGE_LEGACY_API(eo, EINA_FALSE);
1094
1095 Evas_Object_Protected_Data *src_obj;
1096 Evas_Image_Data *o;
1097 Eina_Bool visible;
1098
1099 o = efl_data_scope_get(eo, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
1100 if (!o->cur->source) visible = EINA_FALSE;
1101 src_obj = efl_data_scope_get(o->cur->source, EFL_CANVAS_OBJECT_CLASS);
1102 if (src_obj) visible = !src_obj->proxy->src_invisible;
1103 else visible = EINA_FALSE;
1104
1105 return visible;
1106 }
1107
1108 /* deprecated */
1109 EAPI void*
evas_object_image_data_convert(Evas_Object * eo_obj,Evas_Colorspace to_cspace)1110 evas_object_image_data_convert(Evas_Object *eo_obj, Evas_Colorspace to_cspace)
1111 {
1112 EVAS_IMAGE_LEGACY_API(eo_obj, NULL);
1113
1114 Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
1115 Evas_Image_Data *o;
1116 void *engine_data;
1117 DATA32 *data;
1118 void* result = NULL;
1119 int load_error;
1120
1121 static int warned = 0;
1122 if (!warned)
1123 {
1124 ERR("%s is deprecated and shouldn't be called", __func__);
1125 warned = 1;
1126 }
1127
1128 evas_object_async_block(obj);
1129 o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
1130 if (!o->engine_data) return NULL;
1131 if (o->video_surface)
1132 o->pixels->video.update_pixels(o->pixels->video.data, eo_obj, &o->pixels->video);
1133 if (o->cur->cspace == to_cspace) return NULL;
1134 if ((o->preload & EVAS_IMAGE_PRELOADING) && (o->engine_data))
1135 {
1136 o->preload = EVAS_IMAGE_PRELOAD_NONE;
1137 ENFN->image_data_preload_cancel(ENC, o->engine_data, eo_obj, EINA_TRUE);
1138 }
1139 data = NULL;
1140 engine_data = ENFN->image_data_get(ENC, o->engine_data, 0, &data, &load_error, NULL);
1141 o->load_error = _evas_load_error_to_efl_gfx_image_load_error(load_error);
1142 result = _evas_image_data_convert_internal(o, data, to_cspace);
1143 if (engine_data)
1144 o->engine_data = ENFN->image_data_put(ENC, engine_data, data);
1145
1146 return result;
1147 }
1148
1149 /* deprecated */
1150 EAPI void
evas_object_image_reload(Evas_Object * eo_obj)1151 evas_object_image_reload(Evas_Object *eo_obj)
1152 {
1153 EVAS_IMAGE_LEGACY_API(eo_obj);
1154
1155 Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
1156 Evas_Image_Data *o;
1157
1158 evas_object_async_block(obj);
1159 o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
1160 if ((!o->cur->f) || (o->pixels_checked_out > 0)) return;
1161 if ((o->preload & EVAS_IMAGE_PRELOADING) && (o->engine_data))
1162 {
1163 o->preload = EVAS_IMAGE_PRELOAD_NONE;
1164 ENFN->image_data_preload_cancel(ENC, o->engine_data, eo_obj, EINA_TRUE);
1165 }
1166 if (o->engine_data)
1167 o->engine_data = ENFN->image_dirty_region(ENC, o->engine_data, 0, 0, o->cur->image.w, o->cur->image.h);
1168
1169 eina_file_refresh(o->cur->f);
1170 o->written = EINA_FALSE;
1171
1172 _evas_image_unload(eo_obj, obj, 1);
1173 evas_object_inform_call_image_unloaded(eo_obj);
1174 _evas_image_load(eo_obj, obj, o);
1175
1176 EINA_COW_WRITE_BEGIN(evas_object_image_state_cow, o->prev, Evas_Object_Image_State, prev_write)
1177 {
1178 prev_write->f = NULL;
1179 prev_write->key = NULL;
1180 }
1181 EINA_COW_WRITE_END(evas_object_image_state_cow, o->prev, prev_write);
1182
1183 o->changed = EINA_TRUE;
1184 evas_object_change(eo_obj, obj);
1185 }
1186
1187 /* deprecated */
1188 EAPI Eina_Bool
evas_object_image_pixels_import(Evas_Object * eo_obj,Evas_Pixel_Import_Source * pixels)1189 evas_object_image_pixels_import(Evas_Object *eo_obj, Evas_Pixel_Import_Source *pixels)
1190 {
1191 EVAS_IMAGE_LEGACY_API(eo_obj, EINA_FALSE);
1192
1193 Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
1194 Evas_Image_Data *o;
1195 int load_error;
1196
1197 static int warned = 0;
1198 if (!warned)
1199 {
1200 ERR("%s is deprecated and shouldn't be called", __func__);
1201 warned = 1;
1202 }
1203
1204 evas_object_async_block(obj);
1205 o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
1206 _evas_image_cleanup(eo_obj, obj, o);
1207 if ((pixels->w != o->cur->image.w) || (pixels->h != o->cur->image.h)) return EINA_FALSE;
1208
1209 switch (pixels->format)
1210 {
1211 #if 0
1212 case EVAS_PIXEL_FORMAT_ARGB32:
1213 {
1214 if (o->engine_data)
1215 {
1216 DATA32 *image_pixels = NULL;
1217
1218 o->engine_data =
1219 ENFN->image_data_get(ENC,
1220 o->engine_data,
1221 1,
1222 &image_pixels,
1223 &load_error);
1224 o->load_error = _evas_load_error_to_efl_gfx_image_load_error(load_error);
1225 /* FIXME: need to actualyl support this */
1226 /* memcpy(image_pixels, pixels->rows, o->cur->image.w * o->cur->image.h * 4);*/
1227 if (o->engine_data)
1228 o->engine_data =
1229 ENFN->image_data_put(ENC, o->engine_data, image_pixels);
1230 if (o->engine_data)
1231 o->engine_data =
1232 ENFN->image_alpha_set(ENC, o->engine_data, o->cur->has_alpha);
1233 o->changed = EINA_TRUE;
1234 evas_object_change(eo_obj, obj);
1235 }
1236 }
1237 break;
1238 #endif
1239 case EVAS_PIXEL_FORMAT_YUV420P_601:
1240 {
1241 if (o->engine_data)
1242 {
1243 DATA32 *image_pixels = NULL;
1244
1245 o->engine_data = ENFN->image_data_get(ENC, o->engine_data, 1, &image_pixels, &load_error, NULL);
1246 o->load_error = _evas_load_error_to_efl_gfx_image_load_error(load_error);
1247 if (image_pixels)
1248 evas_common_convert_yuv_422p_601_rgba((DATA8 **) pixels->rows, (DATA8 *) image_pixels, o->cur->image.w, o->cur->image.h);
1249 if (o->engine_data)
1250 o->engine_data = ENFN->image_data_put(ENC, o->engine_data, image_pixels);
1251 if (o->engine_data)
1252 o->engine_data = ENFN->image_alpha_set(ENC, o->engine_data, o->cur->has_alpha);
1253 o->changed = EINA_TRUE;
1254 evas_object_change(eo_obj, obj);
1255 }
1256 }
1257 break;
1258 default:
1259 return EINA_FALSE;
1260 break;
1261 }
1262 return EINA_TRUE;
1263 }
1264
1265 EAPI Eina_Bool
evas_image_max_size_get(Eo * eo_e,int * w,int * h)1266 evas_image_max_size_get(Eo *eo_e, int *w, int *h)
1267 {
1268 Eina_Size2D size;
1269 Eina_Bool ret;
1270
1271 ret = efl_canvas_scene_image_max_size_get(eo_e, &size);
1272 if (ret)
1273 {
1274 if (w) *w = size.w;
1275 if (h) *h = size.h;
1276 }
1277 return ret;
1278 }
1279
1280 /* deprecated */
1281 EAPI void
evas_object_image_alpha_mask_set(Evas_Object * eo_obj EINA_UNUSED,Eina_Bool ismask EINA_UNUSED)1282 evas_object_image_alpha_mask_set(Evas_Object *eo_obj EINA_UNUSED, Eina_Bool ismask EINA_UNUSED)
1283 {
1284 WRN("This function is not implemented, has never been and never will be.");
1285 EVAS_IMAGE_LEGACY_API(eo_obj);
1286 }
1287
1288 EOLIAN static Eina_Bool
_evas_image_efl_file_loaded_get(const Eo * eo_obj,void * _pd EINA_UNUSED)1289 _evas_image_efl_file_loaded_get(const Eo *eo_obj, void *_pd EINA_UNUSED)
1290 {
1291 Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
1292 if (!o->skip_head)
1293 return efl_file_loaded_get(efl_super(eo_obj, EVAS_IMAGE_CLASS));
1294 return !!o->cur->f;
1295 }
1296
1297 EOLIAN static const Eina_File *
_evas_image_efl_file_mmap_get(const Eo * eo_obj,void * _pd EINA_UNUSED)1298 _evas_image_efl_file_mmap_get(const Eo *eo_obj, void *_pd EINA_UNUSED)
1299 {
1300 Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
1301 if (!o->skip_head)
1302 return efl_file_mmap_get(efl_super(eo_obj, EVAS_IMAGE_CLASS));
1303 return o->cur->f;
1304 }
1305
1306 EOLIAN static Eina_Error
_evas_image_efl_file_load(Eo * obj,void * pd EINA_UNUSED)1307 _evas_image_efl_file_load(Eo *obj, void *pd EINA_UNUSED)
1308 {
1309 EVAS_IMAGE_API(obj, EINA_FALSE);
1310 if (efl_file_loaded_get(obj)) return 0;
1311 Evas_Image_Data *o = efl_data_scope_get(obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
1312 Eina_Error err = 0;
1313
1314 if (!o->skip_head)
1315 err = efl_file_load(efl_super(obj, EVAS_IMAGE_CLASS));
1316 if (err)
1317 {
1318 if (err == ENOENT)
1319 _efl_canvas_image_load_error_set(obj, EFL_GFX_IMAGE_LOAD_ERROR_DOES_NOT_EXIST);
1320 else if (err == ENOMEM)
1321 _efl_canvas_image_load_error_set(obj, EFL_GFX_IMAGE_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED);
1322 else if ((err == EPERM) || (err == EACCES))
1323 _efl_canvas_image_load_error_set(obj, EFL_GFX_IMAGE_LOAD_ERROR_PERMISSION_DENIED);
1324 else
1325 _efl_canvas_image_load_error_set(obj, EFL_GFX_IMAGE_LOAD_ERROR_GENERIC);
1326 return err;
1327 }
1328 if (_evas_image_file_load(obj, o))
1329 return 0;
1330 return EFL_GFX_IMAGE_LOAD_ERROR_DOES_NOT_EXIST;
1331 }
1332
1333 EOLIAN static void
_evas_image_efl_file_unload(Eo * obj,void * pd EINA_UNUSED)1334 _evas_image_efl_file_unload(Eo *obj, void *pd EINA_UNUSED)
1335 {
1336 EVAS_IMAGE_API(obj);
1337 efl_file_unload(efl_super(obj, EVAS_IMAGE_CLASS));
1338 _evas_image_file_unload(obj);
1339 }
1340
1341 #include "canvas/evas_image_eo.c"
1342