2010-09-10 17:52:33 -07:00
|
|
|
#include <Elementary.h>
|
|
|
|
#include "elm_priv.h"
|
|
|
|
|
2011-11-23 20:16:03 -08:00
|
|
|
#ifdef ISCOMFITOR
|
|
|
|
# define STR(X) #X
|
|
|
|
# define STUPID(X) STR(X)
|
|
|
|
# define TTDBG(x...) fprintf(stderr, STUPID(__LINE__)": " x)
|
|
|
|
#else
|
|
|
|
# define TTDBG(X...)
|
|
|
|
#endif
|
|
|
|
|
2010-09-10 17:52:33 -07:00
|
|
|
static const char _tooltip_key[] = "_elm_tooltip";
|
|
|
|
|
|
|
|
#define ELM_TOOLTIP_GET_OR_RETURN(tt, obj, ...) \
|
|
|
|
Elm_Tooltip *tt; \
|
|
|
|
do \
|
|
|
|
{ \
|
|
|
|
if (!(obj)) \
|
|
|
|
{ \
|
|
|
|
CRITICAL("Null pointer: " #obj); \
|
|
|
|
return __VA_ARGS__; \
|
|
|
|
} \
|
|
|
|
tt = evas_object_data_get((obj), _tooltip_key); \
|
|
|
|
if (!tt) \
|
|
|
|
{ \
|
|
|
|
ERR("Object does not have tooltip: " #obj); \
|
|
|
|
return __VA_ARGS__; \
|
|
|
|
} \
|
|
|
|
} \
|
|
|
|
while (0)
|
|
|
|
|
|
|
|
struct _Elm_Tooltip
|
|
|
|
{
|
|
|
|
Elm_Tooltip_Content_Cb func;
|
|
|
|
Evas_Smart_Cb del_cb;
|
|
|
|
const void *data;
|
|
|
|
const char *style;
|
2011-07-26 02:38:23 -07:00
|
|
|
Evas *evas, *tt_evas;
|
Tooltips: split owner/eventarea, allow subitems to have indepentent tooltips.
Now owner widget (elm_widget) is just used to listen for theme changes
and create/destroy the tooltip data. The actual mouse events operates
on all Evas_Object and is the one where tooltip data is actually
stored.
The public API is basically the same, just the event_info is now NULL
to avoid confusion.
The internal API introduces elm_object_sub_tooltip_content_cb_set()
and as the first parameter the eventarea. While this may be confusing,
as the second parameter is the actual elementary object, it is the one
that all other calls receive, like elm_object_tooltip_hide() or
elm_object_tooltip_unset(), thus it does make sense to have such order.
Also internal API, elm_widget_item_tooltip_* functions were
added. They are a variation of the widget API to handle its items, as
such the func() gets one more parameter: item, and the del_cb() gets
the item as event_info (that's why the public widget version got
event_info always NULL, to not confuse with this one!)
Widgets with items that makes sense to have tooltips got extra API:
* toolbar
* list
* gengrid
* genlist
SVN revision: 52173
2010-09-12 14:05:13 -07:00
|
|
|
Evas_Object *eventarea, *owner;
|
2010-09-10 17:52:33 -07:00
|
|
|
Evas_Object *tooltip, *content;
|
2011-07-26 02:38:23 -07:00
|
|
|
Evas_Object *tt_win;
|
2010-09-10 17:52:33 -07:00
|
|
|
Ecore_Timer *show_timer;
|
2010-09-12 10:24:45 -07:00
|
|
|
Ecore_Timer *hide_timer;
|
2010-09-10 17:52:33 -07:00
|
|
|
Ecore_Job *reconfigure_job;
|
2012-03-11 15:13:24 -07:00
|
|
|
Evas_Coord mouse_x, mouse_y;
|
2012-03-28 02:02:22 -07:00
|
|
|
struct
|
|
|
|
{
|
|
|
|
Evas_Coord x, y, bx, by;
|
|
|
|
} pad;
|
|
|
|
struct
|
|
|
|
{
|
|
|
|
double x, y;
|
|
|
|
} rel_pos;
|
2010-09-12 10:24:45 -07:00
|
|
|
double hide_timeout; /* from theme */
|
2010-09-10 17:52:33 -07:00
|
|
|
Eina_Bool visible_lock:1;
|
|
|
|
Eina_Bool changed_style:1;
|
2011-07-26 02:38:23 -07:00
|
|
|
Eina_Bool free_size : 1;
|
2010-09-10 17:52:33 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
static void _elm_tooltip_reconfigure(Elm_Tooltip *tt);
|
|
|
|
static void _elm_tooltip_reconfigure_job_start(Elm_Tooltip *tt);
|
|
|
|
static void _elm_tooltip_reconfigure_job_stop(Elm_Tooltip *tt);
|
2010-09-12 10:24:45 -07:00
|
|
|
static void _elm_tooltip_hide_anim_start(Elm_Tooltip *tt);
|
|
|
|
static void _elm_tooltip_hide_anim_stop(Elm_Tooltip *tt);
|
2010-09-10 17:52:33 -07:00
|
|
|
static void _elm_tooltip_show_timer_stop(Elm_Tooltip *tt);
|
|
|
|
static void _elm_tooltip_hide(Elm_Tooltip *tt);
|
2010-09-16 16:44:02 -07:00
|
|
|
static void _elm_tooltip_data_clean(Elm_Tooltip *tt);
|
2010-09-10 17:52:33 -07:00
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_tooltip_content_changed_hints_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
|
|
|
|
{
|
|
|
|
_elm_tooltip_reconfigure_job_start(data);
|
2012-03-11 15:01:55 -07:00
|
|
|
TTDBG("HINTS CHANGED\n");
|
2010-09-10 17:52:33 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_tooltip_content_del_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
|
|
|
|
{
|
|
|
|
Elm_Tooltip *tt = data;
|
|
|
|
tt->content = NULL;
|
|
|
|
tt->visible_lock = EINA_FALSE;
|
2011-10-02 21:12:40 -07:00
|
|
|
if (tt->tooltip) _elm_tooltip_hide(tt);
|
2010-09-10 17:52:33 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_tooltip_obj_move_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
|
|
|
|
{
|
|
|
|
Elm_Tooltip *tt = data;
|
|
|
|
_elm_tooltip_reconfigure_job_start(tt);
|
2012-03-11 15:01:55 -07:00
|
|
|
TTDBG("TT MOVED\n");
|
2010-09-10 17:52:33 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_tooltip_obj_resize_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
|
|
|
|
{
|
|
|
|
Elm_Tooltip *tt = data;
|
|
|
|
_elm_tooltip_reconfigure_job_start(tt);
|
2012-03-11 15:01:55 -07:00
|
|
|
TTDBG("TT RESIZE\n");
|
2010-09-10 17:52:33 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-03-11 15:13:24 -07:00
|
|
|
_elm_tooltip_obj_mouse_move_cb(Elm_Tooltip *tt, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, Evas_Event_Mouse_Move *ev)
|
2010-09-10 17:52:33 -07:00
|
|
|
{
|
2012-03-11 15:13:24 -07:00
|
|
|
if (tt->mouse_x || tt->mouse_y)
|
|
|
|
{
|
|
|
|
if ((abs(ev->cur.output.x - tt->mouse_x) < 3) &&
|
|
|
|
(abs(ev->cur.output.y - tt->mouse_y) < 3))
|
|
|
|
{
|
|
|
|
TTDBG("MOUSE MOVE REJECTED!\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
tt->mouse_x = ev->cur.output.x;
|
|
|
|
tt->mouse_y = ev->cur.output.y;
|
2012-03-11 15:01:55 -07:00
|
|
|
TTDBG("MOUSE MOVED\n");
|
2012-03-11 15:13:24 -07:00
|
|
|
_elm_tooltip_reconfigure_job_start(tt);
|
2010-09-10 17:52:33 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_tooltip_show(Elm_Tooltip *tt)
|
|
|
|
{
|
|
|
|
_elm_tooltip_show_timer_stop(tt);
|
2010-09-12 10:24:45 -07:00
|
|
|
_elm_tooltip_hide_anim_stop(tt);
|
2010-09-10 17:52:33 -07:00
|
|
|
|
2012-03-11 15:01:55 -07:00
|
|
|
TTDBG("TT SHOW\n");
|
2010-09-12 10:46:44 -07:00
|
|
|
if (tt->tooltip)
|
|
|
|
{
|
|
|
|
_elm_tooltip_reconfigure_job_start(tt);
|
2012-03-11 15:01:55 -07:00
|
|
|
TTDBG("RECURSIVE JOB\n");
|
2010-09-12 10:46:44 -07:00
|
|
|
return;
|
|
|
|
}
|
2011-07-26 02:38:23 -07:00
|
|
|
if (tt->free_size)
|
|
|
|
{
|
2012-12-29 07:57:08 -08:00
|
|
|
tt->tt_win = elm_win_add(NULL, "tooltip", ELM_WIN_TOOLTIP);
|
2011-07-26 23:43:51 -07:00
|
|
|
elm_win_override_set(tt->tt_win, EINA_TRUE);
|
2011-07-26 02:38:23 -07:00
|
|
|
tt->tt_evas = evas_object_evas_get(tt->tt_win);
|
|
|
|
tt->tooltip = edje_object_add(tt->tt_evas);
|
2012-08-05 23:43:59 -07:00
|
|
|
evas_object_size_hint_weight_set(tt->tooltip, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
|
|
|
|
evas_object_size_hint_align_set(tt->tooltip, EVAS_HINT_FILL, EVAS_HINT_FILL);
|
2011-07-26 02:38:23 -07:00
|
|
|
elm_win_resize_object_add(tt->tt_win, tt->tooltip);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
tt->tooltip = edje_object_add(tt->evas);
|
2010-09-10 17:52:33 -07:00
|
|
|
if (!tt->tooltip) return;
|
|
|
|
|
2012-08-05 23:43:59 -07:00
|
|
|
if (tt->free_size)
|
|
|
|
evas_object_layer_set(tt->tooltip, ELM_OBJECT_LAYER_TOOLTIP);
|
2010-09-11 10:01:40 -07:00
|
|
|
|
2010-09-10 17:52:33 -07:00
|
|
|
evas_object_event_callback_add
|
Tooltips: split owner/eventarea, allow subitems to have indepentent tooltips.
Now owner widget (elm_widget) is just used to listen for theme changes
and create/destroy the tooltip data. The actual mouse events operates
on all Evas_Object and is the one where tooltip data is actually
stored.
The public API is basically the same, just the event_info is now NULL
to avoid confusion.
The internal API introduces elm_object_sub_tooltip_content_cb_set()
and as the first parameter the eventarea. While this may be confusing,
as the second parameter is the actual elementary object, it is the one
that all other calls receive, like elm_object_tooltip_hide() or
elm_object_tooltip_unset(), thus it does make sense to have such order.
Also internal API, elm_widget_item_tooltip_* functions were
added. They are a variation of the widget API to handle its items, as
such the func() gets one more parameter: item, and the del_cb() gets
the item as event_info (that's why the public widget version got
event_info always NULL, to not confuse with this one!)
Widgets with items that makes sense to have tooltips got extra API:
* toolbar
* list
* gengrid
* genlist
SVN revision: 52173
2010-09-12 14:05:13 -07:00
|
|
|
(tt->eventarea, EVAS_CALLBACK_MOVE, _elm_tooltip_obj_move_cb, tt);
|
2010-09-10 17:52:33 -07:00
|
|
|
evas_object_event_callback_add
|
Tooltips: split owner/eventarea, allow subitems to have indepentent tooltips.
Now owner widget (elm_widget) is just used to listen for theme changes
and create/destroy the tooltip data. The actual mouse events operates
on all Evas_Object and is the one where tooltip data is actually
stored.
The public API is basically the same, just the event_info is now NULL
to avoid confusion.
The internal API introduces elm_object_sub_tooltip_content_cb_set()
and as the first parameter the eventarea. While this may be confusing,
as the second parameter is the actual elementary object, it is the one
that all other calls receive, like elm_object_tooltip_hide() or
elm_object_tooltip_unset(), thus it does make sense to have such order.
Also internal API, elm_widget_item_tooltip_* functions were
added. They are a variation of the widget API to handle its items, as
such the func() gets one more parameter: item, and the del_cb() gets
the item as event_info (that's why the public widget version got
event_info always NULL, to not confuse with this one!)
Widgets with items that makes sense to have tooltips got extra API:
* toolbar
* list
* gengrid
* genlist
SVN revision: 52173
2010-09-12 14:05:13 -07:00
|
|
|
(tt->eventarea, EVAS_CALLBACK_RESIZE, _elm_tooltip_obj_resize_cb, tt);
|
2010-09-10 17:52:33 -07:00
|
|
|
evas_object_event_callback_add
|
2012-03-11 15:13:24 -07:00
|
|
|
(tt->eventarea, EVAS_CALLBACK_MOUSE_MOVE, (Evas_Object_Event_Cb)_elm_tooltip_obj_mouse_move_cb, tt);
|
2010-09-10 17:52:33 -07:00
|
|
|
|
|
|
|
tt->changed_style = EINA_TRUE;
|
|
|
|
_elm_tooltip_reconfigure_job_start(tt);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_tooltip_content_del(Elm_Tooltip *tt)
|
|
|
|
{
|
|
|
|
if (!tt->content) return;
|
|
|
|
|
2012-03-11 15:21:41 -07:00
|
|
|
TTDBG("CONTENT DEL\n");
|
2010-09-10 17:52:33 -07:00
|
|
|
evas_object_event_callback_del_full
|
|
|
|
(tt->content, EVAS_CALLBACK_CHANGED_SIZE_HINTS,
|
|
|
|
_elm_tooltip_content_changed_hints_cb, tt);
|
|
|
|
evas_object_event_callback_del_full
|
|
|
|
(tt->content, EVAS_CALLBACK_DEL,
|
|
|
|
_elm_tooltip_content_del_cb, tt);
|
2011-07-24 15:05:02 -07:00
|
|
|
evas_object_hide(tt->content);
|
2010-09-10 17:52:33 -07:00
|
|
|
evas_object_del(tt->content);
|
|
|
|
tt->content = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_tooltip_hide(Elm_Tooltip *tt)
|
|
|
|
{
|
2011-10-02 21:12:40 -07:00
|
|
|
Evas_Object *del;
|
2012-03-11 15:01:55 -07:00
|
|
|
TTDBG("TT HIDE\n");
|
2010-09-10 17:52:33 -07:00
|
|
|
_elm_tooltip_show_timer_stop(tt);
|
2010-09-12 10:24:45 -07:00
|
|
|
_elm_tooltip_hide_anim_stop(tt);
|
2010-09-10 17:52:33 -07:00
|
|
|
_elm_tooltip_reconfigure_job_stop(tt);
|
|
|
|
|
|
|
|
if (!tt->tooltip) return;
|
|
|
|
if (tt->visible_lock) return;
|
|
|
|
|
|
|
|
_elm_tooltip_content_del(tt);
|
|
|
|
|
|
|
|
evas_object_event_callback_del_full
|
Tooltips: split owner/eventarea, allow subitems to have indepentent tooltips.
Now owner widget (elm_widget) is just used to listen for theme changes
and create/destroy the tooltip data. The actual mouse events operates
on all Evas_Object and is the one where tooltip data is actually
stored.
The public API is basically the same, just the event_info is now NULL
to avoid confusion.
The internal API introduces elm_object_sub_tooltip_content_cb_set()
and as the first parameter the eventarea. While this may be confusing,
as the second parameter is the actual elementary object, it is the one
that all other calls receive, like elm_object_tooltip_hide() or
elm_object_tooltip_unset(), thus it does make sense to have such order.
Also internal API, elm_widget_item_tooltip_* functions were
added. They are a variation of the widget API to handle its items, as
such the func() gets one more parameter: item, and the del_cb() gets
the item as event_info (that's why the public widget version got
event_info always NULL, to not confuse with this one!)
Widgets with items that makes sense to have tooltips got extra API:
* toolbar
* list
* gengrid
* genlist
SVN revision: 52173
2010-09-12 14:05:13 -07:00
|
|
|
(tt->eventarea, EVAS_CALLBACK_MOVE, _elm_tooltip_obj_move_cb, tt);
|
2010-09-10 17:52:33 -07:00
|
|
|
evas_object_event_callback_del_full
|
Tooltips: split owner/eventarea, allow subitems to have indepentent tooltips.
Now owner widget (elm_widget) is just used to listen for theme changes
and create/destroy the tooltip data. The actual mouse events operates
on all Evas_Object and is the one where tooltip data is actually
stored.
The public API is basically the same, just the event_info is now NULL
to avoid confusion.
The internal API introduces elm_object_sub_tooltip_content_cb_set()
and as the first parameter the eventarea. While this may be confusing,
as the second parameter is the actual elementary object, it is the one
that all other calls receive, like elm_object_tooltip_hide() or
elm_object_tooltip_unset(), thus it does make sense to have such order.
Also internal API, elm_widget_item_tooltip_* functions were
added. They are a variation of the widget API to handle its items, as
such the func() gets one more parameter: item, and the del_cb() gets
the item as event_info (that's why the public widget version got
event_info always NULL, to not confuse with this one!)
Widgets with items that makes sense to have tooltips got extra API:
* toolbar
* list
* gengrid
* genlist
SVN revision: 52173
2010-09-12 14:05:13 -07:00
|
|
|
(tt->eventarea, EVAS_CALLBACK_RESIZE, _elm_tooltip_obj_resize_cb, tt);
|
2010-09-10 17:52:33 -07:00
|
|
|
evas_object_event_callback_del_full
|
2012-03-11 15:13:24 -07:00
|
|
|
(tt->eventarea, EVAS_CALLBACK_MOUSE_MOVE, (Evas_Object_Event_Cb)_elm_tooltip_obj_mouse_move_cb, tt);
|
2010-09-10 17:52:33 -07:00
|
|
|
|
2011-10-02 21:12:40 -07:00
|
|
|
del = tt->tt_win ?: tt->tooltip;
|
2011-07-26 02:38:23 -07:00
|
|
|
|
|
|
|
tt->tt_win = NULL;
|
|
|
|
tt->tt_evas = NULL;
|
2010-09-10 17:52:33 -07:00
|
|
|
tt->tooltip = NULL;
|
2011-10-02 21:12:40 -07:00
|
|
|
evas_object_del(del);
|
2010-09-10 17:52:33 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_tooltip_reconfigure_job(void *data)
|
|
|
|
{
|
|
|
|
Elm_Tooltip *tt = data;
|
|
|
|
tt->reconfigure_job = NULL;
|
|
|
|
_elm_tooltip_reconfigure(data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_tooltip_reconfigure_job_stop(Elm_Tooltip *tt)
|
|
|
|
{
|
|
|
|
if (!tt->reconfigure_job) return;
|
|
|
|
ecore_job_del(tt->reconfigure_job);
|
|
|
|
tt->reconfigure_job = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_tooltip_reconfigure_job_start(Elm_Tooltip *tt)
|
|
|
|
{
|
2011-11-21 11:12:35 -08:00
|
|
|
if (tt->reconfigure_job) ecore_job_del(tt->reconfigure_job);
|
|
|
|
tt->reconfigure_job = ecore_job_add(_elm_tooltip_reconfigure_job, tt);
|
2010-09-10 17:52:33 -07:00
|
|
|
}
|
|
|
|
|
2010-09-12 10:24:45 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_elm_tooltip_hide_anim_cb(void *data)
|
2010-09-10 17:52:33 -07:00
|
|
|
{
|
|
|
|
Elm_Tooltip *tt = data;
|
2010-09-12 10:24:45 -07:00
|
|
|
tt->hide_timer = NULL;
|
|
|
|
_elm_tooltip_hide(tt);
|
|
|
|
return EINA_FALSE;
|
2010-09-10 17:52:33 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-09-12 10:24:45 -07:00
|
|
|
_elm_tooltip_hide_anim_start(Elm_Tooltip *tt)
|
2010-09-10 17:52:33 -07:00
|
|
|
{
|
2011-07-26 23:43:51 -07:00
|
|
|
double extra = 0;
|
2010-09-12 10:24:45 -07:00
|
|
|
if (tt->hide_timer) return;
|
2012-03-11 15:21:41 -07:00
|
|
|
TTDBG("HIDE START\n");
|
2011-07-26 23:43:51 -07:00
|
|
|
/* hide slightly faster when in window mode to look less stupid */
|
|
|
|
if ((tt->hide_timeout > 0) && tt->tt_win) extra = 0.1;
|
2010-09-12 10:24:45 -07:00
|
|
|
edje_object_signal_emit(tt->tooltip, "elm,action,hide", "elm");
|
|
|
|
tt->hide_timer = ecore_timer_add
|
2011-07-26 23:43:51 -07:00
|
|
|
(tt->hide_timeout - extra, _elm_tooltip_hide_anim_cb, tt);
|
2010-09-10 17:52:33 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-09-12 10:24:45 -07:00
|
|
|
_elm_tooltip_hide_anim_stop(Elm_Tooltip *tt)
|
2010-09-10 17:52:33 -07:00
|
|
|
{
|
2010-09-12 10:24:45 -07:00
|
|
|
if (!tt->hide_timer) return;
|
2010-09-12 10:46:44 -07:00
|
|
|
if (tt->tooltip)
|
|
|
|
edje_object_signal_emit(tt->tooltip, "elm,action,show", "elm");
|
2010-09-12 10:24:45 -07:00
|
|
|
ecore_timer_del(tt->hide_timer);
|
|
|
|
tt->hide_timer = NULL;
|
2010-09-10 17:52:33 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_tooltip_reconfigure(Elm_Tooltip *tt)
|
|
|
|
{
|
2011-07-26 02:38:23 -07:00
|
|
|
Evas_Coord ox, oy, ow, oh, px, py, tx, ty, tw, th, cw = 0, ch = 0;
|
2010-09-10 17:52:33 -07:00
|
|
|
Evas_Coord eminw, eminh, ominw, ominh;
|
2010-09-12 10:24:45 -07:00
|
|
|
double rel_x, rel_y;
|
Tooltips: split owner/eventarea, allow subitems to have indepentent tooltips.
Now owner widget (elm_widget) is just used to listen for theme changes
and create/destroy the tooltip data. The actual mouse events operates
on all Evas_Object and is the one where tooltip data is actually
stored.
The public API is basically the same, just the event_info is now NULL
to avoid confusion.
The internal API introduces elm_object_sub_tooltip_content_cb_set()
and as the first parameter the eventarea. While this may be confusing,
as the second parameter is the actual elementary object, it is the one
that all other calls receive, like elm_object_tooltip_hide() or
elm_object_tooltip_unset(), thus it does make sense to have such order.
Also internal API, elm_widget_item_tooltip_* functions were
added. They are a variation of the widget API to handle its items, as
such the func() gets one more parameter: item, and the del_cb() gets
the item as event_info (that's why the public widget version got
event_info always NULL, to not confuse with this one!)
Widgets with items that makes sense to have tooltips got extra API:
* toolbar
* list
* gengrid
* genlist
SVN revision: 52173
2010-09-12 14:05:13 -07:00
|
|
|
Eina_Bool inside_eventarea;
|
2010-09-10 17:52:33 -07:00
|
|
|
|
|
|
|
_elm_tooltip_reconfigure_job_stop(tt);
|
|
|
|
|
2010-09-12 10:24:45 -07:00
|
|
|
if (tt->hide_timer) return;
|
2010-09-10 17:52:33 -07:00
|
|
|
if (!tt->tooltip) return;
|
|
|
|
if (tt->changed_style)
|
|
|
|
{
|
|
|
|
const char *style = tt->style ? tt->style : "default";
|
|
|
|
const char *str;
|
2013-02-25 20:26:22 -08:00
|
|
|
if (!_elm_theme_object_set(tt->tt_win ? NULL : tt->owner, tt->tooltip,
|
|
|
|
"tooltip", "base", style))
|
2010-09-10 17:52:33 -07:00
|
|
|
{
|
|
|
|
ERR("Could not apply the theme to the tooltip! style=%s", style);
|
2011-07-26 02:38:23 -07:00
|
|
|
if (tt->tt_win) evas_object_del(tt->tt_win);
|
|
|
|
else evas_object_del(tt->tooltip);
|
|
|
|
tt->tt_win = NULL;
|
|
|
|
tt->tt_evas = NULL;
|
2010-09-10 17:52:33 -07:00
|
|
|
tt->tooltip = NULL;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-09-12 10:24:45 -07:00
|
|
|
tt->rel_pos.x = 0;
|
|
|
|
tt->rel_pos.y = 0;
|
|
|
|
|
2010-09-10 17:52:33 -07:00
|
|
|
tt->pad.x = 0;
|
|
|
|
tt->pad.y = 0;
|
|
|
|
tt->pad.bx = 0;
|
|
|
|
tt->pad.by = 0;
|
2010-09-12 10:24:45 -07:00
|
|
|
tt->hide_timeout = 0.0;
|
2011-07-28 03:08:07 -07:00
|
|
|
|
|
|
|
str = edje_object_data_get(tt->tooltip, "transparent");
|
2011-07-26 23:43:51 -07:00
|
|
|
if (tt->tt_win)
|
|
|
|
{ /* FIXME: hardcoded here is bad */
|
2011-07-28 03:08:07 -07:00
|
|
|
if (str && (!strcmp(str, "enabled")))
|
2011-07-27 12:09:50 -07:00
|
|
|
{
|
2012-08-05 23:43:59 -07:00
|
|
|
evas_object_hide(tt->tt_win);
|
2011-07-27 12:09:50 -07:00
|
|
|
elm_win_alpha_set(tt->tt_win, EINA_TRUE);
|
2012-08-05 23:43:59 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
|
|
|
ecore_x_window_shape_input_rectangle_set(elm_win_xwindow_get(tt->tt_win), 0, 0, 0, 0);
|
|
|
|
#endif
|
|
|
|
evas_object_show(tt->tt_win);
|
2011-07-27 12:09:50 -07:00
|
|
|
}
|
2011-07-26 23:43:51 -07:00
|
|
|
else
|
2011-07-27 12:09:50 -07:00
|
|
|
{
|
2012-08-05 23:43:59 -07:00
|
|
|
evas_object_hide(tt->tt_win);
|
2011-07-27 12:09:50 -07:00
|
|
|
elm_win_alpha_set(tt->tt_win, EINA_FALSE);
|
2012-08-05 23:43:59 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
|
|
|
ecore_x_window_shape_input_rectangle_set(elm_win_xwindow_get(tt->tt_win), 0, 0, 0, 0);
|
|
|
|
#endif
|
|
|
|
evas_object_show(tt->tt_win);
|
2011-07-27 12:09:50 -07:00
|
|
|
}
|
2011-07-26 23:43:51 -07:00
|
|
|
}
|
2010-09-10 17:52:33 -07:00
|
|
|
|
|
|
|
str = edje_object_data_get(tt->tooltip, "pad_x");
|
|
|
|
if (str) tt->pad.x = atoi(str);
|
|
|
|
str = edje_object_data_get(tt->tooltip, "pad_y");
|
|
|
|
if (str) tt->pad.y = atoi(str);
|
|
|
|
|
|
|
|
str = edje_object_data_get(tt->tooltip, "pad_border_x");
|
|
|
|
if (str) tt->pad.bx = atoi(str);
|
|
|
|
str = edje_object_data_get(tt->tooltip, "pad_border_y");
|
|
|
|
if (str) tt->pad.by = atoi(str);
|
|
|
|
|
2010-09-12 10:24:45 -07:00
|
|
|
str = edje_object_data_get(tt->tooltip, "hide_timeout");
|
|
|
|
if (str)
|
|
|
|
{
|
2012-04-25 20:32:18 -07:00
|
|
|
tt->hide_timeout = _elm_atof(str);
|
2010-09-12 10:24:45 -07:00
|
|
|
if (tt->hide_timeout < 0.0) tt->hide_timeout = 0.0;
|
|
|
|
}
|
|
|
|
|
2010-09-10 17:52:33 -07:00
|
|
|
evas_object_pass_events_set(tt->tooltip, EINA_TRUE);
|
|
|
|
tt->changed_style = EINA_FALSE;
|
|
|
|
if (tt->tooltip)
|
2011-07-27 18:32:40 -07:00
|
|
|
edje_object_part_swallow(tt->tooltip, "elm.swallow.content",
|
2011-07-26 02:38:23 -07:00
|
|
|
tt->content);
|
2010-09-12 10:24:45 -07:00
|
|
|
|
|
|
|
edje_object_signal_emit(tt->tooltip, "elm,action,show", "elm");
|
2010-09-10 17:52:33 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!tt->content)
|
|
|
|
{
|
2011-07-26 02:38:23 -07:00
|
|
|
tt->content = tt->func((void *)tt->data, tt->owner, tt->tt_win ? : tt->owner);
|
2010-09-10 17:52:33 -07:00
|
|
|
if (!tt->content)
|
|
|
|
{
|
|
|
|
WRN("could not create tooltip content!");
|
2011-07-26 02:38:23 -07:00
|
|
|
if (tt->tt_win) evas_object_del(tt->tt_win);
|
|
|
|
else evas_object_del(tt->tooltip);
|
|
|
|
|
|
|
|
tt->tt_win = NULL;
|
|
|
|
tt->tt_evas = NULL;
|
2010-09-10 17:52:33 -07:00
|
|
|
tt->tooltip = NULL;
|
|
|
|
return;
|
|
|
|
}
|
2011-07-26 02:38:23 -07:00
|
|
|
evas_object_show(tt->content);
|
2010-09-11 10:01:40 -07:00
|
|
|
evas_object_layer_set(tt->content, ELM_OBJECT_LAYER_TOOLTIP);
|
2010-09-10 17:52:33 -07:00
|
|
|
evas_object_pass_events_set(tt->content, EINA_TRUE);
|
|
|
|
edje_object_part_swallow
|
|
|
|
(tt->tooltip, "elm.swallow.content", tt->content);
|
2011-07-26 02:38:23 -07:00
|
|
|
evas_object_event_callback_add(tt->content, EVAS_CALLBACK_CHANGED_SIZE_HINTS,
|
2010-09-10 17:52:33 -07:00
|
|
|
_elm_tooltip_content_changed_hints_cb, tt);
|
2011-07-26 02:38:23 -07:00
|
|
|
evas_object_event_callback_add(tt->content, EVAS_CALLBACK_DEL,
|
2010-09-10 17:52:33 -07:00
|
|
|
_elm_tooltip_content_del_cb, tt);
|
|
|
|
|
|
|
|
}
|
2011-11-23 20:16:03 -08:00
|
|
|
TTDBG("*******RECALC\n");
|
2010-09-10 17:52:33 -07:00
|
|
|
evas_object_size_hint_min_get(tt->content, &ominw, &ominh);
|
|
|
|
edje_object_size_min_get(tt->tooltip, &eminw, &eminh);
|
|
|
|
|
2011-07-31 07:29:04 -07:00
|
|
|
if (eminw && (ominw < eminw)) ominw = eminw;
|
2013-01-08 20:57:54 -08:00
|
|
|
if (eminh && (ominh < eminh)) ominh = eminh;
|
2010-09-10 17:52:33 -07:00
|
|
|
|
2010-09-12 10:24:45 -07:00
|
|
|
if (ominw < 1) ominw = 10; /* at least it is noticeable */
|
|
|
|
if (ominh < 1) ominh = 10; /* at least it is noticeable */
|
|
|
|
|
2011-07-26 02:38:23 -07:00
|
|
|
edje_object_size_min_restricted_calc(tt->tooltip, &tw, &th, ominw, ominh);
|
2011-11-23 20:52:16 -08:00
|
|
|
TTDBG("TTSIZE: tw=%d,th=%d,ominw=%d,ominh=%d\n", tw, th, ominw, ominh);
|
2010-09-10 17:52:33 -07:00
|
|
|
|
2011-07-26 02:38:23 -07:00
|
|
|
if (tt->tt_win)
|
2011-11-23 20:52:16 -08:00
|
|
|
elm_win_screen_size_get(elm_object_top_widget_get(tt->owner), NULL, NULL, &cw, &ch);
|
2011-07-26 02:38:23 -07:00
|
|
|
if (!cw)
|
|
|
|
evas_output_size_get(tt->tt_evas ?: tt->evas, &cw, &ch);
|
2011-11-23 20:52:16 -08:00
|
|
|
TTDBG("SCREEN: cw=%d,ch=%d\n", cw, ch);
|
2010-09-10 17:52:33 -07:00
|
|
|
|
Tooltips: split owner/eventarea, allow subitems to have indepentent tooltips.
Now owner widget (elm_widget) is just used to listen for theme changes
and create/destroy the tooltip data. The actual mouse events operates
on all Evas_Object and is the one where tooltip data is actually
stored.
The public API is basically the same, just the event_info is now NULL
to avoid confusion.
The internal API introduces elm_object_sub_tooltip_content_cb_set()
and as the first parameter the eventarea. While this may be confusing,
as the second parameter is the actual elementary object, it is the one
that all other calls receive, like elm_object_tooltip_hide() or
elm_object_tooltip_unset(), thus it does make sense to have such order.
Also internal API, elm_widget_item_tooltip_* functions were
added. They are a variation of the widget API to handle its items, as
such the func() gets one more parameter: item, and the del_cb() gets
the item as event_info (that's why the public widget version got
event_info always NULL, to not confuse with this one!)
Widgets with items that makes sense to have tooltips got extra API:
* toolbar
* list
* gengrid
* genlist
SVN revision: 52173
2010-09-12 14:05:13 -07:00
|
|
|
evas_object_geometry_get(tt->eventarea, &ox, &oy, &ow, &oh);
|
2011-11-23 20:16:03 -08:00
|
|
|
TTDBG("EVENTAREA: ox=%d,oy=%d,ow=%d,oh=%d\n", ox, oy, ow, oh);
|
2010-09-10 17:52:33 -07:00
|
|
|
|
2011-07-26 23:43:51 -07:00
|
|
|
if (tt->tt_win)
|
|
|
|
{
|
|
|
|
int x, y;
|
2011-11-23 18:42:46 -08:00
|
|
|
Evas_Object *win = elm_object_top_widget_get(tt->owner);
|
2011-07-26 02:38:23 -07:00
|
|
|
#ifdef HAVE_ELEMENTARY_X
|
2011-11-23 18:42:46 -08:00
|
|
|
Ecore_X_Window xwin = elm_win_xwindow_get(win);
|
2011-07-26 23:43:51 -07:00
|
|
|
ecore_x_pointer_xy_get(xwin, &px, &py);
|
2011-07-26 02:38:23 -07:00
|
|
|
#endif
|
2011-11-23 18:42:46 -08:00
|
|
|
elm_win_screen_position_get(win, &x, &y);
|
2011-07-26 23:43:51 -07:00
|
|
|
ox += x;
|
2011-11-23 20:16:03 -08:00
|
|
|
if (px) px += x;
|
2011-07-26 23:43:51 -07:00
|
|
|
oy += y;
|
2011-11-23 20:16:03 -08:00
|
|
|
if (py) py += y;
|
2011-07-26 23:43:51 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
evas_pointer_canvas_xy_get(tt->evas, &px, &py);
|
2011-11-23 20:16:03 -08:00
|
|
|
TTDBG("POINTER: px=%d,py=%d\n", px, py);
|
2011-07-26 23:43:51 -07:00
|
|
|
inside_eventarea = ((px >= ox) && (py >= oy) &&
|
|
|
|
(px <= ox + ow) && (py <= oy + oh));
|
Tooltips: split owner/eventarea, allow subitems to have indepentent tooltips.
Now owner widget (elm_widget) is just used to listen for theme changes
and create/destroy the tooltip data. The actual mouse events operates
on all Evas_Object and is the one where tooltip data is actually
stored.
The public API is basically the same, just the event_info is now NULL
to avoid confusion.
The internal API introduces elm_object_sub_tooltip_content_cb_set()
and as the first parameter the eventarea. While this may be confusing,
as the second parameter is the actual elementary object, it is the one
that all other calls receive, like elm_object_tooltip_hide() or
elm_object_tooltip_unset(), thus it does make sense to have such order.
Also internal API, elm_widget_item_tooltip_* functions were
added. They are a variation of the widget API to handle its items, as
such the func() gets one more parameter: item, and the del_cb() gets
the item as event_info (that's why the public widget version got
event_info always NULL, to not confuse with this one!)
Widgets with items that makes sense to have tooltips got extra API:
* toolbar
* list
* gengrid
* genlist
SVN revision: 52173
2010-09-12 14:05:13 -07:00
|
|
|
if (inside_eventarea)
|
2010-09-10 17:52:33 -07:00
|
|
|
{
|
2011-11-23 20:52:16 -08:00
|
|
|
/* try to position bottom right corner at pointer */
|
2011-07-27 18:32:40 -07:00
|
|
|
tx = px - tw;
|
|
|
|
ty = py - th;
|
2011-11-23 20:52:16 -08:00
|
|
|
TTDBG("INIT (EVENTAREA)\n");
|
2010-09-10 17:52:33 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2011-11-23 20:52:16 -08:00
|
|
|
/* try centered on middle of eventarea */
|
2010-09-10 17:52:33 -07:00
|
|
|
tx = ox + (ow / 2) - (tw / 2);
|
2011-07-27 18:32:40 -07:00
|
|
|
if (0 > (th - oy - oh)) ty = oy + th;
|
|
|
|
else ty = oy - oh;
|
2011-11-23 20:52:16 -08:00
|
|
|
TTDBG("INIT (INTERPRETED)\n");
|
2010-09-10 17:52:33 -07:00
|
|
|
}
|
2011-11-23 20:16:03 -08:00
|
|
|
TTDBG("ADJUST (POINTER): tx=%d,ty=%d\n", tx, ty);
|
2012-12-02 04:41:09 -08:00
|
|
|
if ((tx < 0) || (tx + tw > cw))
|
2011-07-27 00:12:28 -07:00
|
|
|
{
|
2011-11-23 20:52:16 -08:00
|
|
|
/* if we're offscreen, try to flip over the Y axis */
|
2012-12-02 04:41:09 -08:00
|
|
|
if ((tx < 0) && (abs((tx + 2 * tw) - cw) < abs(tx)))
|
2011-07-27 18:32:40 -07:00
|
|
|
tx += tw;
|
2012-12-02 04:41:09 -08:00
|
|
|
else if (tx + tw > cw)
|
|
|
|
{
|
|
|
|
int test_x = tx - tw;
|
|
|
|
|
|
|
|
if ((test_x >= 0) || (tx + tw - cw > abs(test_x)))
|
|
|
|
tx -= tw;
|
|
|
|
}
|
2011-07-27 00:12:28 -07:00
|
|
|
}
|
2011-11-23 20:52:16 -08:00
|
|
|
else if ((tx > px) && (px > tw))
|
2011-07-27 00:12:28 -07:00
|
|
|
{
|
2011-07-27 18:32:40 -07:00
|
|
|
if (tx + tw < cw)
|
|
|
|
tx += tw;
|
2011-07-27 00:12:28 -07:00
|
|
|
}
|
2012-12-02 04:41:09 -08:00
|
|
|
if ((ty < 0) || (ty + th > ch))
|
2011-07-27 00:12:28 -07:00
|
|
|
{
|
2011-11-23 20:52:16 -08:00
|
|
|
/* if we're offscreen, try to flip over the X axis */
|
2012-12-02 04:41:09 -08:00
|
|
|
if ((ty < 0) && (abs((ty + 2 * th) - ch) < abs(ty)))
|
2011-07-27 18:32:40 -07:00
|
|
|
ty += th;
|
2012-12-02 04:41:09 -08:00
|
|
|
else if (ty + th > ch)
|
|
|
|
{
|
|
|
|
int test_y = ty - th;
|
|
|
|
|
|
|
|
if ((test_y >= 0) || (ty + th - ch > abs(test_y)))
|
|
|
|
ty -= th;
|
|
|
|
}
|
2011-07-27 00:12:28 -07:00
|
|
|
}
|
2011-11-23 20:52:16 -08:00
|
|
|
else if ((ty > py) && (py > th))
|
2011-07-27 00:12:28 -07:00
|
|
|
{
|
2011-07-27 18:32:40 -07:00
|
|
|
if (ty + th < ch)
|
|
|
|
ty += th;
|
|
|
|
}
|
2011-11-23 20:16:03 -08:00
|
|
|
TTDBG("ADJUST (FLIP): tx=%d,ty=%d\n", tx, ty);
|
2011-07-27 18:32:40 -07:00
|
|
|
if (inside_eventarea)
|
|
|
|
{
|
|
|
|
if ((tx == px) && ((tx + tw + tt->pad.x < cw) || (tx + tw > cw))) tx += tt->pad.x;
|
|
|
|
else if ((tx - tt->pad.x > 0) || (tx < 0)) tx -= tt->pad.x;
|
|
|
|
if ((ty == py) && ((ty + th + tt->pad.y < ch) || (ty + th > ch))) ty += tt->pad.y;
|
|
|
|
else if ((ty - tt->pad.y > 0) || (ty < 0)) ty -= tt->pad.y;
|
2011-07-27 00:12:28 -07:00
|
|
|
}
|
2011-11-23 20:16:03 -08:00
|
|
|
TTDBG("PAD: tx=%d,ty=%d\n", tx, ty);
|
2010-09-10 17:52:33 -07:00
|
|
|
if (tt->pad.bx * 2 + tw < cw)
|
|
|
|
{
|
|
|
|
if (tx < tt->pad.bx) tx = tt->pad.bx;
|
2011-07-27 18:32:40 -07:00
|
|
|
else if ((tx >= tw) && (tx + tt->pad.bx <= cw)) tx += tt->pad.bx;
|
|
|
|
else if (tx - tt->pad.bx >= 0) tx -= tt->pad.bx;
|
2010-09-10 17:52:33 -07:00
|
|
|
}
|
2011-07-27 18:32:40 -07:00
|
|
|
else if (tx < 0) tx -= tt->pad.bx;
|
|
|
|
else if (tx > cw) tx += tt->pad.bx;
|
2010-09-10 17:52:33 -07:00
|
|
|
if (tt->pad.by * 2 + th < ch)
|
|
|
|
{
|
|
|
|
if (ty < tt->pad.by) ty = tt->pad.by;
|
2011-07-27 18:32:40 -07:00
|
|
|
else if ((ty >= th) && (ty + tt->pad.by <= ch)) ty += tt->pad.by;
|
|
|
|
else if (ty - tt->pad.by >= 0) ty -= tt->pad.by;
|
2010-09-10 17:52:33 -07:00
|
|
|
}
|
2011-07-27 18:32:40 -07:00
|
|
|
else if (ty < 0) ty -= tt->pad.by;
|
|
|
|
else if (ty > ch) ty += tt->pad.by;
|
2011-11-23 20:16:03 -08:00
|
|
|
TTDBG("PAD (BORDER): tx=%d,ty=%d\n", tx, ty);
|
2012-03-11 14:56:36 -07:00
|
|
|
if (((tx < 0) && (tw < cw)) || ((ty < 0) && (th < ch)))
|
2011-11-23 20:52:16 -08:00
|
|
|
{
|
|
|
|
TTDBG("POSITIONING FAILED! THIS IS A BUG SOMEWHERE!\n");
|
2012-03-11 14:50:02 -07:00
|
|
|
abort();
|
2011-11-23 20:52:16 -08:00
|
|
|
return;
|
|
|
|
}
|
2011-07-26 02:38:23 -07:00
|
|
|
evas_object_move(tt->tt_win ? : tt->tooltip, tx, ty);
|
|
|
|
evas_object_resize(tt->tt_win ? : tt->tooltip, tw, th);
|
2012-03-11 15:21:41 -07:00
|
|
|
TTDBG("FINAL: tx=%d,ty=%d,tw=%d,th=%d\n", tx, ty, tw, th);
|
2010-09-10 17:52:33 -07:00
|
|
|
evas_object_show(tt->tooltip);
|
2010-09-12 10:24:45 -07:00
|
|
|
|
Tooltips: split owner/eventarea, allow subitems to have indepentent tooltips.
Now owner widget (elm_widget) is just used to listen for theme changes
and create/destroy the tooltip data. The actual mouse events operates
on all Evas_Object and is the one where tooltip data is actually
stored.
The public API is basically the same, just the event_info is now NULL
to avoid confusion.
The internal API introduces elm_object_sub_tooltip_content_cb_set()
and as the first parameter the eventarea. While this may be confusing,
as the second parameter is the actual elementary object, it is the one
that all other calls receive, like elm_object_tooltip_hide() or
elm_object_tooltip_unset(), thus it does make sense to have such order.
Also internal API, elm_widget_item_tooltip_* functions were
added. They are a variation of the widget API to handle its items, as
such the func() gets one more parameter: item, and the del_cb() gets
the item as event_info (that's why the public widget version got
event_info always NULL, to not confuse with this one!)
Widgets with items that makes sense to have tooltips got extra API:
* toolbar
* list
* gengrid
* genlist
SVN revision: 52173
2010-09-12 14:05:13 -07:00
|
|
|
if (inside_eventarea)
|
2010-09-12 10:24:45 -07:00
|
|
|
{
|
|
|
|
rel_x = (px - tx) / (double)tw;
|
|
|
|
rel_y = (py - ty) / (double)th;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
rel_x = (ox + (ow / 2) - tx) / (double)tw;
|
|
|
|
rel_y = (oy + (oh / 2) - ty) / (double)th;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define FDIF(a, b) (fabs((a) - (b)) > 0.0001)
|
2010-10-22 14:41:22 -07:00
|
|
|
if ((FDIF(rel_x, tt->rel_pos.x)) || (FDIF(rel_y, tt->rel_pos.y)))
|
2010-09-12 10:24:45 -07:00
|
|
|
{
|
|
|
|
Edje_Message_Float_Set *msg;
|
|
|
|
|
|
|
|
msg = alloca(sizeof(Edje_Message_Float_Set) + sizeof(double));
|
|
|
|
msg->count = 2;
|
|
|
|
msg->val[0] = rel_x;
|
|
|
|
msg->val[1] = rel_y;
|
|
|
|
tt->rel_pos.x = rel_x;
|
|
|
|
tt->rel_pos.y = rel_y;
|
|
|
|
|
|
|
|
edje_object_message_send(tt->tooltip, EDJE_MESSAGE_FLOAT_SET, 1, msg);
|
|
|
|
}
|
|
|
|
#undef FDIF
|
2010-09-10 17:52:33 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_tooltip_show_timer_stop(Elm_Tooltip *tt)
|
|
|
|
{
|
|
|
|
if (!tt->show_timer) return;
|
|
|
|
ecore_timer_del(tt->show_timer);
|
|
|
|
tt->show_timer = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_elm_tooltip_timer_show_cb(void *data)
|
|
|
|
{
|
|
|
|
Elm_Tooltip *tt = data;
|
|
|
|
tt->show_timer = NULL;
|
|
|
|
_elm_tooltip_show(tt);
|
|
|
|
return ECORE_CALLBACK_CANCEL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_tooltip_obj_mouse_in_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
|
|
|
|
{
|
|
|
|
Elm_Tooltip *tt = data;
|
|
|
|
|
2010-09-12 10:24:45 -07:00
|
|
|
_elm_tooltip_hide_anim_stop(tt);
|
|
|
|
|
2010-09-10 17:52:33 -07:00
|
|
|
if ((tt->show_timer) || (tt->tooltip)) return;
|
|
|
|
|
2012-03-11 15:01:55 -07:00
|
|
|
tt->show_timer = ecore_timer_add(_elm_config->tooltip_delay, _elm_tooltip_timer_show_cb, tt);
|
|
|
|
TTDBG("MOUSE IN\n");
|
2010-09-10 17:52:33 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-07-26 23:43:51 -07:00
|
|
|
_elm_tooltip_obj_mouse_out_cb(Elm_Tooltip *tt, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, Evas_Event_Mouse_Out *event __UNUSED__)
|
2010-09-10 17:52:33 -07:00
|
|
|
{
|
2010-09-12 10:24:45 -07:00
|
|
|
if (tt->visible_lock) return;
|
|
|
|
|
|
|
|
if (!tt->tooltip)
|
|
|
|
{
|
|
|
|
_elm_tooltip_show_timer_stop(tt);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
_elm_tooltip_hide_anim_start(tt);
|
2012-03-11 15:01:55 -07:00
|
|
|
TTDBG("MOUSE OUT\n");
|
2010-09-10 17:52:33 -07:00
|
|
|
}
|
|
|
|
|
2011-06-15 07:07:28 -07:00
|
|
|
static void _elm_tooltip_obj_free_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__);
|
2010-09-16 16:44:02 -07:00
|
|
|
|
2010-09-10 17:52:33 -07:00
|
|
|
static void
|
2010-09-16 16:44:02 -07:00
|
|
|
_elm_tooltip_unset(Elm_Tooltip *tt)
|
2010-09-10 17:52:33 -07:00
|
|
|
{
|
2010-09-16 16:44:02 -07:00
|
|
|
tt->visible_lock = EINA_FALSE;
|
|
|
|
_elm_tooltip_hide(tt);
|
|
|
|
_elm_tooltip_data_clean(tt);
|
|
|
|
|
|
|
|
if (tt->eventarea)
|
|
|
|
{
|
|
|
|
evas_object_event_callback_del_full
|
|
|
|
(tt->eventarea, EVAS_CALLBACK_MOUSE_IN,
|
|
|
|
_elm_tooltip_obj_mouse_in_cb, tt);
|
|
|
|
evas_object_event_callback_del_full
|
|
|
|
(tt->eventarea, EVAS_CALLBACK_MOUSE_OUT,
|
2011-07-26 23:43:51 -07:00
|
|
|
(Evas_Object_Event_Cb)_elm_tooltip_obj_mouse_out_cb, tt);
|
2010-09-16 16:44:02 -07:00
|
|
|
evas_object_event_callback_del_full
|
2011-06-15 07:07:28 -07:00
|
|
|
(tt->eventarea, EVAS_CALLBACK_FREE, _elm_tooltip_obj_free_cb, tt);
|
2010-09-16 16:44:02 -07:00
|
|
|
|
|
|
|
evas_object_data_del(tt->eventarea, _tooltip_key);
|
|
|
|
}
|
|
|
|
if (tt->owner)
|
|
|
|
{
|
|
|
|
evas_object_event_callback_del_full
|
2011-06-15 07:07:28 -07:00
|
|
|
(tt->owner, EVAS_CALLBACK_FREE, _elm_tooltip_obj_free_cb, tt);
|
2010-09-16 16:44:02 -07:00
|
|
|
elm_widget_tooltip_del(tt->owner, tt);
|
|
|
|
}
|
|
|
|
|
|
|
|
eina_stringshare_del(tt->style);
|
|
|
|
free(tt);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-06-15 07:07:28 -07:00
|
|
|
_elm_tooltip_obj_free_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
|
2010-09-16 16:44:02 -07:00
|
|
|
{
|
|
|
|
Elm_Tooltip *tt = data;
|
|
|
|
if (tt->eventarea == obj) tt->eventarea = NULL;
|
|
|
|
if (tt->owner == obj) tt->owner = NULL;
|
|
|
|
_elm_tooltip_unset(tt);
|
2010-09-10 17:52:33 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static Evas_Object *
|
2011-07-26 02:38:23 -07:00
|
|
|
_elm_tooltip_label_create(void *data, Evas_Object *obj __UNUSED__, Evas_Object *tooltip)
|
2010-09-10 17:52:33 -07:00
|
|
|
{
|
2011-07-26 02:38:23 -07:00
|
|
|
Evas_Object *label = elm_label_add(tooltip);
|
2010-09-10 17:52:33 -07:00
|
|
|
if (!label)
|
|
|
|
return NULL;
|
2010-09-12 10:24:45 -07:00
|
|
|
elm_object_style_set(label, "tooltip");
|
2011-06-28 23:41:31 -07:00
|
|
|
elm_object_text_set(label, data);
|
2010-09-10 17:52:33 -07:00
|
|
|
return label;
|
|
|
|
}
|
|
|
|
|
2011-10-19 07:17:14 -07:00
|
|
|
static Evas_Object *
|
|
|
|
_elm_tooltip_trans_label_create(void *data, Evas_Object *obj __UNUSED__, Evas_Object *tooltip)
|
|
|
|
{
|
|
|
|
Evas_Object *label = elm_label_add(tooltip);
|
|
|
|
const char **text = data;
|
|
|
|
if (!label)
|
|
|
|
return NULL;
|
|
|
|
elm_object_style_set(label, "tooltip");
|
|
|
|
elm_object_domain_translatable_text_set(label, text[0], text[1]);
|
|
|
|
return label;
|
|
|
|
}
|
|
|
|
|
2010-09-10 17:52:33 -07:00
|
|
|
static void
|
|
|
|
_elm_tooltip_label_del_cb(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
|
|
|
|
{
|
|
|
|
eina_stringshare_del(data);
|
|
|
|
}
|
|
|
|
|
2011-10-19 07:17:14 -07:00
|
|
|
static void
|
|
|
|
_elm_tooltip_trans_label_del_cb(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
|
|
|
|
{
|
|
|
|
const char **text = data;
|
|
|
|
eina_stringshare_del(text[0]);
|
|
|
|
eina_stringshare_del(text[1]);
|
|
|
|
free(text);
|
|
|
|
}
|
|
|
|
|
2010-09-10 17:52:33 -07:00
|
|
|
static void
|
|
|
|
_elm_tooltip_data_clean(Elm_Tooltip *tt)
|
|
|
|
{
|
Tooltips: split owner/eventarea, allow subitems to have indepentent tooltips.
Now owner widget (elm_widget) is just used to listen for theme changes
and create/destroy the tooltip data. The actual mouse events operates
on all Evas_Object and is the one where tooltip data is actually
stored.
The public API is basically the same, just the event_info is now NULL
to avoid confusion.
The internal API introduces elm_object_sub_tooltip_content_cb_set()
and as the first parameter the eventarea. While this may be confusing,
as the second parameter is the actual elementary object, it is the one
that all other calls receive, like elm_object_tooltip_hide() or
elm_object_tooltip_unset(), thus it does make sense to have such order.
Also internal API, elm_widget_item_tooltip_* functions were
added. They are a variation of the widget API to handle its items, as
such the func() gets one more parameter: item, and the del_cb() gets
the item as event_info (that's why the public widget version got
event_info always NULL, to not confuse with this one!)
Widgets with items that makes sense to have tooltips got extra API:
* toolbar
* list
* gengrid
* genlist
SVN revision: 52173
2010-09-12 14:05:13 -07:00
|
|
|
if (tt->del_cb) tt->del_cb((void *)tt->data, tt->owner, NULL);
|
2010-09-10 17:52:33 -07:00
|
|
|
|
|
|
|
_elm_tooltip_content_del(tt);
|
|
|
|
|
|
|
|
tt->data = NULL;
|
|
|
|
tt->del_cb = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Notify tooltip should recalculate its theme.
|
|
|
|
* @internal
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
elm_tooltip_theme(Elm_Tooltip *tt)
|
|
|
|
{
|
|
|
|
if (!tt->tooltip) return;
|
|
|
|
tt->changed_style = EINA_TRUE;
|
|
|
|
_elm_tooltip_reconfigure_job_start(tt);
|
|
|
|
}
|
|
|
|
|
Tooltips: split owner/eventarea, allow subitems to have indepentent tooltips.
Now owner widget (elm_widget) is just used to listen for theme changes
and create/destroy the tooltip data. The actual mouse events operates
on all Evas_Object and is the one where tooltip data is actually
stored.
The public API is basically the same, just the event_info is now NULL
to avoid confusion.
The internal API introduces elm_object_sub_tooltip_content_cb_set()
and as the first parameter the eventarea. While this may be confusing,
as the second parameter is the actual elementary object, it is the one
that all other calls receive, like elm_object_tooltip_hide() or
elm_object_tooltip_unset(), thus it does make sense to have such order.
Also internal API, elm_widget_item_tooltip_* functions were
added. They are a variation of the widget API to handle its items, as
such the func() gets one more parameter: item, and the del_cb() gets
the item as event_info (that's why the public widget version got
event_info always NULL, to not confuse with this one!)
Widgets with items that makes sense to have tooltips got extra API:
* toolbar
* list
* gengrid
* genlist
SVN revision: 52173
2010-09-12 14:05:13 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the content to be shown in the tooltip object for specific event area.
|
|
|
|
*
|
|
|
|
* Setup the tooltip to object. The object @a eventarea can have only
|
|
|
|
* one tooltip, so any previous tooltip data is removed. @p func(with
|
|
|
|
* @p data) will be called every time that need show the tooltip and
|
|
|
|
* it should return a valid Evas_Object. This object is then managed
|
|
|
|
* fully by tooltip system and is deleted when the tooltip is gone.
|
|
|
|
*
|
|
|
|
* This is an internal function that is used by objects with sub-items
|
|
|
|
* that want to provide different tooltips for each of them. The @a
|
|
|
|
* owner object should be an elm_widget and will be used to track
|
|
|
|
* theme changes and to feed @a func and @a del_cb. The @a eventarea
|
|
|
|
* may be any object and is the one that should be used later on with
|
|
|
|
* elm_object_tooltip apis, such as elm_object_tooltip_hide(),
|
|
|
|
* elm_object_tooltip_show() or elm_object_tooltip_unset().
|
|
|
|
*
|
|
|
|
* @param eventarea the object being attached a tooltip.
|
|
|
|
* @param owner the elm_widget that owns this object, will be used to
|
|
|
|
* track theme changes and to be used in @a func or @a del_cb.
|
|
|
|
* @param func the function used to create the tooltip contents. The
|
|
|
|
* @a Evas_Object parameters will receive @a owner as value.
|
|
|
|
* @param data what to provide to @a func as callback data/context.
|
|
|
|
* @param del_cb called when data is not needed anymore, either when
|
2011-08-03 12:07:43 -07:00
|
|
|
* another callback replaces @p func, the tooltip is unset with
|
Tooltips: split owner/eventarea, allow subitems to have indepentent tooltips.
Now owner widget (elm_widget) is just used to listen for theme changes
and create/destroy the tooltip data. The actual mouse events operates
on all Evas_Object and is the one where tooltip data is actually
stored.
The public API is basically the same, just the event_info is now NULL
to avoid confusion.
The internal API introduces elm_object_sub_tooltip_content_cb_set()
and as the first parameter the eventarea. While this may be confusing,
as the second parameter is the actual elementary object, it is the one
that all other calls receive, like elm_object_tooltip_hide() or
elm_object_tooltip_unset(), thus it does make sense to have such order.
Also internal API, elm_widget_item_tooltip_* functions were
added. They are a variation of the widget API to handle its items, as
such the func() gets one more parameter: item, and the del_cb() gets
the item as event_info (that's why the public widget version got
event_info always NULL, to not confuse with this one!)
Widgets with items that makes sense to have tooltips got extra API:
* toolbar
* list
* gengrid
* genlist
SVN revision: 52173
2010-09-12 14:05:13 -07:00
|
|
|
* elm_object_tooltip_unset() or the owner object @a obj
|
|
|
|
* dies. This callback receives as the first parameter the
|
|
|
|
* given @a data, and @c event_info is NULL.
|
|
|
|
*
|
|
|
|
* @internal
|
|
|
|
* @ingroup Tooltips
|
|
|
|
*/
|
2010-09-13 00:56:23 -07:00
|
|
|
void
|
Tooltips: split owner/eventarea, allow subitems to have indepentent tooltips.
Now owner widget (elm_widget) is just used to listen for theme changes
and create/destroy the tooltip data. The actual mouse events operates
on all Evas_Object and is the one where tooltip data is actually
stored.
The public API is basically the same, just the event_info is now NULL
to avoid confusion.
The internal API introduces elm_object_sub_tooltip_content_cb_set()
and as the first parameter the eventarea. While this may be confusing,
as the second parameter is the actual elementary object, it is the one
that all other calls receive, like elm_object_tooltip_hide() or
elm_object_tooltip_unset(), thus it does make sense to have such order.
Also internal API, elm_widget_item_tooltip_* functions were
added. They are a variation of the widget API to handle its items, as
such the func() gets one more parameter: item, and the del_cb() gets
the item as event_info (that's why the public widget version got
event_info always NULL, to not confuse with this one!)
Widgets with items that makes sense to have tooltips got extra API:
* toolbar
* list
* gengrid
* genlist
SVN revision: 52173
2010-09-12 14:05:13 -07:00
|
|
|
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)
|
2010-09-10 17:52:33 -07:00
|
|
|
{
|
|
|
|
Elm_Tooltip *tt = NULL;
|
|
|
|
Eina_Bool just_created;
|
|
|
|
|
Tooltips: split owner/eventarea, allow subitems to have indepentent tooltips.
Now owner widget (elm_widget) is just used to listen for theme changes
and create/destroy the tooltip data. The actual mouse events operates
on all Evas_Object and is the one where tooltip data is actually
stored.
The public API is basically the same, just the event_info is now NULL
to avoid confusion.
The internal API introduces elm_object_sub_tooltip_content_cb_set()
and as the first parameter the eventarea. While this may be confusing,
as the second parameter is the actual elementary object, it is the one
that all other calls receive, like elm_object_tooltip_hide() or
elm_object_tooltip_unset(), thus it does make sense to have such order.
Also internal API, elm_widget_item_tooltip_* functions were
added. They are a variation of the widget API to handle its items, as
such the func() gets one more parameter: item, and the del_cb() gets
the item as event_info (that's why the public widget version got
event_info always NULL, to not confuse with this one!)
Widgets with items that makes sense to have tooltips got extra API:
* toolbar
* list
* gengrid
* genlist
SVN revision: 52173
2010-09-12 14:05:13 -07:00
|
|
|
EINA_SAFETY_ON_NULL_GOTO(owner, error);
|
|
|
|
EINA_SAFETY_ON_NULL_GOTO(eventarea, error);
|
2010-09-10 17:52:33 -07:00
|
|
|
|
|
|
|
if (!func)
|
|
|
|
{
|
Tooltips: split owner/eventarea, allow subitems to have indepentent tooltips.
Now owner widget (elm_widget) is just used to listen for theme changes
and create/destroy the tooltip data. The actual mouse events operates
on all Evas_Object and is the one where tooltip data is actually
stored.
The public API is basically the same, just the event_info is now NULL
to avoid confusion.
The internal API introduces elm_object_sub_tooltip_content_cb_set()
and as the first parameter the eventarea. While this may be confusing,
as the second parameter is the actual elementary object, it is the one
that all other calls receive, like elm_object_tooltip_hide() or
elm_object_tooltip_unset(), thus it does make sense to have such order.
Also internal API, elm_widget_item_tooltip_* functions were
added. They are a variation of the widget API to handle its items, as
such the func() gets one more parameter: item, and the del_cb() gets
the item as event_info (that's why the public widget version got
event_info always NULL, to not confuse with this one!)
Widgets with items that makes sense to have tooltips got extra API:
* toolbar
* list
* gengrid
* genlist
SVN revision: 52173
2010-09-12 14:05:13 -07:00
|
|
|
elm_object_tooltip_unset(eventarea);
|
2010-09-10 17:52:33 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
Tooltips: split owner/eventarea, allow subitems to have indepentent tooltips.
Now owner widget (elm_widget) is just used to listen for theme changes
and create/destroy the tooltip data. The actual mouse events operates
on all Evas_Object and is the one where tooltip data is actually
stored.
The public API is basically the same, just the event_info is now NULL
to avoid confusion.
The internal API introduces elm_object_sub_tooltip_content_cb_set()
and as the first parameter the eventarea. While this may be confusing,
as the second parameter is the actual elementary object, it is the one
that all other calls receive, like elm_object_tooltip_hide() or
elm_object_tooltip_unset(), thus it does make sense to have such order.
Also internal API, elm_widget_item_tooltip_* functions were
added. They are a variation of the widget API to handle its items, as
such the func() gets one more parameter: item, and the del_cb() gets
the item as event_info (that's why the public widget version got
event_info always NULL, to not confuse with this one!)
Widgets with items that makes sense to have tooltips got extra API:
* toolbar
* list
* gengrid
* genlist
SVN revision: 52173
2010-09-12 14:05:13 -07:00
|
|
|
tt = evas_object_data_get(eventarea, _tooltip_key);
|
2010-09-10 17:52:33 -07:00
|
|
|
if (tt)
|
|
|
|
{
|
Tooltips: split owner/eventarea, allow subitems to have indepentent tooltips.
Now owner widget (elm_widget) is just used to listen for theme changes
and create/destroy the tooltip data. The actual mouse events operates
on all Evas_Object and is the one where tooltip data is actually
stored.
The public API is basically the same, just the event_info is now NULL
to avoid confusion.
The internal API introduces elm_object_sub_tooltip_content_cb_set()
and as the first parameter the eventarea. While this may be confusing,
as the second parameter is the actual elementary object, it is the one
that all other calls receive, like elm_object_tooltip_hide() or
elm_object_tooltip_unset(), thus it does make sense to have such order.
Also internal API, elm_widget_item_tooltip_* functions were
added. They are a variation of the widget API to handle its items, as
such the func() gets one more parameter: item, and the del_cb() gets
the item as event_info (that's why the public widget version got
event_info always NULL, to not confuse with this one!)
Widgets with items that makes sense to have tooltips got extra API:
* toolbar
* list
* gengrid
* genlist
SVN revision: 52173
2010-09-12 14:05:13 -07:00
|
|
|
if (tt->owner != owner)
|
|
|
|
{
|
2010-09-16 16:44:02 -07:00
|
|
|
if (tt->owner != eventarea)
|
|
|
|
evas_object_event_callback_del_full
|
2011-06-15 07:07:28 -07:00
|
|
|
(tt->owner, EVAS_CALLBACK_FREE, _elm_tooltip_obj_free_cb, tt);
|
2010-09-16 16:44:02 -07:00
|
|
|
|
Tooltips: split owner/eventarea, allow subitems to have indepentent tooltips.
Now owner widget (elm_widget) is just used to listen for theme changes
and create/destroy the tooltip data. The actual mouse events operates
on all Evas_Object and is the one where tooltip data is actually
stored.
The public API is basically the same, just the event_info is now NULL
to avoid confusion.
The internal API introduces elm_object_sub_tooltip_content_cb_set()
and as the first parameter the eventarea. While this may be confusing,
as the second parameter is the actual elementary object, it is the one
that all other calls receive, like elm_object_tooltip_hide() or
elm_object_tooltip_unset(), thus it does make sense to have such order.
Also internal API, elm_widget_item_tooltip_* functions were
added. They are a variation of the widget API to handle its items, as
such the func() gets one more parameter: item, and the del_cb() gets
the item as event_info (that's why the public widget version got
event_info always NULL, to not confuse with this one!)
Widgets with items that makes sense to have tooltips got extra API:
* toolbar
* list
* gengrid
* genlist
SVN revision: 52173
2010-09-12 14:05:13 -07:00
|
|
|
elm_widget_tooltip_del(tt->owner, tt);
|
|
|
|
|
2010-09-16 16:44:02 -07:00
|
|
|
if (owner != eventarea)
|
|
|
|
evas_object_event_callback_add
|
2011-06-15 07:07:28 -07:00
|
|
|
(owner, EVAS_CALLBACK_FREE, _elm_tooltip_obj_free_cb, tt);
|
2010-09-16 16:44:02 -07:00
|
|
|
|
Tooltips: split owner/eventarea, allow subitems to have indepentent tooltips.
Now owner widget (elm_widget) is just used to listen for theme changes
and create/destroy the tooltip data. The actual mouse events operates
on all Evas_Object and is the one where tooltip data is actually
stored.
The public API is basically the same, just the event_info is now NULL
to avoid confusion.
The internal API introduces elm_object_sub_tooltip_content_cb_set()
and as the first parameter the eventarea. While this may be confusing,
as the second parameter is the actual elementary object, it is the one
that all other calls receive, like elm_object_tooltip_hide() or
elm_object_tooltip_unset(), thus it does make sense to have such order.
Also internal API, elm_widget_item_tooltip_* functions were
added. They are a variation of the widget API to handle its items, as
such the func() gets one more parameter: item, and the del_cb() gets
the item as event_info (that's why the public widget version got
event_info always NULL, to not confuse with this one!)
Widgets with items that makes sense to have tooltips got extra API:
* toolbar
* list
* gengrid
* genlist
SVN revision: 52173
2010-09-12 14:05:13 -07:00
|
|
|
elm_widget_tooltip_add(tt->owner, tt);
|
|
|
|
}
|
|
|
|
|
2010-09-10 17:52:33 -07:00
|
|
|
if ((tt->func == func) && (tt->data == data) &&
|
|
|
|
(tt->del_cb == del_cb))
|
|
|
|
return;
|
|
|
|
_elm_tooltip_data_clean(tt);
|
|
|
|
just_created = EINA_FALSE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
tt = ELM_NEW(Elm_Tooltip);
|
|
|
|
if (!tt) goto error;
|
|
|
|
|
Tooltips: split owner/eventarea, allow subitems to have indepentent tooltips.
Now owner widget (elm_widget) is just used to listen for theme changes
and create/destroy the tooltip data. The actual mouse events operates
on all Evas_Object and is the one where tooltip data is actually
stored.
The public API is basically the same, just the event_info is now NULL
to avoid confusion.
The internal API introduces elm_object_sub_tooltip_content_cb_set()
and as the first parameter the eventarea. While this may be confusing,
as the second parameter is the actual elementary object, it is the one
that all other calls receive, like elm_object_tooltip_hide() or
elm_object_tooltip_unset(), thus it does make sense to have such order.
Also internal API, elm_widget_item_tooltip_* functions were
added. They are a variation of the widget API to handle its items, as
such the func() gets one more parameter: item, and the del_cb() gets
the item as event_info (that's why the public widget version got
event_info always NULL, to not confuse with this one!)
Widgets with items that makes sense to have tooltips got extra API:
* toolbar
* list
* gengrid
* genlist
SVN revision: 52173
2010-09-12 14:05:13 -07:00
|
|
|
tt->owner = owner;
|
|
|
|
tt->eventarea = eventarea;
|
|
|
|
tt->evas = evas_object_evas_get(eventarea);
|
|
|
|
evas_object_data_set(eventarea, _tooltip_key, tt);
|
2010-09-10 17:52:33 -07:00
|
|
|
|
|
|
|
just_created = EINA_TRUE;
|
|
|
|
|
2011-07-26 23:43:51 -07:00
|
|
|
evas_object_event_callback_add(eventarea, EVAS_CALLBACK_MOUSE_IN,
|
Tooltips: split owner/eventarea, allow subitems to have indepentent tooltips.
Now owner widget (elm_widget) is just used to listen for theme changes
and create/destroy the tooltip data. The actual mouse events operates
on all Evas_Object and is the one where tooltip data is actually
stored.
The public API is basically the same, just the event_info is now NULL
to avoid confusion.
The internal API introduces elm_object_sub_tooltip_content_cb_set()
and as the first parameter the eventarea. While this may be confusing,
as the second parameter is the actual elementary object, it is the one
that all other calls receive, like elm_object_tooltip_hide() or
elm_object_tooltip_unset(), thus it does make sense to have such order.
Also internal API, elm_widget_item_tooltip_* functions were
added. They are a variation of the widget API to handle its items, as
such the func() gets one more parameter: item, and the del_cb() gets
the item as event_info (that's why the public widget version got
event_info always NULL, to not confuse with this one!)
Widgets with items that makes sense to have tooltips got extra API:
* toolbar
* list
* gengrid
* genlist
SVN revision: 52173
2010-09-12 14:05:13 -07:00
|
|
|
_elm_tooltip_obj_mouse_in_cb, tt);
|
2011-07-26 23:43:51 -07:00
|
|
|
evas_object_event_callback_add(eventarea, EVAS_CALLBACK_MOUSE_OUT,
|
|
|
|
(Evas_Object_Event_Cb)_elm_tooltip_obj_mouse_out_cb, tt);
|
|
|
|
evas_object_event_callback_add(eventarea, EVAS_CALLBACK_FREE,
|
|
|
|
_elm_tooltip_obj_free_cb, tt);
|
2010-09-10 17:52:33 -07:00
|
|
|
|
2010-09-16 16:44:02 -07:00
|
|
|
if (owner != eventarea)
|
|
|
|
evas_object_event_callback_add
|
2011-06-15 07:07:28 -07:00
|
|
|
(owner, EVAS_CALLBACK_FREE, _elm_tooltip_obj_free_cb, tt);
|
2010-09-16 16:44:02 -07:00
|
|
|
|
Tooltips: split owner/eventarea, allow subitems to have indepentent tooltips.
Now owner widget (elm_widget) is just used to listen for theme changes
and create/destroy the tooltip data. The actual mouse events operates
on all Evas_Object and is the one where tooltip data is actually
stored.
The public API is basically the same, just the event_info is now NULL
to avoid confusion.
The internal API introduces elm_object_sub_tooltip_content_cb_set()
and as the first parameter the eventarea. While this may be confusing,
as the second parameter is the actual elementary object, it is the one
that all other calls receive, like elm_object_tooltip_hide() or
elm_object_tooltip_unset(), thus it does make sense to have such order.
Also internal API, elm_widget_item_tooltip_* functions were
added. They are a variation of the widget API to handle its items, as
such the func() gets one more parameter: item, and the del_cb() gets
the item as event_info (that's why the public widget version got
event_info always NULL, to not confuse with this one!)
Widgets with items that makes sense to have tooltips got extra API:
* toolbar
* list
* gengrid
* genlist
SVN revision: 52173
2010-09-12 14:05:13 -07:00
|
|
|
elm_widget_tooltip_add(tt->owner, tt);
|
2010-09-10 17:52:33 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
tt->func = func;
|
|
|
|
tt->data = data;
|
|
|
|
tt->del_cb = del_cb;
|
|
|
|
|
2010-09-12 10:24:45 -07:00
|
|
|
if (!just_created) _elm_tooltip_reconfigure_job_start(tt);
|
2010-09-10 17:52:33 -07:00
|
|
|
return;
|
|
|
|
|
|
|
|
error:
|
Tooltips: split owner/eventarea, allow subitems to have indepentent tooltips.
Now owner widget (elm_widget) is just used to listen for theme changes
and create/destroy the tooltip data. The actual mouse events operates
on all Evas_Object and is the one where tooltip data is actually
stored.
The public API is basically the same, just the event_info is now NULL
to avoid confusion.
The internal API introduces elm_object_sub_tooltip_content_cb_set()
and as the first parameter the eventarea. While this may be confusing,
as the second parameter is the actual elementary object, it is the one
that all other calls receive, like elm_object_tooltip_hide() or
elm_object_tooltip_unset(), thus it does make sense to have such order.
Also internal API, elm_widget_item_tooltip_* functions were
added. They are a variation of the widget API to handle its items, as
such the func() gets one more parameter: item, and the del_cb() gets
the item as event_info (that's why the public widget version got
event_info always NULL, to not confuse with this one!)
Widgets with items that makes sense to have tooltips got extra API:
* toolbar
* list
* gengrid
* genlist
SVN revision: 52173
2010-09-12 14:05:13 -07:00
|
|
|
if (del_cb) del_cb((void *)data, owner, NULL);
|
2010-09-10 17:52:33 -07:00
|
|
|
}
|
|
|
|
|
2010-09-13 00:56:23 -07:00
|
|
|
/**
|
|
|
|
* Force show tooltip of object
|
|
|
|
*
|
|
|
|
* @param obj Target object
|
|
|
|
*
|
|
|
|
* Force show the tooltip and disable hide on mouse_out.
|
|
|
|
* If another content is set as tooltip, the visible tooltip will hididen and
|
|
|
|
* showed again with new content.
|
|
|
|
* This can force show more than one tooltip at a time.
|
|
|
|
*
|
|
|
|
* @ingroup Tooltips
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
elm_object_tooltip_show(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
ELM_TOOLTIP_GET_OR_RETURN(tt, obj);
|
|
|
|
tt->visible_lock = EINA_TRUE;
|
|
|
|
_elm_tooltip_show(tt);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Force hide tooltip of object
|
|
|
|
*
|
|
|
|
* @param obj Target object
|
|
|
|
*
|
|
|
|
* Force hide the tooltip and (re)enable future mouse interations.
|
|
|
|
*
|
|
|
|
* @ingroup Tooltips
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
elm_object_tooltip_hide(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
ELM_TOOLTIP_GET_OR_RETURN(tt, obj);
|
|
|
|
tt->visible_lock = EINA_FALSE;
|
|
|
|
_elm_tooltip_hide_anim_start(tt);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the text to be shown in the tooltip object
|
|
|
|
*
|
|
|
|
* @param obj Target object
|
|
|
|
* @param text The text to set in the content
|
|
|
|
*
|
|
|
|
* Setup the text as tooltip to object. The object can have only one tooltip,
|
|
|
|
* so any previous tooltip data is removed.
|
|
|
|
* This method call internaly the elm_tooltip_content_cb_set().
|
|
|
|
*
|
|
|
|
* @ingroup Tooltips
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
elm_object_tooltip_text_set(Evas_Object *obj, const char *text)
|
|
|
|
{
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(obj);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(text);
|
|
|
|
|
|
|
|
text = eina_stringshare_add(text);
|
|
|
|
elm_object_tooltip_content_cb_set
|
|
|
|
(obj, _elm_tooltip_label_create, text, _elm_tooltip_label_del_cb);
|
|
|
|
}
|
|
|
|
|
2011-10-19 07:17:14 -07:00
|
|
|
/**
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
elm_object_tooltip_domain_translatable_text_set(Evas_Object *obj, const char *domain, const char *text)
|
|
|
|
{
|
|
|
|
const char **data;
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(obj);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(text);
|
|
|
|
|
|
|
|
data = malloc(2 * sizeof(char *));
|
|
|
|
if (!data) return;
|
|
|
|
data[0] = eina_stringshare_add(domain);
|
|
|
|
data[1] = eina_stringshare_add(text);
|
|
|
|
elm_object_tooltip_content_cb_set
|
|
|
|
(obj, _elm_tooltip_trans_label_create, data,
|
|
|
|
_elm_tooltip_trans_label_del_cb);
|
|
|
|
}
|
|
|
|
|
2010-09-13 00:56:23 -07:00
|
|
|
/**
|
|
|
|
* Set the content to be shown in the tooltip object
|
|
|
|
*
|
|
|
|
* Setup the tooltip to object. The object can have only one tooltip,
|
|
|
|
* so any previous tooltip data is removed. @p func(with @p data) will
|
|
|
|
* be called every time that need show the tooltip and it should
|
|
|
|
* return a valid Evas_Object. This object is then managed fully by
|
|
|
|
* tooltip system and is deleted when the tooltip is gone.
|
|
|
|
*
|
|
|
|
* @param obj the object being attached a tooltip.
|
|
|
|
* @param func the function used to create the tooltip contents.
|
|
|
|
* @param data what to provide to @a func as callback data/context.
|
|
|
|
* @param del_cb called when data is not needed anymore, either when
|
2011-08-03 12:07:43 -07:00
|
|
|
* another callback replaces @p func, the tooltip is unset with
|
2010-09-13 00:56:23 -07:00
|
|
|
* elm_object_tooltip_unset() or the owner object @a obj
|
|
|
|
* dies. This callback receives as the first parameter the
|
|
|
|
* given @a data, and @c event_info is NULL.
|
|
|
|
*
|
|
|
|
* @ingroup Tooltips
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
elm_object_tooltip_content_cb_set(Evas_Object *obj, Elm_Tooltip_Content_Cb func, const void *data, Evas_Smart_Cb del_cb)
|
|
|
|
{
|
|
|
|
elm_object_sub_tooltip_content_cb_set(obj, obj, func, data, del_cb);
|
|
|
|
}
|
|
|
|
|
2010-09-10 17:52:33 -07:00
|
|
|
/**
|
|
|
|
* Unset tooltip from object
|
|
|
|
*
|
|
|
|
* @param obj Target object
|
|
|
|
*
|
|
|
|
* Remove tooltip from object. The callback provided as del_cb to
|
|
|
|
* elm_object_tooltip_content_cb_set() will be called to notify it is
|
|
|
|
* not used anymore.
|
|
|
|
*
|
|
|
|
* @see elm_object_tooltip_content_cb_set()
|
|
|
|
*
|
|
|
|
* @ingroup Tooltips
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
elm_object_tooltip_unset(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
ELM_TOOLTIP_GET_OR_RETURN(tt, obj);
|
2010-09-16 16:44:02 -07:00
|
|
|
_elm_tooltip_unset(tt);
|
2010-09-10 17:52:33 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Sets a different style for this object tooltip.
|
|
|
|
*
|
|
|
|
* @note before you set a style you should define a tooltip with
|
|
|
|
* elm_object_tooltip_content_cb_set() or
|
|
|
|
* elm_object_tooltip_text_set().
|
|
|
|
*
|
|
|
|
* @param obj an object with tooltip already set.
|
|
|
|
* @param style the theme style to use (default, transparent, ...)
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
elm_object_tooltip_style_set(Evas_Object *obj, const char *style)
|
|
|
|
{
|
|
|
|
ELM_TOOLTIP_GET_OR_RETURN(tt, obj);
|
|
|
|
if (!eina_stringshare_replace(&tt->style, style)) return;
|
|
|
|
elm_tooltip_theme(tt);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the style for this object tooltip.
|
|
|
|
*
|
|
|
|
* @param obj an object with tooltip already set.
|
|
|
|
* @return style the theme style in use, defaults to "default". If the
|
|
|
|
* object does not have a tooltip set, then NULL is returned.
|
|
|
|
*/
|
|
|
|
EAPI const char *
|
|
|
|
elm_object_tooltip_style_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
ELM_TOOLTIP_GET_OR_RETURN(tt, obj, NULL);
|
|
|
|
return tt->style ? tt->style : "default";
|
|
|
|
}
|
|
|
|
|
2011-07-26 02:38:23 -07:00
|
|
|
/**
|
|
|
|
* @brief Disable size restrictions on an object's tooltip
|
|
|
|
* @param obj The tooltip's anchor object
|
|
|
|
* @param disable If EINA_TRUE, size restrictions are disabled
|
|
|
|
* @return EINA_FALSE on failure, EINA_TRUE on success
|
|
|
|
*
|
2012-03-04 18:35:25 -08:00
|
|
|
* This function allows a tooltip to expand beyond its parent window's canvas.
|
2011-07-26 02:38:23 -07:00
|
|
|
* It will instead be limited only by the size of the display.
|
|
|
|
*/
|
|
|
|
EAPI Eina_Bool
|
2011-12-05 07:25:09 -08:00
|
|
|
elm_object_tooltip_window_mode_set(Evas_Object *obj, Eina_Bool disable)
|
2011-07-26 02:38:23 -07:00
|
|
|
{
|
|
|
|
ELM_TOOLTIP_GET_OR_RETURN(tt, obj, EINA_FALSE);
|
|
|
|
return tt->free_size = disable;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief Retrieve size restriction state of an object's tooltip
|
|
|
|
* @param obj The tooltip's anchor object
|
|
|
|
* @return If EINA_TRUE, size restrictions are disabled
|
|
|
|
*
|
|
|
|
* This function returns whether a tooltip is allowed to expand beyond
|
2012-03-04 18:35:25 -08:00
|
|
|
* its parent window's canvas.
|
2011-07-26 02:38:23 -07:00
|
|
|
* It will instead be limited only by the size of the display.
|
|
|
|
*/
|
|
|
|
EAPI Eina_Bool
|
2011-12-05 07:25:09 -08:00
|
|
|
elm_object_tooltip_window_mode_get(const Evas_Object *obj)
|
2011-07-26 02:38:23 -07:00
|
|
|
{
|
|
|
|
ELM_TOOLTIP_GET_OR_RETURN(tt, obj, EINA_FALSE);
|
|
|
|
return tt->free_size;
|
|
|
|
}
|