Elementary thumb: Fixed warning.
[framework/uifw/elementary.git] / src / lib / elm_thumb.c
1 #include <Elementary.h>
2 #include "elm_priv.h"
3
4 /**
5  * @defgroup Thumb Thumb
6  *
7  * A thumb object is used for displaying the thumbnail of an image or video.
8  * You must have compiled Elementary with Ethumb_Client support and the DBus
9  * service must be present and auto-activated in order to have thumbnails to
10  * be generated.
11  *
12  * Signals that you can add callbacks for are:
13  *
14  * "clicked" - This is called when a user has clicked the thumb without dragging
15  *             around.
16  * "clicked,double" - This is called when a user has double-clicked the thumb.
17  * "press" - This is called when a user has pressed down the thumb.
18  * "generate,start" - The thumbnail generation started.
19  * "generate,stop" - The generation process stopped.
20  * "generate,error" - The generation failed.
21  * "load,error" - The thumbnail image loading failed.
22  */
23
24 typedef struct _Widget_Data Widget_Data;
25
26 struct _Widget_Data
27 {
28    Evas_Object *self;
29    Evas_Object *frame;
30    Evas_Object *view;
31    const char *file;
32    const char *key;
33    struct
34      {
35         int id;
36         const char *file;
37         const char *key;
38         Ethumb_Exists *exists;
39      } thumb;
40    Ecore_Event_Handler *eeh;
41    Elm_Thumb_Animation_Setting anim_setting;
42    Eina_Bool on_hold : 1;
43    Eina_Bool is_video : 1;
44    Eina_Bool was_video : 1;
45    Eina_Bool edit : 1;
46 };
47
48 static const char *widtype = NULL;
49
50 static const char SIG_CLICKED[] = "clicked";
51 static const char SIG_CLICKED_DOUBLE[] = "clicked,double";
52 static const char SIG_GENERATE_ERROR[] = "generate,error";
53 static const char SIG_GENERATE_START[] = "generate,start";
54 static const char SIG_GENERATE_STOP[] = "generate,stop";
55 static const char SIG_LOAD_ERROR[] = "load,error";
56 static const char SIG_PRESS[] = "press";
57
58 static const Evas_Smart_Cb_Description _signals[] =
59 {
60      {SIG_CLICKED, ""},
61      {SIG_CLICKED_DOUBLE, ""},
62      {SIG_GENERATE_ERROR, ""},
63      {SIG_GENERATE_START, ""},
64      {SIG_GENERATE_STOP, ""},
65      {SIG_LOAD_ERROR, ""},
66      {SIG_PRESS, ""},
67      {NULL, NULL}
68 };
69
70 #define EDJE_SIGNAL_GENERATE_START "elm,thumb,generate,start"
71 #define EDJE_SIGNAL_GENERATE_STOP "elm,thumb,generate,stop"
72 #define EDJE_SIGNAL_GENERATE_ERROR "elm,thumb,generate,error"
73 #define EDJE_SIGNAL_LOAD_ERROR "elm,thumb,load,error"
74 #define EDJE_SIGNAL_PULSE_START "elm,state,pulse,start"
75 #define EDJE_SIGNAL_PULSE_STOP "elm,state,pulse,stop"
76
77 struct _Ethumb_Client *_elm_ethumb_client = NULL;
78 Eina_Bool _elm_ethumb_connected = EINA_FALSE;
79
80 EAPI int ELM_ECORE_EVENT_ETHUMB_CONNECT = 0;
81
82 static void
83 _del_hook(Evas_Object *obj)
84 {
85    Widget_Data *wd = elm_widget_data_get(obj);
86
87 #ifdef HAVE_ELEMENTARY_ETHUMB
88    if (wd->thumb.id >= 0)
89      ethumb_client_generate_cancel(_elm_ethumb_client, wd->thumb.id,
90                                    NULL, NULL, NULL);
91    if (wd->thumb.exists)
92      {
93         ethumb_client_thumb_exists_cancel(wd->thumb.exists);
94         wd->thumb.exists = NULL;
95      }
96 #endif
97
98    eina_stringshare_del(wd->file);
99    eina_stringshare_del(wd->key);
100    if (wd->eeh) ecore_event_handler_del(wd->eeh);
101    free(wd);
102 }
103
104 static void
105 _theme_hook(Evas_Object *obj)
106 {
107    Widget_Data *wd = elm_widget_data_get(obj);
108    _elm_theme_object_set(obj, wd->frame, "thumb", "base",
109                          elm_widget_style_get(obj));
110 }
111
112 #ifdef HAVE_ELEMENTARY_ETHUMB
113 static void
114 _mouse_down_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info)
115 {
116    Widget_Data *wd = data;
117    Evas_Event_Mouse_Down *ev = event_info;
118
119    if (ev->button != 1)
120      return;
121    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD)
122      wd->on_hold = EINA_TRUE;
123    else
124      wd->on_hold = EINA_FALSE;
125    if (ev->flags & EVAS_BUTTON_DOUBLE_CLICK)
126      evas_object_smart_callback_call(wd->self, SIG_CLICKED_DOUBLE, NULL);
127    else
128      evas_object_smart_callback_call(wd->self, SIG_PRESS, NULL);
129 }
130
131 static void
132 _mouse_up_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info)
133 {
134    Widget_Data *wd = data;
135    Evas_Event_Mouse_Up *ev = event_info;
136
137    if (ev->button != 1)
138      return;
139    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD)
140      wd->on_hold = EINA_TRUE;
141    else
142      wd->on_hold = EINA_FALSE;
143    if (!wd->on_hold)
144      evas_object_smart_callback_call(wd->self, SIG_CLICKED, NULL);
145    wd->on_hold = EINA_FALSE;
146 }
147
148 static void
149 _finished_thumb(Widget_Data *wd, const char *thumb_path, const char *thumb_key)
150 {
151    Eina_Bool new_view = EINA_FALSE;
152    int r;
153    Evas_Coord mw, mh;
154    Evas *evas;
155
156    evas = evas_object_evas_get(wd->self);
157    if ((wd->view) && (wd->is_video ^ wd->was_video))
158      {
159         evas_object_del(wd->view);
160         wd->view = NULL;
161      }
162    wd->was_video = wd->is_video;
163
164    if ((wd->is_video) &&
165        (ethumb_client_format_get(_elm_ethumb_client) == ETHUMB_THUMB_EET))
166      {
167         if (!wd->view)
168           {
169              wd->view = edje_object_add(evas);
170              if (!wd->view)
171                {
172                   ERR("could not create edje object");
173                   goto err;
174                }
175              new_view = EINA_TRUE;
176           }
177
178         if (!edje_object_file_set(wd->view, thumb_path, "movie/thumb"))
179           {
180              ERR("could not set file=%s key=%s for %s", thumb_path, thumb_key,
181                  wd->file);
182              goto view_err;
183           }
184      }
185    else
186      {
187         if (!wd->view)
188           {
189              wd->view = evas_object_image_filled_add(evas);
190              if (!wd->view)
191                {
192                   ERR("could not create image object");
193                   goto err;
194                }
195              new_view = EINA_TRUE;
196           }
197
198         evas_object_image_file_set(wd->view, thumb_path, thumb_key);
199         r = evas_object_image_load_error_get(wd->view);
200         if (r != EVAS_LOAD_ERROR_NONE)
201           {
202              ERR("%s: %s", thumb_path, evas_load_error_str(r));
203              goto view_err;
204           }
205      }
206
207    if (new_view) elm_widget_sub_object_add(wd->self, wd->view);
208    edje_object_part_swallow(wd->frame, "elm.swallow.content", wd->view);
209    edje_object_size_min_get(wd->frame, &mw, &mh);
210    edje_object_size_min_restricted_calc(wd->frame, &mw, &mh, mw, mh);
211    evas_object_size_hint_min_set(wd->self, mw, mh);
212    eina_stringshare_replace(&(wd->thumb.file), thumb_path);
213    eina_stringshare_replace(&(wd->thumb.key), thumb_key);
214    edje_object_signal_emit(wd->frame, EDJE_SIGNAL_GENERATE_STOP, "elm");
215    evas_object_smart_callback_call(wd->self, SIG_GENERATE_STOP, NULL);
216    return;
217
218 view_err:
219    evas_object_del(wd->view);
220    wd->view = NULL;
221 err:
222    edje_object_signal_emit(wd->frame, EDJE_SIGNAL_LOAD_ERROR, "elm");
223    evas_object_smart_callback_call(wd->self, SIG_LOAD_ERROR, NULL);
224 }
225
226 static void
227 _finished_thumb_cb(void *data, Ethumb_Client *c __UNUSED__, int id, const char *file, const char *key, const char *thumb_path, const char *thumb_key, Eina_Bool success)
228 {
229    Widget_Data *wd = data;
230
231    EINA_SAFETY_ON_FALSE_RETURN(wd->thumb.id == id);
232    wd->thumb.id = -1;
233
234    edje_object_signal_emit(wd->frame, EDJE_SIGNAL_PULSE_STOP, "elm");
235
236    if (success)
237      {
238         _finished_thumb(wd, thumb_path, thumb_key);
239         return;
240      }
241
242    ERR("could not generate thumbnail for %s (key: %s)", file, key ? key : "");
243    edje_object_signal_emit(wd->frame, EDJE_SIGNAL_GENERATE_ERROR, "elm");
244    evas_object_smart_callback_call(wd->self, SIG_GENERATE_ERROR, NULL);
245 }
246
247 static void
248 _thumb_exists(Ethumb_Client *client __UNUSED__, Ethumb_Exists *thread,
249               Eina_Bool exists, void *data)
250 {
251    Widget_Data *wd = data;
252
253    if (ethumb_client_thumb_exists_check(thread))
254      return ;
255
256    if (exists)
257      {
258         const char *thumb_path, *thumb_key;
259
260         wd->thumb.id = -1;
261         ethumb_client_thumb_path_get(_elm_ethumb_client, &thumb_path,
262                                      &thumb_key);
263         _finished_thumb(wd, thumb_path, thumb_key);
264         return;
265      }
266    else if ((wd->thumb.id = ethumb_client_generate
267              (_elm_ethumb_client, _finished_thumb_cb, wd, NULL)) != -1)
268      {
269         edje_object_signal_emit(wd->frame, EDJE_SIGNAL_PULSE_START, "elm");
270         edje_object_signal_emit(wd->frame, EDJE_SIGNAL_GENERATE_START, "elm");
271         evas_object_smart_callback_call(wd->self, SIG_GENERATE_START, NULL);
272      }
273    else
274      {
275         wd->thumb.id = -1;
276         edje_object_signal_emit(wd->frame, EDJE_SIGNAL_GENERATE_ERROR, "elm");
277         evas_object_smart_callback_call(wd->self, SIG_GENERATE_ERROR, NULL);
278      }
279
280 }
281
282 static void
283 _thumb_apply(Widget_Data *wd)
284 {
285    if (wd->thumb.id > 0)
286      {
287         ethumb_client_generate_cancel
288            (_elm_ethumb_client, wd->thumb.id, NULL, NULL, NULL);
289         wd->thumb.id = -1;
290      }
291
292    if (wd->thumb.exists)
293      {
294         ethumb_client_thumb_exists_cancel(wd->thumb.exists);
295         wd->thumb.exists = NULL;
296      }
297
298    if (!wd->file) return;
299
300    ethumb_client_file_set(_elm_ethumb_client, wd->file, wd->key);
301    ethumb_client_thumb_exists(_elm_ethumb_client, _thumb_exists, wd);
302 }
303
304 static Eina_Bool
305 _thumb_apply_cb(void *data, int type __UNUSED__, void *ev __UNUSED__)
306 {
307    _thumb_apply(data);
308    return ECORE_CALLBACK_RENEW;
309 }
310
311 static void
312 _thumb_show(Widget_Data *wd)
313 {
314    evas_object_show(wd->frame);
315
316    if (elm_thumb_ethumb_client_connected())
317      {
318         _thumb_apply(wd);
319         return;
320      }
321
322    if (!wd->eeh)
323      wd->eeh = ecore_event_handler_add(ELM_ECORE_EVENT_ETHUMB_CONNECT,
324                                        _thumb_apply_cb, wd);
325 }
326
327 static void
328 _thumb_show_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
329 {
330    _thumb_show(data);
331 }
332
333 static void
334 _thumb_hide_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
335 {
336    Widget_Data *wd = data;
337
338    evas_object_hide(wd->frame);
339
340    if (wd->thumb.id >= 0)
341      {
342         ethumb_client_generate_cancel
343            (_elm_ethumb_client, wd->thumb.id, NULL, NULL, NULL);
344         wd->thumb.id = -1;
345
346         edje_object_signal_emit(wd->frame, EDJE_SIGNAL_GENERATE_STOP, "elm");
347         evas_object_smart_callback_call(wd->self, SIG_GENERATE_STOP, NULL);
348      }
349
350    if (wd->thumb.exists)
351      {
352         ethumb_client_thumb_exists_cancel(wd->thumb.exists);
353         wd->thumb.exists = NULL;
354      }
355
356    if (wd->eeh)
357      {
358         ecore_event_handler_del(wd->eeh);
359         wd->eeh = NULL;
360      }
361 }
362
363 #endif
364
365 #ifdef ELM_ETHUMB
366 static int _elm_need_ethumb = 0;
367
368 static void _on_die_cb(void *, Ethumb_Client *);
369
370 static void
371 _connect_cb(void *data __UNUSED__, Ethumb_Client *c, Eina_Bool success)
372 {
373    if (success)
374      {
375         ethumb_client_on_server_die_callback_set(c, _on_die_cb, NULL, NULL);
376         _elm_ethumb_connected = EINA_TRUE;
377         ecore_event_add(ELM_ECORE_EVENT_ETHUMB_CONNECT, NULL, NULL, NULL);
378      }
379    else
380      _elm_ethumb_client = NULL;
381 }
382
383 static void
384 _on_die_cb(void *data __UNUSED__, Ethumb_Client *c __UNUSED__)
385 {
386    ethumb_client_disconnect(_elm_ethumb_client);
387    _elm_ethumb_client = NULL;
388    _elm_ethumb_connected = EINA_FALSE;
389    _elm_ethumb_client = ethumb_client_connect(_connect_cb, NULL, NULL);
390 }
391 #endif
392
393 void
394 _elm_unneed_ethumb(void)
395 {
396 #ifdef ELM_ETHUMB
397    if (--_elm_need_ethumb) return;
398
399    ethumb_client_disconnect(_elm_ethumb_client);
400    _elm_ethumb_client = NULL;
401    ethumb_client_shutdown();
402    ELM_ECORE_EVENT_ETHUMB_CONNECT = 0;
403 #endif
404 }
405
406 static Eina_Bool
407 _elm_thumb_dropcb(void *data __UNUSED__, Evas_Object *o, Elm_Selection_Data *drop)
408 {
409    if ((!o) || (!drop) || (!drop->data)) return EINA_FALSE;
410    elm_thumb_file_set(o, drop->data, NULL);
411    return EINA_TRUE;
412 }
413
414 /**
415  * This must be called before any other function that handle with
416  * elm_thumb objects or ethumb_client instances.
417  *
418  * @ingroup Thumb
419  */
420 EAPI Eina_Bool
421 elm_need_ethumb(void)
422 {
423 #ifdef ELM_ETHUMB
424    if (_elm_need_ethumb++) return EINA_TRUE;
425    ELM_ECORE_EVENT_ETHUMB_CONNECT = ecore_event_type_new();
426    ethumb_client_init();
427    _elm_ethumb_client = ethumb_client_connect(_connect_cb, NULL, NULL);
428    return EINA_TRUE;
429 #else
430    return EINA_FALSE;
431 #endif
432 }
433
434 /**
435  * Add a new thumb object to the parent.
436  *
437  * @param parent The parent object.
438  * @return The new object or NULL if it cannot be created.
439  *
440  * @see elm_thumb_file_set()
441  * @see elm_thumb_ethumb_client_get()
442  *
443  * @ingroup Thumb
444  */
445 EAPI Evas_Object *
446 elm_thumb_add(Evas_Object *parent)
447 {
448    Evas *e;
449    Widget_Data *wd;
450    Evas_Object *obj;
451    Evas_Coord minw, minh;
452
453    ELM_WIDGET_STANDARD_SETUP(wd, Widget_Data, parent, e, obj, NULL);
454
455    ELM_SET_WIDTYPE(widtype, "thumb");
456    elm_widget_type_set(obj, "thumb");
457    elm_widget_sub_object_add(parent, obj);
458    elm_widget_data_set(obj, wd);
459    elm_widget_del_hook_set(obj, _del_hook);
460    elm_widget_theme_hook_set(obj, _theme_hook);
461    elm_widget_can_focus_set(obj, EINA_FALSE);
462
463    wd->frame = edje_object_add(e);
464    _elm_theme_object_set(obj, wd->frame, "thumb", "base", "default");
465    elm_widget_resize_object_set(obj, wd->frame);
466
467    edje_object_size_min_calc(obj, &minw, &minh);
468    evas_object_size_hint_min_set(obj, minw, minh);
469
470    wd->self = obj;
471    wd->view = NULL;
472    wd->file = NULL;
473    wd->key = NULL;
474    wd->eeh = NULL;
475    wd->thumb.id = -1;
476    wd->thumb.exists = NULL;
477    wd->on_hold = EINA_FALSE;
478    wd->is_video = EINA_FALSE;
479    wd->was_video = EINA_FALSE;
480
481 #ifdef HAVE_ELEMENTARY_ETHUMB
482    evas_object_event_callback_add(obj, EVAS_CALLBACK_MOUSE_DOWN,
483                                   _mouse_down_cb, wd);
484    evas_object_event_callback_add(obj, EVAS_CALLBACK_MOUSE_UP,
485                                   _mouse_up_cb, wd);
486    evas_object_event_callback_add(obj, EVAS_CALLBACK_SHOW,
487                                   _thumb_show_cb, wd);
488    evas_object_event_callback_add(obj, EVAS_CALLBACK_HIDE,
489                                   _thumb_hide_cb, wd);
490 #endif
491
492    // TODO: convert Elementary to subclassing of Evas_Smart_Class
493    // TODO: and save some bytes, making descriptions per-class and not instance!
494    evas_object_smart_callbacks_descriptions_set(obj, _signals);
495    return obj;
496 }
497
498 /**
499  * Reload thumbnail if it was generated before.
500  *
501  * This is useful if the ethumb client configuration changed, like its
502  * size, aspect or any other property one set in the handle returned
503  * by elm_thumb_ethumb_client_get().
504  *
505  * @param obj The thumb object to reload
506  *
507  * @see elm_thumb_file_set()
508  *
509  * @ingroup Thumb
510  */
511 EAPI void
512 elm_thumb_reload(Evas_Object *obj)
513 {
514    ELM_CHECK_WIDTYPE(obj, widtype);
515    Widget_Data *wd = elm_widget_data_get(obj);
516
517    eina_stringshare_replace(&(wd->thumb.file), NULL);
518    eina_stringshare_replace(&(wd->thumb.key), NULL);
519
520 #ifdef HAVE_ELEMENTARY_ETHUMB
521    if (evas_object_visible_get(obj))
522      _thumb_show(wd);
523 #endif
524 }
525
526 /**
527  * Set the file that will be used as thumbnail.
528  *
529  * The file can be an image or a video (in that case, acceptable extensions are:
530  * avi, mp4, ogv, mov, mpg and wmv). To start the video animation, use the
531  * function elm_thumb_animate().
532  *
533  * @param obj The thumb object.
534  * @param file The path to file that will be used as thumb.
535  * @param key The key used in case of an EET file.
536  *
537  * @see elm_thumb_file_get()
538  * @see elm_thumb_reload()
539  * @see elm_thumb_animate()
540  *
541  * @ingroup Thumb
542  */
543 EAPI void
544 elm_thumb_file_set(Evas_Object *obj, const char *file, const char *key)
545 {
546    ELM_CHECK_WIDTYPE(obj, widtype);
547    Eina_Bool file_replaced, key_replaced;
548    Widget_Data *wd = elm_widget_data_get(obj);
549
550    file_replaced = eina_stringshare_replace(&(wd->file), file);
551    key_replaced = eina_stringshare_replace(&(wd->key), key);
552
553    if (file_replaced)
554      {
555         int prefix_size;
556         const char **ext, *ptr;
557         static const char *extensions[] =
558           {
559              ".avi", ".mp4", ".ogv", ".mov", ".mpg", ".wmv", NULL
560           };
561
562         prefix_size = eina_stringshare_strlen(wd->file) - 4;
563         if (prefix_size >= 0)
564           {
565              ptr = wd->file + prefix_size;
566              wd->is_video = EINA_FALSE;
567              for (ext = extensions; *ext; ext++)
568                if (!strcasecmp(ptr, *ext))
569                  {
570                     wd->is_video = EINA_TRUE;
571                     break;
572                  }
573           }
574      }
575
576    eina_stringshare_replace(&(wd->thumb.file), NULL);
577    eina_stringshare_replace(&(wd->thumb.key), NULL);
578
579 #ifdef HAVE_ELEMENTARY_ETHUMB
580    if (((file_replaced) || (key_replaced)) && (evas_object_visible_get(obj)))
581      _thumb_show(wd);
582 #endif
583 }
584
585 /**
586  * Get the image or video path and key used to generate the thumbnail.
587  *
588  * @param obj The thumb object.
589  * @param file Pointer to filename.
590  * @param key Pointer to key.
591  *
592  * @see elm_thumb_file_set()
593  * @see elm_thumb_path_get()
594  * @see elm_thumb_animate()
595  *
596  * @ingroup Thumb
597  */
598 EAPI void
599 elm_thumb_file_get(const Evas_Object *obj, const char **file, const char **key)
600 {
601    ELM_CHECK_WIDTYPE(obj, widtype);
602    Widget_Data *wd = elm_widget_data_get(obj);
603
604    if (file)
605      *file = wd->file;
606    if (key)
607      *key = wd->key;
608 }
609
610 /**
611  * Get the path and key to the image or video generated by ethumb.
612  *
613  * One just need to make sure that the thumbnail was generated before getting
614  * its path; otherwise, the path will be NULL. One way to do that is by asking
615  * for the path when/after the "generate,stop" smart callback is called.
616  *
617  * @param obj The thumb object.
618  * @param file Pointer to thumb path.
619  * @param key Pointer to thumb key.
620  *
621  * @see elm_thumb_file_get()
622  *
623  * @ingroup Thumb
624  */
625 EAPI void
626 elm_thumb_path_get(const Evas_Object *obj, const char **file, const char **key)
627 {
628    ELM_CHECK_WIDTYPE(obj, widtype);
629    Widget_Data *wd = elm_widget_data_get(obj);
630
631    if (file)
632      *file = wd->thumb.file;
633    if (key)
634      *key = wd->thumb.key;
635 }
636
637 /**
638  * Set the animation state for the thumb object. If its content is an animated
639  * video, you may start/stop the animation or tell it to play continuously and
640  * looping.
641  *
642  * @param obj The thumb object.
643  * @param setting The animation setting.
644  *
645  * @see elm_thumb_file_set()
646  *
647  * @ingroup Thumb
648  */
649 EAPI void
650 elm_thumb_animate_set(Evas_Object *obj, Elm_Thumb_Animation_Setting setting)
651 {
652    ELM_CHECK_WIDTYPE(obj, widtype);
653    Widget_Data *wd = elm_widget_data_get(obj);
654
655    EINA_SAFETY_ON_TRUE_RETURN(setting >= ELM_THUMB_ANIMATION_LAST);
656
657    wd->anim_setting = setting;
658    if (setting == ELM_THUMB_ANIMATION_LOOP)
659      edje_object_signal_emit(wd->view, "animate_loop", "");
660    else if (setting == ELM_THUMB_ANIMATION_START)
661      edje_object_signal_emit(wd->view, "animate", "");
662    else if (setting == ELM_THUMB_ANIMATION_STOP)
663      edje_object_signal_emit(wd->view, "animate_stop", "");
664 }
665
666 /**
667  * Get the animation state for the thumb object.
668  *
669  * @param obj The thumb object.
670  * @return getting The animation setting or @c ELM_THUMB_ANIMATION_LAST,
671  * on errors.
672  *
673  * @see elm_thumb_file_get()
674  *
675  * @ingroup Thumb
676  */
677 EAPI Elm_Thumb_Animation_Setting
678 elm_thumb_animate_get(const Evas_Object *obj)
679 {
680    ELM_CHECK_WIDTYPE(obj, widtype) ELM_THUMB_ANIMATION_LAST;
681    Widget_Data *wd = elm_widget_data_get(obj);
682
683    return wd->anim_setting;
684 }
685
686 /**
687  * Get the ethumb_client handle so custom configuration can be made.
688  * This must be called before the objects are created to be sure no object is
689  * visible and no generation started.
690  *
691  * @return Ethumb_Client instance or NULL.
692  *
693  * Example of usage:
694  *
695  * @code
696  * #include <Elementary.h>
697  * #ifndef ELM_LIB_QUICKLAUNCH
698  * EAPI int
699  * elm_main(int argc, char **argv)
700  * {
701  *    Ethumb_Client *client;
702  *
703  *    elm_need_ethumb();
704  *
705  *    // ... your code
706  *
707  *    client = elm_thumb_ethumb_client_get();
708  *    if (!client)
709  *      {
710  *         ERR("could not get ethumb_client");
711  *         return 1;
712  *      }
713  *    ethumb_client_size_set(client, 100, 100);
714  *    ethumb_client_crop_align_set(client, 0.5, 0.5);
715  *    // ... your code
716  *
717  *    // Create elm_thumb objects here
718  *
719  *    elm_run();
720  *    elm_shutdown();
721  *    return 0;
722  * }
723  * #endif
724  * ELM_MAIN()
725  * @endcode
726  *
727  * @ingroup Thumb
728  */
729 EAPI void *
730 elm_thumb_ethumb_client_get(void)
731 {
732    return _elm_ethumb_client;
733 }
734
735 /**
736  * Get the ethumb_client connection state.
737  *
738  * @return EINA_TRUE if the client is connected to the server or
739  *         EINA_FALSE otherwise.
740  */
741 EAPI Eina_Bool
742 elm_thumb_ethumb_client_connected(void)
743 {
744    return _elm_ethumb_connected;
745 }
746
747 EAPI Eina_Bool
748 elm_thumb_editable_set(Evas_Object *obj, Eina_Bool edit)
749 {
750    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
751    Widget_Data *wd = elm_widget_data_get(obj);
752
753    if (!wd) return EINA_FALSE;
754    edit = !!edit;
755    if (wd->edit == edit) return EINA_TRUE;
756
757    wd->edit = edit;
758    if (wd->edit)
759      elm_drop_target_add(obj, ELM_SEL_FORMAT_IMAGE,
760                          _elm_thumb_dropcb, obj);
761    else
762      elm_drop_target_del(obj);
763
764    return EINA_TRUE;
765 }
766
767 EAPI Eina_Bool
768 elm_thumb_editable_get(const Evas_Object *obj)
769 {
770    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
771    Widget_Data *wd = elm_widget_data_get(obj);
772
773    if (!wd) return EINA_FALSE;
774    return wd->edit;
775 }
776
777 /* vim:set ts=8 sw=3 sts=3 expandtab cino=>5n-2f0^-2{2(0W1st0 :*/