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