src/lib/elm_thumb.c

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