src/lib/els_tooltip.c

   1 #include <Elementary.h>
   2 #include "elm_priv.h"
   3
   4 #ifdef ISCOMFITOR
   5 # define STR(X) #X
   6 # define STUPID(X) STR(X)
   7 # define TTDBG(x...) fprintf(stderr, STUPID(__LINE__)": " x)
   8 #else
   9 # define TTDBG(X...)
  10 #endif
  11
  12 static const char _tooltip_key[] = "_elm_tooltip";
  13
  14 #define ELM_TOOLTIP_GET_OR_RETURN(tt, obj, ...)         \
  15   Elm_Tooltip *tt;                                      \
  16   do                                                    \
  17     {                                                   \
  18        if (!(obj))                                      \
  19          {                                              \
  20             CRITICAL("Null pointer: " #obj);            \
  21             return __VA_ARGS__;                         \
  22          }                                              \
  23        tt = evas_object_data_get((obj), _tooltip_key);  \
  24        if (!tt)                                         \
  25          {                                              \
  26             ERR("Object does not have tooltip: " #obj); \
  27             return __VA_ARGS__;                         \
  28          }                                              \
  29     }                                                   \
  30   while (0)
  31
  32 struct _Elm_Tooltip
  33 {
  34    Elm_Tooltip_Content_Cb   func;
  35    Evas_Smart_Cb            del_cb;
  36    const void              *data;
  37    const char              *style;
  38    Evas                    *evas, *tt_evas;
  39    Evas_Object             *eventarea, *owner;
  40    Evas_Object             *tooltip, *content;
  41    Evas_Object             *tt_win;
  42    Ecore_Timer             *show_timer;
  43    Ecore_Timer             *hide_timer;
  44    Ecore_Job               *reconfigure_job;
  45    struct {
  46       Evas_Coord            x, y, bx, by;
  47    } pad;
  48    struct {
  49       double                x, y;
  50    } rel_pos;
  51    double                   hide_timeout; /* from theme */
  52    Eina_Bool                visible_lock:1;
  53    Eina_Bool                changed_style:1;
  54    Eina_Bool                free_size : 1;
  55 };
  56
  57 static void _elm_tooltip_reconfigure(Elm_Tooltip *tt);
  58 static void _elm_tooltip_reconfigure_job_start(Elm_Tooltip *tt);
  59 static void _elm_tooltip_reconfigure_job_stop(Elm_Tooltip *tt);
  60 static void _elm_tooltip_hide_anim_start(Elm_Tooltip *tt);
  61 static void _elm_tooltip_hide_anim_stop(Elm_Tooltip *tt);
  62 static void _elm_tooltip_show_timer_stop(Elm_Tooltip *tt);
  63 static void _elm_tooltip_hide(Elm_Tooltip *tt);
  64 static void _elm_tooltip_data_clean(Elm_Tooltip *tt);
  65
  66 static void
  67 _elm_tooltip_content_changed_hints_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
  68 {
  69    _elm_tooltip_reconfigure_job_start(data);
  70 }
  71
  72 static void
  73 _elm_tooltip_content_del_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
  74 {
  75    Elm_Tooltip *tt = data;
  76    tt->content = NULL;
  77    tt->visible_lock = EINA_FALSE;
  78    if (tt->tooltip) _elm_tooltip_hide(tt);
  79 }
  80
  81 static void
  82 _elm_tooltip_obj_move_cb(void *data, Evas *e  __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info  __UNUSED__)
  83 {
  84    Elm_Tooltip *tt = data;
  85    _elm_tooltip_reconfigure_job_start(tt);
  86 }
  87
  88 static void
  89 _elm_tooltip_obj_resize_cb(void *data, Evas *e  __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info  __UNUSED__)
  90 {
  91    Elm_Tooltip *tt = data;
  92    _elm_tooltip_reconfigure_job_start(tt);
  93 }
  94
  95 static void
  96 _elm_tooltip_obj_mouse_move_cb(void *data, Evas *e  __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info  __UNUSED__)
  97 {
  98    Elm_Tooltip *tt = data;
  99    _elm_tooltip_reconfigure_job_start(tt);
 100 }
 101
 102 static void
 103 _elm_tooltip_show(Elm_Tooltip *tt)
 104 {
 105    _elm_tooltip_show_timer_stop(tt);
 106    _elm_tooltip_hide_anim_stop(tt);
 107
 108    if (tt->tooltip)
 109      {
 110         _elm_tooltip_reconfigure_job_start(tt);
 111         return;
 112      }
 113    if (tt->free_size)
 114      {
 115         tt->tt_win = elm_win_add(NULL, "tooltip", ELM_WIN_BASIC);
 116         elm_win_borderless_set(tt->tt_win, EINA_TRUE);
 117         elm_win_override_set(tt->tt_win, EINA_TRUE);
 118         tt->tt_evas = evas_object_evas_get(tt->tt_win);
 119         tt->tooltip = edje_object_add(tt->tt_evas);
 120         evas_object_move(tt->tooltip, 0, 0);
 121         elm_win_resize_object_add(tt->tt_win, tt->tooltip);
 122 #ifdef HAVE_ELEMENTARY_X
 123         ecore_x_window_shape_input_rectangle_set(elm_win_xwindow_get(tt->tt_win), 0, 0, 0, 0);
 124 #endif
 125         evas_object_show(tt->tt_win);
 126      }
 127    else
 128       tt->tooltip = edje_object_add(tt->evas);
 129    if (!tt->tooltip) return;
 130
 131    evas_object_layer_set(tt->tt_win ?: tt->tooltip, ELM_OBJECT_LAYER_TOOLTIP);
 132
 133    evas_object_event_callback_add
 134      (tt->eventarea, EVAS_CALLBACK_MOVE, _elm_tooltip_obj_move_cb, tt);
 135    evas_object_event_callback_add
 136      (tt->eventarea, EVAS_CALLBACK_RESIZE, _elm_tooltip_obj_resize_cb, tt);
 137    evas_object_event_callback_add
 138      (tt->eventarea, EVAS_CALLBACK_MOUSE_MOVE, _elm_tooltip_obj_mouse_move_cb, tt);
 139
 140    tt->changed_style = EINA_TRUE;
 141    _elm_tooltip_reconfigure_job_start(tt);
 142 }
 143
 144 static void
 145 _elm_tooltip_content_del(Elm_Tooltip *tt)
 146 {
 147    if (!tt->content) return;
 148
 149    evas_object_event_callback_del_full
 150      (tt->content, EVAS_CALLBACK_CHANGED_SIZE_HINTS,
 151       _elm_tooltip_content_changed_hints_cb, tt);
 152    evas_object_event_callback_del_full
 153      (tt->content, EVAS_CALLBACK_DEL,
 154       _elm_tooltip_content_del_cb, tt);
 155    evas_object_hide(tt->content);
 156    evas_object_del(tt->content);
 157    tt->content = NULL;
 158 }
 159
 160
 161 static void
 162 _elm_tooltip_hide(Elm_Tooltip *tt)
 163 {
 164    Evas_Object *del;
 165    _elm_tooltip_show_timer_stop(tt);
 166    _elm_tooltip_hide_anim_stop(tt);
 167    _elm_tooltip_reconfigure_job_stop(tt);
 168
 169    if (!tt->tooltip) return;
 170    if (tt->visible_lock) return;
 171
 172    _elm_tooltip_content_del(tt);
 173
 174    evas_object_event_callback_del_full
 175      (tt->eventarea, EVAS_CALLBACK_MOVE, _elm_tooltip_obj_move_cb, tt);
 176    evas_object_event_callback_del_full
 177      (tt->eventarea, EVAS_CALLBACK_RESIZE, _elm_tooltip_obj_resize_cb, tt);
 178    evas_object_event_callback_del_full
 179      (tt->eventarea, EVAS_CALLBACK_MOUSE_MOVE, _elm_tooltip_obj_mouse_move_cb, tt);
 180
 181    del = tt->tt_win ?: tt->tooltip;
 182
 183    tt->tt_win = NULL;
 184    tt->tt_evas = NULL;
 185    tt->tooltip = NULL;
 186    evas_object_del(del);
 187 }
 188
 189 static void
 190 _elm_tooltip_reconfigure_job(void *data)
 191 {
 192    Elm_Tooltip *tt = data;
 193    tt->reconfigure_job = NULL;
 194    _elm_tooltip_reconfigure(data);
 195 }
 196
 197 static void
 198 _elm_tooltip_reconfigure_job_stop(Elm_Tooltip *tt)
 199 {
 200    if (!tt->reconfigure_job) return;
 201    ecore_job_del(tt->reconfigure_job);
 202    tt->reconfigure_job = NULL;
 203 }
 204
 205 static void
 206 _elm_tooltip_reconfigure_job_start(Elm_Tooltip *tt)
 207 {
 208    if (tt->reconfigure_job) ecore_job_del(tt->reconfigure_job);
 209    tt->reconfigure_job = ecore_job_add(_elm_tooltip_reconfigure_job, tt);
 210 }
 211
 212 static Eina_Bool
 213 _elm_tooltip_hide_anim_cb(void *data)
 214 {
 215    Elm_Tooltip *tt = data;
 216    tt->hide_timer = NULL;
 217    _elm_tooltip_hide(tt);
 218    return EINA_FALSE;
 219 }
 220
 221 static void
 222 _elm_tooltip_hide_anim_start(Elm_Tooltip *tt)
 223 {
 224    double extra = 0;
 225    if (tt->hide_timer) return;
 226    /* hide slightly faster when in window mode to look less stupid */
 227    if ((tt->hide_timeout > 0) && tt->tt_win) extra = 0.1;
 228    edje_object_signal_emit(tt->tooltip, "elm,action,hide", "elm");
 229    tt->hide_timer = ecore_timer_add
 230      (tt->hide_timeout - extra, _elm_tooltip_hide_anim_cb, tt);
 231 }
 232
 233 static void
 234 _elm_tooltip_hide_anim_stop(Elm_Tooltip *tt)
 235 {
 236    if (!tt->hide_timer) return;
 237    if (tt->tooltip)
 238      edje_object_signal_emit(tt->tooltip, "elm,action,show", "elm");
 239    ecore_timer_del(tt->hide_timer);
 240    tt->hide_timer = NULL;
 241 }
 242
 243 static void
 244 _elm_tooltip_reconfigure(Elm_Tooltip *tt)
 245 {
 246    Evas_Coord ox, oy, ow, oh, px, py, tx, ty, tw, th, cw = 0, ch = 0;
 247    Evas_Coord eminw, eminh, ominw, ominh;
 248    double rel_x, rel_y;
 249    Eina_Bool inside_eventarea;
 250
 251    _elm_tooltip_reconfigure_job_stop(tt);
 252
 253    if (tt->hide_timer) return;
 254    if (!tt->tooltip) return;
 255    if (tt->changed_style)
 256      {
 257         const char *style = tt->style ? tt->style : "default";
 258         const char *str;
 259         if (!_elm_theme_object_set(tt->tt_win ? NULL : tt->owner, tt->tooltip, "tooltip", "base", style))
 260           {
 261              ERR("Could not apply the theme to the tooltip! style=%s", style);
 262              if (tt->tt_win) evas_object_del(tt->tt_win);
 263              else evas_object_del(tt->tooltip);
 264              tt->tt_win = NULL;
 265              tt->tt_evas = NULL;
 266              tt->tooltip = NULL;
 267              return;
 268           }
 269
 270         tt->rel_pos.x = 0;
 271         tt->rel_pos.y = 0;
 272
 273         tt->pad.x = 0;
 274         tt->pad.y = 0;
 275         tt->pad.bx = 0;
 276         tt->pad.by = 0;
 277         tt->hide_timeout = 0.0;
 278
 279         str = edje_object_data_get(tt->tooltip, "transparent");
 280         if (tt->tt_win)
 281           {  /* FIXME: hardcoded here is bad */
 282              if (str && (!strcmp(str, "enabled")))
 283                {
 284                   elm_win_alpha_set(tt->tt_win, EINA_TRUE);
 285                   elm_win_transparent_set(tt->tt_win, EINA_TRUE);
 286                }
 287              else
 288                {
 289                   elm_win_alpha_set(tt->tt_win, EINA_FALSE);
 290                   elm_win_transparent_set(tt->tt_win, EINA_FALSE);
 291                }
 292           }
 293
 294         str = edje_object_data_get(tt->tooltip, "pad_x");
 295         if (str) tt->pad.x = atoi(str);
 296         str = edje_object_data_get(tt->tooltip, "pad_y");
 297         if (str) tt->pad.y = atoi(str);
 298
 299         str = edje_object_data_get(tt->tooltip, "pad_border_x");
 300         if (str) tt->pad.bx = atoi(str);
 301         str = edje_object_data_get(tt->tooltip, "pad_border_y");
 302         if (str) tt->pad.by = atoi(str);
 303
 304         str = edje_object_data_get(tt->tooltip, "hide_timeout");
 305         if (str)
 306           {
 307              tt->hide_timeout = atof(str);
 308              if (tt->hide_timeout < 0.0) tt->hide_timeout = 0.0;
 309           }
 310
 311         evas_object_pass_events_set(tt->tooltip, EINA_TRUE);
 312         tt->changed_style = EINA_FALSE;
 313         if (tt->tooltip)
 314           edje_object_part_swallow(tt->tooltip, "elm.swallow.content",
 315                                    tt->content);
 316
 317         edje_object_signal_emit(tt->tooltip, "elm,action,show", "elm");
 318      }
 319
 320    if (!tt->content)
 321      {
 322         tt->content = tt->func((void *)tt->data, tt->owner, tt->tt_win ? : tt->owner);
 323         if (!tt->content)
 324           {
 325              WRN("could not create tooltip content!");
 326              if (tt->tt_win) evas_object_del(tt->tt_win);
 327              else evas_object_del(tt->tooltip);
 328
 329              tt->tt_win = NULL;
 330              tt->tt_evas = NULL;
 331              tt->tooltip = NULL;
 332              return;
 333           }
 334         evas_object_show(tt->content);
 335         evas_object_layer_set(tt->content, ELM_OBJECT_LAYER_TOOLTIP);
 336         evas_object_pass_events_set(tt->content, EINA_TRUE);
 337         edje_object_part_swallow
 338           (tt->tooltip, "elm.swallow.content", tt->content);
 339         evas_object_event_callback_add(tt->content, EVAS_CALLBACK_CHANGED_SIZE_HINTS,
 340            _elm_tooltip_content_changed_hints_cb, tt);
 341         evas_object_event_callback_add(tt->content, EVAS_CALLBACK_DEL,
 342            _elm_tooltip_content_del_cb, tt);
 343
 344      }
 345    TTDBG("*******RECALC\n");
 346    evas_object_size_hint_min_get(tt->content, &ominw, &ominh);
 347    edje_object_size_min_get(tt->tooltip, &eminw, &eminh);
 348
 349    if (eminw && (ominw < eminw)) ominw = eminw;
 350    if (eminw && (ominh < eminh)) ominh = eminh;
 351
 352    if (ominw < 1) ominw = 10; /* at least it is noticeable */
 353    if (ominh < 1) ominh = 10; /* at least it is noticeable */
 354
 355    edje_object_size_min_restricted_calc(tt->tooltip, &tw, &th, ominw, ominh);
 356    TTDBG("TTSIZE:  tw=%d,th=%d,ominw=%d,ominh=%d\n", tw, th, ominw, ominh);
 357
 358    if (tt->tt_win)
 359      elm_win_screen_size_get(elm_object_top_widget_get(tt->owner), NULL, NULL, &cw, &ch);
 360    if (!cw)
 361      evas_output_size_get(tt->tt_evas ?: tt->evas, &cw, &ch);
 362    TTDBG("SCREEN:  cw=%d,ch=%d\n", cw, ch);
 363
 364    evas_object_geometry_get(tt->eventarea, &ox, &oy, &ow, &oh);
 365    TTDBG("EVENTAREA:  ox=%d,oy=%d,ow=%d,oh=%d\n", ox, oy, ow, oh);
 366
 367    if (tt->tt_win)
 368      {
 369         int x, y;
 370         Evas_Object *win = elm_object_top_widget_get(tt->owner);
 371 #ifdef HAVE_ELEMENTARY_X
 372         Ecore_X_Window xwin = elm_win_xwindow_get(win);
 373         ecore_x_pointer_xy_get(xwin, &px, &py);
 374 #endif
 375         elm_win_screen_position_get(win, &x, &y);
 376         ox += x;
 377         if (px) px += x;
 378         oy += y;
 379         if (py) py += y;
 380      }
 381    else
 382      evas_pointer_canvas_xy_get(tt->evas, &px, &py);
 383    TTDBG("POINTER:  px=%d,py=%d\n", px, py);
 384    inside_eventarea = ((px >= ox) && (py >= oy) &&
 385                        (px <= ox + ow) && (py <= oy + oh));
 386    if (inside_eventarea)
 387      {
 388         /* try to position bottom right corner at pointer */
 389         tx = px - tw;
 390         ty = py - th;
 391         TTDBG("INIT (EVENTAREA)\n");
 392      }
 393    else
 394      {
 395         /* try centered on middle of eventarea */
 396         tx = ox + (ow / 2) - (tw / 2);
 397         if (0 > (th - oy - oh)) ty = oy + th;
 398         else ty = oy - oh;
 399         TTDBG("INIT (INTERPRETED)\n");
 400      }
 401    TTDBG("ADJUST (POINTER):  tx=%d,ty=%d\n", tx, ty);
 402    if (tx < 0)
 403      {
 404         /* if we're offscreen, try to flip over the Y axis */
 405         if (abs((tx + 2 * tw) - cw) < abs(tx))
 406           tx += tw;
 407      }
 408    else if ((tx > px) && (px > tw))
 409      {
 410         if (tx + tw < cw)
 411           tx += tw;
 412      }
 413    if (ty < 0)
 414      {
 415         /* if we're offscreen, try to flip over the X axis */
 416         if (abs((ty + 2 * th) - ch) < abs(ty))
 417           ty += th;
 418      }
 419    else if ((ty > py) && (py > th))
 420      {
 421         if (ty + th < ch)
 422           ty += th;
 423      }
 424    TTDBG("ADJUST (FLIP):  tx=%d,ty=%d\n", tx, ty);
 425    if (inside_eventarea)
 426      {
 427         if ((tx == px) && ((tx + tw + tt->pad.x < cw) || (tx + tw > cw))) tx += tt->pad.x;
 428         else if ((tx - tt->pad.x > 0) || (tx < 0)) tx -= tt->pad.x;
 429         if ((ty == py) && ((ty + th + tt->pad.y < ch) || (ty + th > ch))) ty += tt->pad.y;
 430         else if ((ty - tt->pad.y > 0) || (ty < 0)) ty -= tt->pad.y;
 431      }
 432    TTDBG("PAD:  tx=%d,ty=%d\n", tx, ty);
 433    if (tt->pad.bx * 2 + tw < cw)
 434      {
 435         if (tx < tt->pad.bx) tx = tt->pad.bx;
 436         else if ((tx >= tw) && (tx + tt->pad.bx <= cw)) tx += tt->pad.bx;
 437         else if (tx - tt->pad.bx >= 0) tx -= tt->pad.bx;
 438      }
 439    else if (tx < 0) tx -= tt->pad.bx;
 440    else if (tx > cw) tx += tt->pad.bx;
 441    if (tt->pad.by * 2 + th < ch)
 442      {
 443         if (ty < tt->pad.by) ty = tt->pad.by;
 444         else if ((ty >= th) && (ty + tt->pad.by <= ch)) ty += tt->pad.by;
 445         else if (ty - tt->pad.by >= 0) ty -= tt->pad.by;
 446      }
 447    else if (ty < 0) ty -= tt->pad.by;
 448    else if (ty > ch) ty += tt->pad.by;
 449    TTDBG("PAD (BORDER):  tx=%d,ty=%d\n", tx, ty);
 450    if ((tx < 0) || (ty < 0))
 451      {
 452         TTDBG("POSITIONING FAILED! THIS IS A BUG SOMEWHERE!\n");
 453         return;
 454      }
 455    evas_object_move(tt->tt_win ? : tt->tooltip, tx, ty);
 456    evas_object_resize(tt->tt_win ? : tt->tooltip, tw, th);
 457    evas_object_show(tt->tooltip);
 458
 459    if (inside_eventarea)
 460      {
 461         rel_x = (px - tx) / (double)tw;
 462         rel_y = (py - ty) / (double)th;
 463      }
 464    else
 465      {
 466         rel_x = (ox + (ow / 2) - tx) / (double)tw;
 467         rel_y = (oy + (oh / 2) - ty) / (double)th;
 468      }
 469
 470 #define FDIF(a, b) (fabs((a) - (b)) > 0.0001)
 471    if ((FDIF(rel_x, tt->rel_pos.x)) || (FDIF(rel_y, tt->rel_pos.y)))
 472      {
 473         Edje_Message_Float_Set *msg;
 474
 475         msg = alloca(sizeof(Edje_Message_Float_Set) + sizeof(double));
 476         msg->count = 2;
 477         msg->val[0] = rel_x;
 478         msg->val[1] = rel_y;
 479         tt->rel_pos.x = rel_x;
 480         tt->rel_pos.y = rel_y;
 481
 482         edje_object_message_send(tt->tooltip, EDJE_MESSAGE_FLOAT_SET, 1, msg);
 483      }
 484 #undef FDIF
 485 }
 486
 487 static void
 488 _elm_tooltip_show_timer_stop(Elm_Tooltip *tt)
 489 {
 490    if (!tt->show_timer) return;
 491    ecore_timer_del(tt->show_timer);
 492    tt->show_timer = NULL;
 493 }
 494
 495 static Eina_Bool
 496 _elm_tooltip_timer_show_cb(void *data)
 497 {
 498    Elm_Tooltip *tt = data;
 499    tt->show_timer = NULL;
 500    _elm_tooltip_show(tt);
 501    return ECORE_CALLBACK_CANCEL;
 502 }
 503
 504 static void
 505 _elm_tooltip_obj_mouse_in_cb(void *data, Evas *e  __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info  __UNUSED__)
 506 {
 507    Elm_Tooltip *tt = data;
 508
 509    _elm_tooltip_hide_anim_stop(tt);
 510
 511    if ((tt->show_timer) || (tt->tooltip)) return;
 512
 513    tt->show_timer = ecore_timer_add
 514      (_elm_config->tooltip_delay, _elm_tooltip_timer_show_cb, tt);
 515 }
 516
 517 static void
 518 _elm_tooltip_obj_mouse_out_cb(Elm_Tooltip *tt, Evas *e  __UNUSED__, Evas_Object *obj __UNUSED__, Evas_Event_Mouse_Out *event __UNUSED__)
 519 {
 520    if (tt->visible_lock) return;
 521
 522    if (!tt->tooltip)
 523      {
 524         _elm_tooltip_show_timer_stop(tt);
 525         return;
 526      }
 527    _elm_tooltip_hide_anim_start(tt);
 528 }
 529
 530 static void _elm_tooltip_obj_free_cb(void *data, Evas *e  __UNUSED__, Evas_Object *obj, void *event_info  __UNUSED__);
 531
 532 static void
 533 _elm_tooltip_unset(Elm_Tooltip *tt)
 534 {
 535    tt->visible_lock = EINA_FALSE;
 536    _elm_tooltip_hide(tt);
 537    _elm_tooltip_data_clean(tt);
 538
 539    if (tt->eventarea)
 540      {
 541         evas_object_event_callback_del_full
 542           (tt->eventarea, EVAS_CALLBACK_MOUSE_IN,
 543            _elm_tooltip_obj_mouse_in_cb, tt);
 544         evas_object_event_callback_del_full
 545           (tt->eventarea, EVAS_CALLBACK_MOUSE_OUT,
 546            (Evas_Object_Event_Cb)_elm_tooltip_obj_mouse_out_cb, tt);
 547         evas_object_event_callback_del_full
 548           (tt->eventarea, EVAS_CALLBACK_FREE, _elm_tooltip_obj_free_cb, tt);
 549
 550         evas_object_data_del(tt->eventarea, _tooltip_key);
 551      }
 552    if (tt->owner)
 553      {
 554         evas_object_event_callback_del_full
 555           (tt->owner, EVAS_CALLBACK_FREE, _elm_tooltip_obj_free_cb, tt);
 556         elm_widget_tooltip_del(tt->owner, tt);
 557      }
 558
 559    eina_stringshare_del(tt->style);
 560    free(tt);
 561 }
 562
 563 static void
 564 _elm_tooltip_obj_free_cb(void *data, Evas *e  __UNUSED__, Evas_Object *obj, void *event_info  __UNUSED__)
 565 {
 566    Elm_Tooltip *tt = data;
 567    if (tt->eventarea == obj) tt->eventarea = NULL;
 568    if (tt->owner == obj) tt->owner = NULL;
 569    _elm_tooltip_unset(tt);
 570 }
 571
 572 static Evas_Object *
 573 _elm_tooltip_label_create(void *data, Evas_Object *obj __UNUSED__, Evas_Object *tooltip)
 574 {
 575    Evas_Object *label = elm_label_add(tooltip);
 576    if (!label)
 577      return NULL;
 578    elm_object_style_set(label, "tooltip");
 579    elm_object_text_set(label, data);
 580    return label;
 581 }
 582
 583 static Evas_Object *
 584 _elm_tooltip_trans_label_create(void *data, Evas_Object *obj __UNUSED__, Evas_Object *tooltip)
 585 {
 586    Evas_Object *label = elm_label_add(tooltip);
 587    const char **text = data;
 588    if (!label)
 589      return NULL;
 590    elm_object_style_set(label, "tooltip");
 591    elm_object_domain_translatable_text_set(label, text[0], text[1]);
 592    return label;
 593 }
 594
 595 static void
 596 _elm_tooltip_label_del_cb(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
 597 {
 598    eina_stringshare_del(data);
 599 }
 600
 601 static void
 602 _elm_tooltip_trans_label_del_cb(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
 603 {
 604    const char **text = data;
 605    eina_stringshare_del(text[0]);
 606    eina_stringshare_del(text[1]);
 607    free(text);
 608 }
 609
 610 static void
 611 _elm_tooltip_data_clean(Elm_Tooltip *tt)
 612 {
 613    if (tt->del_cb) tt->del_cb((void *)tt->data, tt->owner, NULL);
 614
 615    _elm_tooltip_content_del(tt);
 616
 617    tt->data = NULL;
 618    tt->del_cb = NULL;
 619 }
 620
 621 /**
 622  * Notify tooltip should recalculate its theme.
 623  * @internal
 624  */
 625 void
 626 elm_tooltip_theme(Elm_Tooltip *tt)
 627 {
 628    if (!tt->tooltip) return;
 629    tt->changed_style = EINA_TRUE;
 630    _elm_tooltip_reconfigure_job_start(tt);
 631 }
 632
 633
 634 /**
 635  * Set the content to be shown in the tooltip object for specific event area.
 636  *
 637  * Setup the tooltip to object. The object @a eventarea can have only
 638  * one tooltip, so any previous tooltip data is removed. @p func(with
 639  * @p data) will be called every time that need show the tooltip and
 640  * it should return a valid Evas_Object. This object is then managed
 641  * fully by tooltip system and is deleted when the tooltip is gone.
 642  *
 643  * This is an internal function that is used by objects with sub-items
 644  * that want to provide different tooltips for each of them. The @a
 645  * owner object should be an elm_widget and will be used to track
 646  * theme changes and to feed @a func and @a del_cb. The @a eventarea
 647  * may be any object and is the one that should be used later on with
 648  * elm_object_tooltip apis, such as elm_object_tooltip_hide(),
 649  * elm_object_tooltip_show() or elm_object_tooltip_unset().
 650  *
 651  * @param eventarea the object being attached a tooltip.
 652  * @param owner the elm_widget that owns this object, will be used to
 653  *        track theme changes and to be used in @a func or @a del_cb.
 654  * @param func the function used to create the tooltip contents. The
 655  *        @a Evas_Object parameters will receive @a owner as value.
 656  * @param data what to provide to @a func as callback data/context.
 657  * @param del_cb called when data is not needed anymore, either when
 658  *        another callback replaces @p func, the tooltip is unset with
 659  *        elm_object_tooltip_unset() or the owner object @a obj
 660  *        dies. This callback receives as the first parameter the
 661  *        given @a data, and @c event_info is NULL.
 662  *
 663  * @internal
 664  * @ingroup Tooltips
 665  */
 666 void
 667 elm_object_sub_tooltip_content_cb_set(Evas_Object *eventarea, Evas_Object *owner, Elm_Tooltip_Content_Cb func, const void *data, Evas_Smart_Cb del_cb)
 668 {
 669    Elm_Tooltip *tt = NULL;
 670    Eina_Bool just_created;
 671
 672    EINA_SAFETY_ON_NULL_GOTO(owner, error);
 673    EINA_SAFETY_ON_NULL_GOTO(eventarea, error);
 674
 675    if (!func)
 676      {
 677         elm_object_tooltip_unset(eventarea);
 678         return;
 679      }
 680
 681    tt = evas_object_data_get(eventarea, _tooltip_key);
 682    if (tt)
 683      {
 684         if (tt->owner != owner)
 685           {
 686              if (tt->owner != eventarea)
 687                evas_object_event_callback_del_full
 688                  (tt->owner, EVAS_CALLBACK_FREE, _elm_tooltip_obj_free_cb, tt);
 689
 690              elm_widget_tooltip_del(tt->owner, tt);
 691
 692              if (owner != eventarea)
 693                evas_object_event_callback_add
 694                  (owner, EVAS_CALLBACK_FREE, _elm_tooltip_obj_free_cb, tt);
 695
 696              elm_widget_tooltip_add(tt->owner, tt);
 697           }
 698
 699         if ((tt->func == func) && (tt->data == data) &&
 700             (tt->del_cb == del_cb))
 701           return;
 702         _elm_tooltip_data_clean(tt);
 703         just_created = EINA_FALSE;
 704      }
 705    else
 706      {
 707         tt = ELM_NEW(Elm_Tooltip);
 708         if (!tt) goto error;
 709
 710         tt->owner = owner;
 711         tt->eventarea = eventarea;
 712         tt->evas = evas_object_evas_get(eventarea);
 713         evas_object_data_set(eventarea, _tooltip_key, tt);
 714
 715         just_created = EINA_TRUE;
 716
 717         evas_object_event_callback_add(eventarea, EVAS_CALLBACK_MOUSE_IN,
 718            _elm_tooltip_obj_mouse_in_cb, tt);
 719         evas_object_event_callback_add(eventarea, EVAS_CALLBACK_MOUSE_OUT,
 720            (Evas_Object_Event_Cb)_elm_tooltip_obj_mouse_out_cb, tt);
 721         evas_object_event_callback_add(eventarea, EVAS_CALLBACK_FREE,
 722            _elm_tooltip_obj_free_cb, tt);
 723
 724         if (owner != eventarea)
 725           evas_object_event_callback_add
 726             (owner, EVAS_CALLBACK_FREE, _elm_tooltip_obj_free_cb, tt);
 727
 728         elm_widget_tooltip_add(tt->owner, tt);
 729      }
 730
 731    tt->func = func;
 732    tt->data = data;
 733    tt->del_cb = del_cb;
 734
 735    if (!just_created) _elm_tooltip_reconfigure_job_start(tt);
 736    return;
 737
 738  error:
 739    if (del_cb) del_cb((void *)data, owner, NULL);
 740 }
 741
 742 /**
 743  * Force show tooltip of object
 744  *
 745  * @param obj Target object
 746  *
 747  * Force show the tooltip and disable hide on mouse_out.
 748  * If another content is set as tooltip, the visible tooltip will hididen and
 749  * showed again with new content.
 750  * This can force show more than one tooltip at a time.
 751  *
 752  * @ingroup Tooltips
 753  */
 754 EAPI void
 755 elm_object_tooltip_show(Evas_Object *obj)
 756 {
 757    ELM_TOOLTIP_GET_OR_RETURN(tt, obj);
 758    tt->visible_lock = EINA_TRUE;
 759    _elm_tooltip_show(tt);
 760 }
 761
 762 /**
 763  * Force hide tooltip of object
 764  *
 765  * @param obj Target object
 766  *
 767  * Force hide the tooltip and (re)enable future mouse interations.
 768  *
 769  * @ingroup Tooltips
 770  */
 771 EAPI void
 772 elm_object_tooltip_hide(Evas_Object *obj)
 773 {
 774    ELM_TOOLTIP_GET_OR_RETURN(tt, obj);
 775    tt->visible_lock = EINA_FALSE;
 776    _elm_tooltip_hide_anim_start(tt);
 777 }
 778
 779 /**
 780  * Set the text to be shown in the tooltip object
 781  *
 782  * @param obj Target object
 783  * @param text The text to set in the content
 784  *
 785  * Setup the text as tooltip to object. The object can have only one tooltip,
 786  * so any previous tooltip data is removed.
 787  * This method call internaly the elm_tooltip_content_cb_set().
 788  *
 789  * @ingroup Tooltips
 790  */
 791 EAPI void
 792 elm_object_tooltip_text_set(Evas_Object *obj, const char *text)
 793 {
 794    EINA_SAFETY_ON_NULL_RETURN(obj);
 795    EINA_SAFETY_ON_NULL_RETURN(text);
 796
 797    text = eina_stringshare_add(text);
 798    elm_object_tooltip_content_cb_set
 799      (obj, _elm_tooltip_label_create, text, _elm_tooltip_label_del_cb);
 800 }
 801
 802 /**
 803  */
 804 EAPI void
 805 elm_object_tooltip_domain_translatable_text_set(Evas_Object *obj, const char *domain, const char *text)
 806 {
 807    const char **data;
 808    EINA_SAFETY_ON_NULL_RETURN(obj);
 809    EINA_SAFETY_ON_NULL_RETURN(text);
 810
 811    data = malloc(2 * sizeof(char *));
 812    if (!data) return;
 813    data[0] = eina_stringshare_add(domain);
 814    data[1] = eina_stringshare_add(text);
 815    elm_object_tooltip_content_cb_set
 816      (obj, _elm_tooltip_trans_label_create, data,
 817       _elm_tooltip_trans_label_del_cb);
 818 }
 819
 820 /**
 821  * Set the content to be shown in the tooltip object
 822  *
 823  * Setup the tooltip to object. The object can have only one tooltip,
 824  * so any previous tooltip data is removed. @p func(with @p data) will
 825  * be called every time that need show the tooltip and it should
 826  * return a valid Evas_Object. This object is then managed fully by
 827  * tooltip system and is deleted when the tooltip is gone.
 828  *
 829  * @param obj the object being attached a tooltip.
 830  * @param func the function used to create the tooltip contents.
 831  * @param data what to provide to @a func as callback data/context.
 832  * @param del_cb called when data is not needed anymore, either when
 833  *        another callback replaces @p func, the tooltip is unset with
 834  *        elm_object_tooltip_unset() or the owner object @a obj
 835  *        dies. This callback receives as the first parameter the
 836  *        given @a data, and @c event_info is NULL.
 837  *
 838  * @ingroup Tooltips
 839  */
 840 EAPI void
 841 elm_object_tooltip_content_cb_set(Evas_Object *obj, Elm_Tooltip_Content_Cb func, const void *data, Evas_Smart_Cb del_cb)
 842 {
 843    elm_object_sub_tooltip_content_cb_set(obj, obj, func, data, del_cb);
 844 }
 845
 846 /**
 847  * Unset tooltip from object
 848  *
 849  * @param obj Target object
 850  *
 851  * Remove tooltip from object. The callback provided as del_cb to
 852  * elm_object_tooltip_content_cb_set() will be called to notify it is
 853  * not used anymore.
 854  *
 855  * @see elm_object_tooltip_content_cb_set()
 856  *
 857  * @ingroup Tooltips
 858  */
 859 EAPI void
 860 elm_object_tooltip_unset(Evas_Object *obj)
 861 {
 862    ELM_TOOLTIP_GET_OR_RETURN(tt, obj);
 863    _elm_tooltip_unset(tt);
 864 }
 865
 866 /**
 867  * Sets a different style for this object tooltip.
 868  *
 869  * @note before you set a style you should define a tooltip with
 870  *       elm_object_tooltip_content_cb_set() or
 871  *       elm_object_tooltip_text_set().
 872  *
 873  * @param obj an object with tooltip already set.
 874  * @param style the theme style to use (default, transparent, ...)
 875  */
 876 EAPI void
 877 elm_object_tooltip_style_set(Evas_Object *obj, const char *style)
 878 {
 879    ELM_TOOLTIP_GET_OR_RETURN(tt, obj);
 880    if (!eina_stringshare_replace(&tt->style, style)) return;
 881    elm_tooltip_theme(tt);
 882 }
 883
 884 /**
 885  * Get the style for this object tooltip.
 886  *
 887  * @param obj an object with tooltip already set.
 888  * @return style the theme style in use, defaults to "default". If the
 889  *         object does not have a tooltip set, then NULL is returned.
 890  */
 891 EAPI const char *
 892 elm_object_tooltip_style_get(const Evas_Object *obj)
 893 {
 894    ELM_TOOLTIP_GET_OR_RETURN(tt, obj, NULL);
 895    return tt->style ? tt->style : "default";
 896 }
 897
 898 /**
 899  * Get the configured tooltip delay
 900  *
 901  * This gets the globally configured tooltip delay in seconds
 902  *
 903  * @return The tooltip delay
 904  * @ingroup Tooltips
 905  */
 906 EAPI double
 907 elm_tooltip_delay_get(void)
 908 {
 909    return _elm_config->tooltip_delay;
 910 }
 911
 912 /**
 913  * Set the configured tooltip delay
 914  *
 915  * This sets the globally configured delay to tooltip
 916  *
 917  * @param delay The delay to show the tooltip
 918  * @return EINA_TRUE if value is valid and setted
 919  * @ingroup Tooltips
 920  */
 921 EAPI Eina_Bool
 922 elm_tooltip_delay_set(double delay)
 923 {
 924    if (delay < 0.0) return EINA_FALSE;
 925    _elm_config->tooltip_delay = delay;
 926    return EINA_TRUE;
 927 }
 928
 929 /**
 930  * @brief Disable size restrictions on an object's tooltip
 931  * @param obj The tooltip's anchor object
 932  * @param disable If EINA_TRUE, size restrictions are disabled
 933  * @return EINA_FALSE on failure, EINA_TRUE on success
 934  *
 935  * This function allows a tooltip to expand beyond its parant window's canvas.
 936  * It will instead be limited only by the size of the display.
 937  */
 938 EAPI Eina_Bool
 939 elm_object_tooltip_window_mode_set(Evas_Object *obj, Eina_Bool disable)
 940 {
 941    ELM_TOOLTIP_GET_OR_RETURN(tt, obj, EINA_FALSE);
 942    return tt->free_size = disable;
 943 }
 944
 945 /**
 946  * @brief Retrieve size restriction state of an object's tooltip
 947  * @param obj The tooltip's anchor object
 948  * @return If EINA_TRUE, size restrictions are disabled
 949  *
 950  * This function returns whether a tooltip is allowed to expand beyond
 951  * its parant window's canvas.
 952  * It will instead be limited only by the size of the display.
 953  */
 954 EAPI Eina_Bool
 955 elm_object_tooltip_window_mode_get(const Evas_Object *obj)
 956 {
 957    ELM_TOOLTIP_GET_OR_RETURN(tt, obj, EINA_FALSE);
 958    return tt->free_size;
 959 }