2008-09-29 23:58:56 -07:00
|
|
|
#include <Elementary.h>
|
|
|
|
#include "elm_priv.h"
|
2012-05-03 15:41:26 -07:00
|
|
|
#include "elm_widget_container.h"
|
2012-07-04 14:41:01 -07:00
|
|
|
#include "elm_interface_scrollable.h"
|
2008-09-29 23:58:56 -07:00
|
|
|
|
2010-03-22 14:36:59 -07:00
|
|
|
static const char SMART_NAME[] = "elm_widget";
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
static const char SMART_NAME_COMPAT[] = "elm_widget_compat";
|
2010-03-22 14:36:59 -07:00
|
|
|
|
2011-04-02 23:43:17 -07:00
|
|
|
#define API_ENTRY \
|
2012-05-03 15:40:58 -07:00
|
|
|
Elm_Widget_Smart_Data * sd = evas_object_smart_data_get(obj); \
|
2011-12-18 23:06:22 -08:00
|
|
|
if ((!sd) || (!_elm_widget_is(obj)))
|
2011-04-02 23:43:17 -07:00
|
|
|
#define INTERNAL_ENTRY \
|
2012-05-03 15:40:58 -07:00
|
|
|
Elm_Widget_Smart_Data * sd = evas_object_smart_data_get(obj); \
|
2011-12-27 21:51:10 -08:00
|
|
|
if (!sd) return
|
2011-04-02 23:43:17 -07:00
|
|
|
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
/* this will vanish as soon as we finish the migration of widgets to
|
|
|
|
* the new hierarchical schema. */
|
|
|
|
#define COMPAT_SMART_DATA(_sd) \
|
|
|
|
((Elm_Widget_Compat_Smart_Data *)_sd)
|
|
|
|
|
|
|
|
/* these typedefs are just to save typing on
|
|
|
|
* _elm_widget_compat_smart_set_user() and will die eventually */
|
|
|
|
typedef Eina_Bool (*one_arg_class_func)(Evas_Object *obj);
|
|
|
|
typedef Eina_Bool (*event_class_func)(Evas_Object *obj,
|
|
|
|
Evas_Object *source,
|
|
|
|
Evas_Callback_Type type,
|
|
|
|
void *event_info);
|
|
|
|
typedef Eina_Bool (*focus_next_func)(const Evas_Object *obj,
|
|
|
|
Elm_Focus_Direction dir,
|
|
|
|
Evas_Object **next);
|
|
|
|
typedef Eina_Bool (*focus_direction_func)(const Evas_Object *obj,
|
|
|
|
const Evas_Object *base,
|
|
|
|
double degree,
|
|
|
|
Evas_Object **target,
|
|
|
|
double *weight);
|
|
|
|
|
|
|
|
/* these will eventually take place of the two on the top */
|
|
|
|
#define ELM_WIDGET_DATA_GET(o, wd) \
|
|
|
|
Elm_Widget_Smart_Data * wd = evas_object_smart_data_get(o)
|
|
|
|
|
|
|
|
#define ELM_WIDGET_DATA_GET_OR_RETURN(o, ptr) \
|
|
|
|
ELM_WIDGET_DATA_GET(o, ptr); \
|
|
|
|
if (!ptr) \
|
|
|
|
{ \
|
|
|
|
CRITICAL("no widget data for object %p (%s)", \
|
|
|
|
o, evas_object_type_get(o)); \
|
|
|
|
return; \
|
|
|
|
}
|
|
|
|
|
2011-08-10 16:43:50 -07:00
|
|
|
#undef elm_widget_text_set_hook_set
|
|
|
|
#undef elm_widget_text_get_hook_set
|
|
|
|
#undef elm_widget_content_set_hook_set
|
|
|
|
#undef elm_widget_content_get_hook_set
|
|
|
|
#undef elm_widget_content_unset_hook_set
|
|
|
|
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
/**
|
|
|
|
* @addtogroup Widget
|
|
|
|
* @{
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Base widget smart data extended with instance widget hooks. This
|
|
|
|
* will be used for compatibility with the old (non-hierarchical)
|
|
|
|
* widget structure, until all widgets are adapted to the new
|
|
|
|
* hierarchical schema
|
|
|
|
*/
|
|
|
|
typedef struct _Elm_Widget_Compat_Smart_Data
|
|
|
|
{
|
|
|
|
Elm_Widget_Smart_Data base; /**< Base widget smart data as first member obligatory, as we're inheriting from it */
|
|
|
|
|
|
|
|
const char *type;
|
|
|
|
void *data;
|
|
|
|
|
|
|
|
void *on_focus_data;
|
|
|
|
void *on_change_data;
|
|
|
|
|
|
|
|
Eina_List *edje_signals;
|
|
|
|
|
|
|
|
/* (instance) widget hooks */
|
|
|
|
void (*del)(Evas_Object *obj);
|
|
|
|
void (*del_pre)(Evas_Object *obj);
|
|
|
|
void (*focus)(Evas_Object *obj);
|
|
|
|
void (*activate)(Evas_Object *obj);
|
|
|
|
void (*disable)(Evas_Object *obj);
|
|
|
|
void (*theme)(Evas_Object *obj);
|
2012-07-03 05:09:34 -07:00
|
|
|
void (*access)(Evas_Object *obj, Eina_Bool is_access);
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
void (*translate)(Evas_Object *obj);
|
|
|
|
Eina_Bool (*event)(Evas_Object *obj,
|
|
|
|
Evas_Object *source,
|
|
|
|
Evas_Callback_Type type,
|
|
|
|
void *event_info);
|
|
|
|
void (*signal)(Evas_Object *obj,
|
|
|
|
const char *emission,
|
|
|
|
const char *source);
|
|
|
|
void (*callback_add)(Evas_Object *obj,
|
|
|
|
const char *emission,
|
|
|
|
const char *source,
|
|
|
|
Edje_Signal_Cb func,
|
|
|
|
void *data);
|
|
|
|
void (*callback_del)(Evas_Object *obj,
|
|
|
|
const char *emission,
|
|
|
|
const char *source,
|
|
|
|
Edje_Signal_Cb func,
|
|
|
|
void *data);
|
|
|
|
void (*changed)(Evas_Object *obj);
|
|
|
|
Eina_Bool (*focus_next)(const Evas_Object *obj,
|
|
|
|
Elm_Focus_Direction dir,
|
|
|
|
Evas_Object **next);
|
|
|
|
Eina_Bool (*focus_direction)(const Evas_Object *obj,
|
|
|
|
const Evas_Object *base,
|
|
|
|
double degree,
|
|
|
|
Evas_Object **target,
|
|
|
|
double *weight);
|
|
|
|
void (*on_focus)(void *data,
|
|
|
|
Evas_Object *obj);
|
|
|
|
void (*on_change)(void *data,
|
|
|
|
Evas_Object *obj);
|
|
|
|
Elm_Widget_Text_Set_Cb text_set;
|
|
|
|
Elm_Widget_Text_Get_Cb text_get;
|
|
|
|
Elm_Widget_Content_Set_Cb content_set;
|
|
|
|
Elm_Widget_Content_Get_Cb content_get;
|
|
|
|
Elm_Widget_Content_Unset_Cb content_unset;
|
|
|
|
} Elm_Widget_Compat_Smart_Data;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Inheriting from base widget smart class, so that we flag widgets
|
|
|
|
* not migrated to new hierarchical schema as "compat" (or legacy),
|
|
|
|
* until we get all of them migrated. Then, this class will be
|
|
|
|
* dropped.
|
|
|
|
*/
|
|
|
|
typedef struct _Elm_Widget_Compat_Smart_Class
|
|
|
|
{
|
|
|
|
Elm_Widget_Smart_Class base; /**< Base widget smart class wrapped here */
|
|
|
|
} Elm_Widget_Compat_Smart_Class;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @}
|
|
|
|
*/
|
|
|
|
|
2010-11-29 05:56:30 -08:00
|
|
|
typedef struct _Elm_Event_Cb_Data Elm_Event_Cb_Data;
|
2011-10-19 07:17:14 -07:00
|
|
|
typedef struct _Elm_Translate_String_Data Elm_Translate_String_Data;
|
2008-09-29 23:58:56 -07:00
|
|
|
|
2011-04-02 23:43:17 -07:00
|
|
|
struct _Elm_Event_Cb_Data
|
|
|
|
{
|
|
|
|
Elm_Event_Cb func;
|
|
|
|
const void *data;
|
2010-11-29 05:56:30 -08:00
|
|
|
};
|
|
|
|
|
2011-10-19 07:17:14 -07:00
|
|
|
struct _Elm_Translate_String_Data
|
|
|
|
{
|
|
|
|
const char *id;
|
|
|
|
const char *domain;
|
|
|
|
const char *string;
|
|
|
|
};
|
|
|
|
|
2008-10-06 18:23:49 -07:00
|
|
|
/* local subsystem functions */
|
2012-05-03 15:40:58 -07:00
|
|
|
static void _smart_reconfigure(Elm_Widget_Smart_Data *sd);
|
2008-10-06 18:23:49 -07:00
|
|
|
static void _smart_add(Evas_Object *obj);
|
|
|
|
static void _smart_del(Evas_Object *obj);
|
2011-04-02 23:43:17 -07:00
|
|
|
static void _smart_move(Evas_Object *obj,
|
|
|
|
Evas_Coord x,
|
|
|
|
Evas_Coord y);
|
|
|
|
static void _smart_resize(Evas_Object *obj,
|
|
|
|
Evas_Coord w,
|
|
|
|
Evas_Coord h);
|
2008-10-06 18:23:49 -07:00
|
|
|
static void _smart_show(Evas_Object *obj);
|
|
|
|
static void _smart_hide(Evas_Object *obj);
|
2011-04-02 23:43:17 -07:00
|
|
|
static void _smart_color_set(Evas_Object *obj,
|
|
|
|
int r,
|
|
|
|
int g,
|
|
|
|
int b,
|
|
|
|
int a);
|
|
|
|
static void _smart_clip_set(Evas_Object *obj,
|
|
|
|
Evas_Object *clip);
|
2008-10-06 18:23:49 -07:00
|
|
|
static void _smart_clip_unset(Evas_Object *obj);
|
2009-11-17 08:32:45 -08:00
|
|
|
static void _smart_calculate(Evas_Object *obj);
|
2012-03-28 03:03:45 -07:00
|
|
|
static void _smart_member_add(Evas_Object *obj, Evas_Object *child);
|
2012-04-03 07:29:38 -07:00
|
|
|
static void _smart_member_del(Evas_Object *obj, Evas_Object *child);
|
2011-04-02 23:43:17 -07:00
|
|
|
static void _if_focused_revert(Evas_Object *obj,
|
|
|
|
Eina_Bool can_focus_only);
|
|
|
|
static Evas_Object *_newest_focus_order_get(Evas_Object *obj,
|
|
|
|
unsigned int *newest_focus_order,
|
|
|
|
Eina_Bool can_focus_only);
|
2012-05-02 20:02:54 -07:00
|
|
|
static double _direction_weight_get(const Evas_Object *obj1, const Evas_Object *obj2, double degree);
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70627
2012-05-02 09:57:38 -07:00
|
|
|
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
static void _sub_obj_del(void *data,
|
|
|
|
Evas *e,
|
|
|
|
Evas_Object *obj,
|
|
|
|
void *event_info);
|
|
|
|
static void _focus_parents(Evas_Object *obj);
|
|
|
|
static void _sub_obj_hide(void *data,
|
|
|
|
Evas *e,
|
|
|
|
Evas_Object *obj,
|
|
|
|
void *event_info);
|
|
|
|
|
2008-10-06 18:23:49 -07:00
|
|
|
/* local subsystem globals */
|
2010-09-13 00:56:23 -07:00
|
|
|
static Eina_List *widtypes = NULL;
|
2008-10-06 18:23:49 -07:00
|
|
|
|
2010-06-21 00:39:49 -07:00
|
|
|
static unsigned int focus_order = 0;
|
|
|
|
|
2010-09-13 00:56:23 -07:00
|
|
|
static inline Eina_Bool
|
|
|
|
_elm_widget_is(const Evas_Object *obj)
|
|
|
|
{
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
return evas_object_smart_type_check_ptr(obj, SMART_NAME);
|
2010-09-13 00:56:23 -07:00
|
|
|
}
|
|
|
|
|
2010-09-24 07:47:52 -07:00
|
|
|
static inline Eina_Bool
|
|
|
|
_is_focusable(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
API_ENTRY return EINA_FALSE;
|
2010-10-22 14:41:22 -07:00
|
|
|
return sd->can_focus || (sd->child_can_focus);
|
2010-09-24 07:47:52 -07:00
|
|
|
}
|
|
|
|
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
static inline Eina_Bool
|
|
|
|
_elm_legacy_is(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
return evas_object_smart_type_check_ptr(obj, SMART_NAME_COMPAT);
|
|
|
|
}
|
|
|
|
|
2012-07-04 14:41:01 -07:00
|
|
|
static inline Eina_Bool
|
|
|
|
_elm_scrollable_is(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
return !!evas_object_smart_interface_get(obj, ELM_SCROLLABLE_IFACE_NAME);
|
|
|
|
}
|
|
|
|
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
/* what follows are both basic (unimplemented) smart class functions
|
|
|
|
* and proxies from those to smart data (instance) widget
|
|
|
|
* functions. one by one we'll be surpassing the proxies on the
|
|
|
|
* widgets, as long as we make them extensions of the basic elm widget
|
|
|
|
* the right way */
|
|
|
|
#define PROXY_MAKE(_prefix) \
|
|
|
|
static Eina_Bool \
|
|
|
|
_elm_widget_##_prefix##_func_compat(Evas_Object * obj) \
|
|
|
|
{ \
|
|
|
|
ELM_WIDGET_DATA_GET(obj, sd); \
|
|
|
|
if (COMPAT_SMART_DATA(sd)->_prefix) \
|
|
|
|
{ \
|
|
|
|
COMPAT_SMART_DATA(sd)->_prefix(obj); \
|
|
|
|
return EINA_TRUE; \
|
|
|
|
} \
|
|
|
|
return EINA_FALSE; \
|
|
|
|
}
|
|
|
|
|
|
|
|
#define UNIMPLEMENTED_MAKE(_prefix) \
|
|
|
|
static Eina_Bool \
|
|
|
|
_elm_widget_##_prefix##_func_unimplemented(Evas_Object * obj) \
|
|
|
|
{ \
|
|
|
|
WRN("The %s widget does not implement the \"" #_prefix "\" function.", \
|
|
|
|
elm_widget_type_get(obj)); \
|
|
|
|
return EINA_FALSE; \
|
|
|
|
}
|
|
|
|
|
|
|
|
PROXY_MAKE(disable);
|
|
|
|
PROXY_MAKE(theme);
|
|
|
|
PROXY_MAKE(translate);
|
|
|
|
UNIMPLEMENTED_MAKE(disable);
|
|
|
|
UNIMPLEMENTED_MAKE(translate);
|
|
|
|
|
|
|
|
#undef PROXY_MAKE
|
|
|
|
#undef UNIMPLEMENTED_MAKE
|
|
|
|
|
2012-05-03 15:41:15 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_elm_widget_theme_func(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
_elm_widget_mirrored_reload(obj);
|
|
|
|
|
|
|
|
elm_widget_disabled_set(obj, elm_widget_disabled_get(obj));
|
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_elm_widget_on_focus_func_compat(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_DATA_GET(obj, sd);
|
|
|
|
|
|
|
|
if (COMPAT_SMART_DATA(sd)->on_focus)
|
|
|
|
{
|
|
|
|
COMPAT_SMART_DATA(sd)->on_focus
|
|
|
|
(COMPAT_SMART_DATA(sd)->on_focus_data, obj);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_elm_widget_on_focus_func_unimplemented(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
WRN("The %s widget does not implement the \"on_focus\" function.",
|
|
|
|
elm_widget_type_get(obj));
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_elm_widget_event_func_compat(Evas_Object *obj,
|
|
|
|
Evas_Object *source,
|
|
|
|
Evas_Callback_Type type,
|
|
|
|
void *event_info)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_DATA_GET(obj, sd);
|
|
|
|
|
|
|
|
if (COMPAT_SMART_DATA(sd)->event)
|
|
|
|
return COMPAT_SMART_DATA(sd)->event(obj, source, type, event_info);
|
|
|
|
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_elm_widget_event_func_unimplemented(Evas_Object *obj,
|
|
|
|
Evas_Object *source __UNUSED__,
|
|
|
|
Evas_Callback_Type type __UNUSED__,
|
|
|
|
void *event_info __UNUSED__)
|
|
|
|
{
|
|
|
|
WRN("The %s widget does not implement the \"event\" function.",
|
|
|
|
elm_widget_type_get(obj));
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_elm_widget_focus_next_func_compat(const Evas_Object *obj,
|
|
|
|
Elm_Focus_Direction dir,
|
|
|
|
Evas_Object **next)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_DATA_GET(obj, sd);
|
|
|
|
|
|
|
|
if (COMPAT_SMART_DATA(sd)->focus_next)
|
|
|
|
return COMPAT_SMART_DATA(sd)->focus_next(obj, dir, next);
|
|
|
|
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_elm_widget_focus_next_func_unimplemented(const Evas_Object *obj __UNUSED__,
|
|
|
|
Elm_Focus_Direction dir __UNUSED__,
|
|
|
|
Evas_Object **next __UNUSED__)
|
|
|
|
{
|
|
|
|
WRN("The %s widget does not implement the \"focus_next\" function.",
|
|
|
|
elm_widget_type_get(obj));
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_elm_widget_focus_direction_func_compat(const Evas_Object *obj,
|
|
|
|
const Evas_Object *base,
|
|
|
|
double degree,
|
|
|
|
Evas_Object **target,
|
|
|
|
double *weight)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_DATA_GET(obj, sd);
|
|
|
|
|
|
|
|
if (COMPAT_SMART_DATA(sd)->focus_direction)
|
|
|
|
return COMPAT_SMART_DATA(sd)->focus_direction
|
|
|
|
(obj, base, degree, target, weight);
|
|
|
|
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_elm_widget_focus_direction_func_unimplemented(const Evas_Object *obj __UNUSED__,
|
|
|
|
const Evas_Object *base __UNUSED__,
|
|
|
|
double degree __UNUSED__,
|
|
|
|
Evas_Object **target __UNUSED__,
|
|
|
|
double *weight __UNUSED__)
|
|
|
|
{
|
|
|
|
WRN("The %s widget does not implement the \"focus_direction\" function.",
|
|
|
|
elm_widget_type_get(obj));
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
2012-05-03 15:41:09 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_elm_widget_sub_object_add_func(Evas_Object *obj,
|
|
|
|
Evas_Object *sobj)
|
|
|
|
{
|
|
|
|
double scale, pscale = elm_widget_scale_get(sobj);
|
|
|
|
Elm_Theme *th, *pth = elm_widget_theme_get(sobj);
|
|
|
|
Eina_Bool mirrored, pmirrored = elm_widget_mirrored_get(obj);
|
|
|
|
|
|
|
|
ELM_WIDGET_DATA_GET(obj, sd);
|
|
|
|
EINA_SAFETY_ON_TRUE_RETURN_VAL(obj == sobj, EINA_FALSE);
|
|
|
|
|
|
|
|
if (sobj == sd->parent_obj)
|
|
|
|
{
|
|
|
|
/* in this case, sobj must be an elm widget, or something
|
|
|
|
* very wrong is happening */
|
|
|
|
if (!_elm_widget_is(sobj)) return EINA_FALSE;
|
|
|
|
|
|
|
|
if (!elm_widget_sub_object_del(sobj, obj)) return EINA_FALSE;
|
|
|
|
WRN("You passed a parent object of obj = %p as the sub object = %p!",
|
|
|
|
obj, sobj);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (_elm_widget_is(sobj))
|
|
|
|
{
|
|
|
|
ELM_WIDGET_DATA_GET(sobj, sdc);
|
|
|
|
|
2012-05-31 09:23:19 -07:00
|
|
|
if (sdc->parent_obj == obj) return EINA_TRUE;
|
|
|
|
if (sdc->parent_obj)
|
2012-05-03 15:41:09 -07:00
|
|
|
{
|
2012-05-31 09:23:19 -07:00
|
|
|
if (!elm_widget_sub_object_del(sdc->parent_obj, sobj))
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
sdc->parent_obj = obj;
|
|
|
|
_elm_widget_top_win_focused_set(sobj, sd->top_win_focused);
|
|
|
|
|
|
|
|
/* update child focusable-ness on self and parents, now that a
|
|
|
|
* focusable child got in */
|
|
|
|
if (!sd->child_can_focus && (_is_focusable(sobj)))
|
|
|
|
{
|
|
|
|
Elm_Widget_Smart_Data *sdp = sd;
|
|
|
|
|
|
|
|
sdp->child_can_focus = EINA_TRUE;
|
|
|
|
while (sdp->parent_obj)
|
2012-05-31 00:15:28 -07:00
|
|
|
{
|
2012-05-31 09:23:19 -07:00
|
|
|
sdp = evas_object_smart_data_get(sdp->parent_obj);
|
|
|
|
|
|
|
|
if (sdp->child_can_focus) break;
|
|
|
|
|
|
|
|
sdp->child_can_focus = EINA_TRUE;
|
2012-05-31 00:15:28 -07:00
|
|
|
}
|
2012-05-03 15:41:09 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
void *data = evas_object_data_get(sobj, "elm-parent");
|
|
|
|
|
|
|
|
if (data)
|
|
|
|
{
|
|
|
|
if (data == obj) return EINA_TRUE;
|
|
|
|
if (!elm_widget_sub_object_del(data, sobj)) return EINA_FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
sd->subobjs = eina_list_append(sd->subobjs, sobj);
|
|
|
|
evas_object_data_set(sobj, "elm-parent", obj);
|
|
|
|
evas_object_event_callback_add
|
|
|
|
(sobj, EVAS_CALLBACK_DEL, _sub_obj_del, sd);
|
|
|
|
if (_elm_widget_is(sobj))
|
|
|
|
{
|
|
|
|
evas_object_event_callback_add
|
|
|
|
(sobj, EVAS_CALLBACK_HIDE, _sub_obj_hide, sd);
|
|
|
|
|
|
|
|
scale = elm_widget_scale_get(sobj);
|
|
|
|
th = elm_widget_theme_get(sobj);
|
|
|
|
mirrored = elm_widget_mirrored_get(sobj);
|
|
|
|
|
|
|
|
if ((scale != pscale) || (th != pth) || (pmirrored != mirrored))
|
|
|
|
elm_widget_theme(sobj);
|
|
|
|
|
|
|
|
if (elm_widget_focus_get(sobj)) _focus_parents(obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_elm_widget_sub_object_del_func(Evas_Object *obj,
|
|
|
|
Evas_Object *sobj)
|
|
|
|
{
|
|
|
|
Evas_Object *sobj_parent;
|
|
|
|
|
|
|
|
if (!sobj) return EINA_FALSE;
|
|
|
|
|
|
|
|
ELM_WIDGET_DATA_GET(obj, sd);
|
|
|
|
EINA_SAFETY_ON_TRUE_RETURN_VAL(obj == sobj, EINA_FALSE);
|
|
|
|
|
|
|
|
sobj_parent = evas_object_data_del(sobj, "elm-parent");
|
|
|
|
if (sobj_parent != obj)
|
|
|
|
{
|
|
|
|
static int abort_on_warn = -1;
|
|
|
|
|
|
|
|
ERR("removing sub object %p (%s) from parent %p (%s), "
|
|
|
|
"but elm-parent is different %p (%s)!",
|
|
|
|
sobj, elm_widget_type_get(sobj), obj, elm_widget_type_get(obj),
|
|
|
|
sobj_parent, elm_widget_type_get(sobj_parent));
|
|
|
|
|
|
|
|
if (EINA_UNLIKELY(abort_on_warn == -1))
|
|
|
|
{
|
|
|
|
if (getenv("ELM_ERROR_ABORT")) abort_on_warn = 1;
|
|
|
|
else abort_on_warn = 0;
|
|
|
|
}
|
|
|
|
if (abort_on_warn == 1) abort();
|
|
|
|
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (_elm_widget_is(sobj))
|
|
|
|
{
|
|
|
|
if (elm_widget_focus_get(sobj))
|
|
|
|
{
|
|
|
|
elm_widget_tree_unfocusable_set(sobj, EINA_TRUE);
|
|
|
|
elm_widget_tree_unfocusable_set(sobj, EINA_FALSE);
|
|
|
|
}
|
|
|
|
if ((sd->child_can_focus) && (_is_focusable(sobj)))
|
|
|
|
{
|
2012-05-31 09:23:19 -07:00
|
|
|
Evas_Object *parent = obj;
|
|
|
|
|
|
|
|
/* update child focusable-ness on self and parents, now that a
|
|
|
|
* focusable child is gone */
|
|
|
|
while (parent)
|
2012-05-03 15:41:09 -07:00
|
|
|
{
|
2012-05-31 09:23:19 -07:00
|
|
|
const Eina_List *l;
|
|
|
|
Evas_Object *subobj;
|
|
|
|
|
|
|
|
ELM_WIDGET_DATA_GET(parent, sdp);
|
|
|
|
|
|
|
|
sdp->child_can_focus = EINA_FALSE;
|
|
|
|
EINA_LIST_FOREACH (sdp->subobjs, l, subobj)
|
2012-05-03 15:41:09 -07:00
|
|
|
{
|
2012-05-31 00:15:28 -07:00
|
|
|
if ((subobj != sobj) && (_is_focusable(subobj)))
|
|
|
|
{
|
2012-05-31 09:23:19 -07:00
|
|
|
sdp->child_can_focus = EINA_TRUE;
|
2012-05-31 00:15:28 -07:00
|
|
|
break;
|
|
|
|
}
|
2012-05-03 15:41:09 -07:00
|
|
|
}
|
2012-05-31 09:23:19 -07:00
|
|
|
|
|
|
|
/* break again, child_can_focus went back to
|
|
|
|
* original value */
|
|
|
|
if (sdp->child_can_focus) break;
|
|
|
|
parent = sdp->parent_obj;
|
2012-05-03 15:41:09 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ELM_WIDGET_DATA_GET(sobj, sdc);
|
|
|
|
sdc->parent_obj = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sd->resize_obj == sobj) sd->resize_obj = NULL;
|
|
|
|
|
|
|
|
sd->subobjs = eina_list_remove(sd->subobjs, sobj);
|
|
|
|
|
|
|
|
evas_object_event_callback_del_full
|
|
|
|
(sobj, EVAS_CALLBACK_DEL, _sub_obj_del, sd);
|
|
|
|
if (_elm_widget_is(sobj))
|
|
|
|
evas_object_event_callback_del_full
|
|
|
|
(sobj, EVAS_CALLBACK_HIDE, _sub_obj_hide, sd);
|
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
static const Evas_Smart_Cb_Description _smart_callbacks[] =
|
|
|
|
{
|
|
|
|
/* FIXME: complete later */
|
|
|
|
{NULL, NULL}
|
|
|
|
};
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_widget_smart_set(Elm_Widget_Smart_Class *api)
|
|
|
|
{
|
|
|
|
Evas_Smart_Class *sc;
|
|
|
|
|
|
|
|
if (!(sc = (Evas_Smart_Class *)api))
|
|
|
|
return;
|
|
|
|
|
|
|
|
sc->add = _smart_add;
|
|
|
|
sc->del = _smart_del;
|
|
|
|
sc->move = _smart_move;
|
|
|
|
sc->resize = _smart_resize;
|
|
|
|
sc->show = _smart_show;
|
|
|
|
sc->hide = _smart_hide;
|
|
|
|
sc->color_set = _smart_color_set;
|
|
|
|
sc->clip_set = _smart_clip_set;
|
|
|
|
sc->clip_unset = _smart_clip_unset;
|
|
|
|
sc->calculate = _smart_calculate;
|
|
|
|
sc->member_add = _smart_member_add;
|
|
|
|
sc->member_del = _smart_member_del;
|
|
|
|
|
|
|
|
#define API_DEFAULT_SET_UNIMPLEMENTED(_prefix) \
|
|
|
|
api->_prefix = _elm_widget_##_prefix##_func_unimplemented;
|
|
|
|
|
2012-05-03 15:41:15 -07:00
|
|
|
/* NB: always remember to call these parent versions on children,
|
|
|
|
* except for the unimplemented ones and calculate, which is moot */
|
|
|
|
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
#define API_DEFAULT_SET(_prefix) \
|
|
|
|
api->_prefix = _elm_widget_##_prefix##_func;
|
|
|
|
|
|
|
|
/* base api */
|
|
|
|
API_DEFAULT_SET_UNIMPLEMENTED(on_focus);
|
|
|
|
API_DEFAULT_SET_UNIMPLEMENTED(disable);
|
2012-05-03 15:41:15 -07:00
|
|
|
|
|
|
|
api->theme = _elm_widget_theme_func;
|
|
|
|
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
API_DEFAULT_SET_UNIMPLEMENTED(translate);
|
|
|
|
API_DEFAULT_SET_UNIMPLEMENTED(event);
|
|
|
|
API_DEFAULT_SET_UNIMPLEMENTED(focus_next);
|
|
|
|
API_DEFAULT_SET_UNIMPLEMENTED(focus_direction);
|
|
|
|
|
2012-05-03 15:41:09 -07:00
|
|
|
/* NB: because those two weren't hooks before, translate the
|
|
|
|
* individual calls to them on the widgets as we bring them to the
|
|
|
|
* new class hierarchy. also, sub_object_{add,del} must be
|
|
|
|
* different than member_{add,del} here, because widget parenting
|
|
|
|
* on elm does not always imply parent and child will live on the
|
|
|
|
* same Evas layer */
|
|
|
|
API_DEFAULT_SET(sub_object_add);
|
|
|
|
API_DEFAULT_SET(sub_object_del);
|
|
|
|
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
#undef API_DEFAULT_SET
|
|
|
|
#undef API_DEFAULT_SET_UNIMPLEMENTED
|
|
|
|
|
|
|
|
sc->callbacks = _smart_callbacks;
|
|
|
|
}
|
|
|
|
|
|
|
|
// internal funcs
|
|
|
|
static inline Eina_Bool
|
|
|
|
_elm_widget_focus_chain_manager_is(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
API_ENTRY return EINA_FALSE;
|
|
|
|
|
|
|
|
if (_elm_legacy_is(obj)) return !!COMPAT_SMART_DATA(sd)->focus_next;
|
2012-05-20 21:17:11 -07:00
|
|
|
if (!sd->api) return EINA_FALSE;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
return sd->api->focus_next &&
|
|
|
|
(sd->api->focus_next != _elm_widget_focus_next_func_unimplemented);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline Eina_Bool
|
|
|
|
_elm_widget_focus_direction_manager_is(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
API_ENTRY return EINA_FALSE;
|
|
|
|
|
|
|
|
if (_elm_legacy_is(obj)) return !!COMPAT_SMART_DATA(sd)->focus_direction;
|
2012-05-20 21:17:11 -07:00
|
|
|
if (!sd->api) return EINA_FALSE;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
return sd->api->focus_direction &&
|
|
|
|
(sd->api->focus_direction !=
|
|
|
|
_elm_widget_focus_direction_func_unimplemented);
|
|
|
|
}
|
|
|
|
|
2010-09-28 20:59:28 -07:00
|
|
|
static void
|
|
|
|
_unfocus_parents(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
for (; obj; obj = elm_widget_parent_get(obj))
|
|
|
|
{
|
2011-12-27 21:51:10 -08:00
|
|
|
INTERNAL_ENTRY;
|
2010-09-28 20:59:28 -07:00
|
|
|
if (!sd->focused) return;
|
|
|
|
sd->focused = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_focus_parents(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
for (; obj; obj = elm_widget_parent_get(obj))
|
|
|
|
{
|
2011-12-27 21:51:10 -08:00
|
|
|
INTERNAL_ENTRY;
|
2010-09-28 20:59:28 -07:00
|
|
|
if (sd->focused) return;
|
|
|
|
sd->focused = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-10-07 23:38:20 -07:00
|
|
|
static void
|
2011-04-02 23:43:17 -07:00
|
|
|
_sub_obj_del(void *data,
|
|
|
|
Evas *e __UNUSED__,
|
|
|
|
Evas_Object *obj,
|
|
|
|
void *event_info __UNUSED__)
|
2008-10-07 23:38:20 -07:00
|
|
|
{
|
2012-05-03 15:40:58 -07:00
|
|
|
Elm_Widget_Smart_Data *sd = data;
|
2009-10-17 23:03:03 -07:00
|
|
|
|
2010-09-28 20:59:28 -07:00
|
|
|
if (_elm_widget_is(obj))
|
|
|
|
{
|
|
|
|
if (elm_widget_focus_get(obj)) _unfocus_parents(sd->obj);
|
|
|
|
}
|
2008-11-26 21:41:13 -08:00
|
|
|
if (obj == sd->resize_obj)
|
2012-05-22 00:05:07 -07:00
|
|
|
{
|
|
|
|
/* already dels sub object */
|
|
|
|
elm_widget_resize_object_set(sd->obj, NULL);
|
|
|
|
return;
|
|
|
|
}
|
2009-10-22 15:10:23 -07:00
|
|
|
else if (obj == sd->hover_obj)
|
2012-05-22 00:05:07 -07:00
|
|
|
{
|
|
|
|
sd->hover_obj = NULL;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
else if (_elm_legacy_is(sd->obj))
|
|
|
|
{
|
|
|
|
evas_object_smart_callback_call(sd->obj, "sub-object-del", obj);
|
|
|
|
sd->subobjs = eina_list_remove(sd->subobjs, obj);
|
|
|
|
}
|
2008-11-26 21:41:13 -08:00
|
|
|
else
|
2012-05-03 15:41:09 -07:00
|
|
|
{
|
|
|
|
if (!elm_widget_sub_object_del(sd->obj, obj))
|
|
|
|
ERR("failed to remove sub object %p from %p\n", obj, sd->obj);
|
|
|
|
}
|
2008-10-07 23:38:20 -07:00
|
|
|
}
|
|
|
|
|
2011-03-19 08:13:14 -07:00
|
|
|
static void
|
2011-04-02 23:43:17 -07:00
|
|
|
_sub_obj_hide(void *data __UNUSED__,
|
|
|
|
Evas *e __UNUSED__,
|
|
|
|
Evas_Object *obj,
|
|
|
|
void *event_info __UNUSED__)
|
2011-03-19 08:13:14 -07:00
|
|
|
{
|
2011-04-14 05:47:16 -07:00
|
|
|
elm_widget_focus_hide_handle(obj);
|
2011-03-19 08:13:14 -07:00
|
|
|
}
|
|
|
|
|
2008-10-22 01:58:56 -07:00
|
|
|
static void
|
2011-10-31 01:26:12 -07:00
|
|
|
_sub_obj_mouse_down(void *data,
|
|
|
|
Evas *e __UNUSED__,
|
|
|
|
Evas_Object *obj __UNUSED__,
|
|
|
|
void *event_info)
|
|
|
|
{
|
2012-05-03 15:40:58 -07:00
|
|
|
Elm_Widget_Smart_Data *sd = data;
|
2011-10-31 01:26:12 -07:00
|
|
|
Evas_Event_Mouse_Down *ev = event_info;
|
|
|
|
if (!(ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD))
|
2011-11-01 17:36:24 -07:00
|
|
|
sd->still_in = EINA_TRUE;
|
2011-10-31 01:26:12 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_sub_obj_mouse_move(void *data,
|
|
|
|
Evas *e __UNUSED__,
|
|
|
|
Evas_Object *obj,
|
|
|
|
void *event_info)
|
|
|
|
{
|
2012-05-03 15:40:58 -07:00
|
|
|
Elm_Widget_Smart_Data *sd = data;
|
2011-10-31 01:26:12 -07:00
|
|
|
Evas_Event_Mouse_Move *ev = event_info;
|
|
|
|
if (sd->still_in)
|
|
|
|
{
|
|
|
|
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD)
|
2011-11-01 17:27:04 -07:00
|
|
|
sd->still_in = EINA_FALSE;
|
2011-10-31 01:26:12 -07:00
|
|
|
else
|
|
|
|
{
|
|
|
|
Evas_Coord x, y, w, h;
|
|
|
|
evas_object_geometry_get(obj, &x, &y, &w, &h);
|
|
|
|
if ((ev->cur.canvas.x < x) || (ev->cur.canvas.y < y) ||
|
|
|
|
(ev->cur.canvas.x >= (x + w)) || (ev->cur.canvas.y >= (y + h)))
|
2011-11-01 17:27:04 -07:00
|
|
|
sd->still_in = EINA_FALSE;
|
2011-10-31 01:26:12 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_sub_obj_mouse_up(void *data,
|
2011-08-08 03:32:32 -07:00
|
|
|
Evas *e __UNUSED__,
|
|
|
|
Evas_Object *obj,
|
2011-10-31 01:26:12 -07:00
|
|
|
void *event_info __UNUSED__)
|
2008-10-22 01:58:56 -07:00
|
|
|
{
|
2012-05-03 15:40:58 -07:00
|
|
|
Elm_Widget_Smart_Data *sd = data;
|
2011-10-31 01:26:12 -07:00
|
|
|
if (sd->still_in)
|
|
|
|
elm_widget_focus_mouse_up_handle(obj);
|
2011-11-01 17:27:04 -07:00
|
|
|
sd->still_in = EINA_FALSE;
|
2008-10-22 01:58:56 -07:00
|
|
|
}
|
|
|
|
|
2010-09-13 00:56:23 -07:00
|
|
|
static void
|
2011-04-02 23:43:17 -07:00
|
|
|
_propagate_x_drag_lock(Evas_Object *obj,
|
|
|
|
int dir)
|
2010-09-13 00:56:23 -07:00
|
|
|
{
|
2011-12-27 21:51:10 -08:00
|
|
|
INTERNAL_ENTRY;
|
2011-04-02 23:43:17 -07:00
|
|
|
if (sd->parent_obj)
|
|
|
|
{
|
2012-05-03 15:40:58 -07:00
|
|
|
Elm_Widget_Smart_Data *sd2 = evas_object_smart_data_get(sd->parent_obj);
|
2011-04-02 23:43:17 -07:00
|
|
|
if (sd2)
|
|
|
|
{
|
|
|
|
sd2->child_drag_x_locked += dir;
|
|
|
|
_propagate_x_drag_lock(sd->parent_obj, dir);
|
|
|
|
}
|
|
|
|
}
|
2010-09-13 00:56:23 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-04-02 23:43:17 -07:00
|
|
|
_propagate_y_drag_lock(Evas_Object *obj,
|
|
|
|
int dir)
|
2010-09-13 00:56:23 -07:00
|
|
|
{
|
2011-12-27 21:51:10 -08:00
|
|
|
INTERNAL_ENTRY;
|
2011-04-02 23:43:17 -07:00
|
|
|
if (sd->parent_obj)
|
|
|
|
{
|
2012-05-03 15:40:58 -07:00
|
|
|
Elm_Widget_Smart_Data *sd2 = evas_object_smart_data_get(sd->parent_obj);
|
2011-04-02 23:43:17 -07:00
|
|
|
if (sd2)
|
|
|
|
{
|
|
|
|
sd2->child_drag_y_locked += dir;
|
|
|
|
_propagate_y_drag_lock(sd->parent_obj, dir);
|
|
|
|
}
|
|
|
|
}
|
2010-09-13 00:56:23 -07:00
|
|
|
}
|
|
|
|
|
2010-09-20 19:02:24 -07:00
|
|
|
static void
|
2011-04-02 23:43:17 -07:00
|
|
|
_propagate_event(void *data,
|
|
|
|
Evas *e __UNUSED__,
|
|
|
|
Evas_Object *obj,
|
|
|
|
void *event_info)
|
2010-09-20 19:02:24 -07:00
|
|
|
{
|
2011-12-27 21:51:10 -08:00
|
|
|
INTERNAL_ENTRY;
|
2011-04-02 23:43:17 -07:00
|
|
|
Evas_Callback_Type type = (Evas_Callback_Type)(long)data;
|
2010-09-20 19:02:24 -07:00
|
|
|
Evas_Event_Flags *event_flags = NULL;
|
2010-10-08 09:27:04 -07:00
|
|
|
|
2010-09-20 19:02:24 -07:00
|
|
|
switch (type)
|
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
case EVAS_CALLBACK_KEY_DOWN:
|
2011-04-03 04:55:56 -07:00
|
|
|
{
|
|
|
|
Evas_Event_Key_Down *ev = event_info;
|
|
|
|
event_flags = &(ev->event_flags);
|
|
|
|
}
|
2011-04-02 23:43:17 -07:00
|
|
|
break;
|
|
|
|
|
2011-04-01 04:20:18 -07:00
|
|
|
case EVAS_CALLBACK_KEY_UP:
|
2011-04-03 04:55:56 -07:00
|
|
|
{
|
|
|
|
Evas_Event_Key_Up *ev = event_info;
|
|
|
|
event_flags = &(ev->event_flags);
|
|
|
|
}
|
2011-04-02 23:43:17 -07:00
|
|
|
break;
|
|
|
|
|
2011-04-01 04:20:18 -07:00
|
|
|
case EVAS_CALLBACK_MOUSE_WHEEL:
|
2011-04-03 04:55:56 -07:00
|
|
|
{
|
|
|
|
Evas_Event_Mouse_Wheel *ev = event_info;
|
|
|
|
event_flags = &(ev->event_flags);
|
|
|
|
}
|
2011-04-02 23:43:17 -07:00
|
|
|
break;
|
|
|
|
|
2011-04-01 04:20:18 -07:00
|
|
|
default:
|
2011-04-02 23:43:17 -07:00
|
|
|
break;
|
2010-09-20 19:02:24 -07:00
|
|
|
}
|
2010-10-08 09:27:04 -07:00
|
|
|
|
2010-11-29 05:56:30 -08:00
|
|
|
elm_widget_event_propagate(obj, type, event_info, event_flags);
|
2010-09-20 19:02:24 -07:00
|
|
|
}
|
|
|
|
|
2010-09-13 00:56:23 -07:00
|
|
|
static void
|
|
|
|
_parent_focus(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
2011-05-27 03:44:21 -07:00
|
|
|
if (sd->focused) return;
|
2010-09-21 11:55:32 -07:00
|
|
|
|
2010-09-13 00:56:23 -07:00
|
|
|
Evas_Object *o = elm_widget_parent_get(obj);
|
2010-09-21 11:55:32 -07:00
|
|
|
sd->focus_order_on_calc = EINA_TRUE;
|
|
|
|
|
2011-05-27 03:44:21 -07:00
|
|
|
if (o) _parent_focus(o);
|
2010-09-21 11:55:32 -07:00
|
|
|
|
|
|
|
if (!sd->focus_order_on_calc)
|
|
|
|
return; /* we don't want to override it if by means of any of the
|
2011-04-01 04:20:18 -07:00
|
|
|
callbacks below one gets to calculate our order
|
|
|
|
first. */
|
2010-09-21 11:55:32 -07:00
|
|
|
|
2010-09-13 00:56:23 -07:00
|
|
|
focus_order++;
|
|
|
|
sd->focus_order = focus_order;
|
2012-05-20 21:17:11 -07:00
|
|
|
if (!sd->api) return;
|
2011-09-06 23:15:55 -07:00
|
|
|
if (sd->top_win_focused)
|
|
|
|
{
|
|
|
|
sd->focused = EINA_TRUE;
|
2012-08-03 09:43:17 -07:00
|
|
|
sd->api->on_focus(obj);
|
|
|
|
if (_elm_legacy_is(obj) && COMPAT_SMART_DATA(sd)->focus)
|
|
|
|
COMPAT_SMART_DATA(sd)->focus(obj);
|
2011-09-06 23:15:55 -07:00
|
|
|
_elm_widget_focus_region_show(obj);
|
|
|
|
}
|
2010-09-21 11:55:32 -07:00
|
|
|
sd->focus_order_on_calc = EINA_FALSE;
|
2012-06-25 22:54:45 -07:00
|
|
|
|
|
|
|
if (_elm_config->access_mode == ELM_ACCESS_MODE_ON)
|
|
|
|
_elm_access_highlight_set(obj);
|
2010-09-13 00:56:23 -07:00
|
|
|
}
|
|
|
|
|
2010-10-19 07:17:03 -07:00
|
|
|
static void
|
2011-04-02 23:43:17 -07:00
|
|
|
_elm_object_focus_chain_del_cb(void *data,
|
|
|
|
Evas *e __UNUSED__,
|
|
|
|
Evas_Object *obj,
|
|
|
|
void *event_info __UNUSED__)
|
2010-10-19 07:17:03 -07:00
|
|
|
{
|
2012-05-03 15:40:58 -07:00
|
|
|
Elm_Widget_Smart_Data *sd = data;
|
2010-10-19 07:17:03 -07:00
|
|
|
|
|
|
|
sd->focus_chain = eina_list_remove(sd->focus_chain, obj);
|
|
|
|
}
|
|
|
|
|
2010-09-13 00:56:23 -07:00
|
|
|
// exposed util funcs to elm
|
|
|
|
void
|
|
|
|
_elm_widget_type_clear(void)
|
|
|
|
{
|
|
|
|
const char **ptr;
|
2011-03-09 23:22:22 -08:00
|
|
|
|
2010-09-13 00:56:23 -07:00
|
|
|
EINA_LIST_FREE(widtypes, ptr)
|
|
|
|
{
|
|
|
|
eina_stringshare_del(*ptr);
|
|
|
|
*ptr = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-10-22 11:29:51 -07:00
|
|
|
void
|
|
|
|
_elm_widget_focus_region_show(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Evas_Coord x, y, w, h, ox, oy;
|
2012-05-03 15:40:58 -07:00
|
|
|
Elm_Widget_Smart_Data *sd2;
|
2010-10-22 11:29:51 -07:00
|
|
|
Evas_Object *o;
|
|
|
|
|
|
|
|
API_ENTRY return;
|
|
|
|
|
|
|
|
o = elm_widget_parent_get(obj);
|
|
|
|
if (!o) return;
|
|
|
|
|
|
|
|
elm_widget_focus_region_get(obj, &x, &y, &w, &h);
|
|
|
|
evas_object_geometry_get(obj, &ox, &oy, NULL, NULL);
|
|
|
|
while (o)
|
|
|
|
{
|
|
|
|
Evas_Coord px, py;
|
|
|
|
sd2 = evas_object_smart_data_get(o);
|
2012-07-24 19:43:32 -07:00
|
|
|
if (sd2->focus_region)
|
2010-10-22 11:29:51 -07:00
|
|
|
{
|
2012-07-04 14:36:50 -07:00
|
|
|
sd2->focus_region(o, x, y, w, h);
|
2010-10-22 11:29:51 -07:00
|
|
|
elm_widget_focus_region_get(o, &x, &y, &w, &h);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
evas_object_geometry_get(o, &px, &py, NULL, NULL);
|
|
|
|
x += ox - px;
|
|
|
|
y += oy - py;
|
|
|
|
ox = px;
|
|
|
|
oy = py;
|
|
|
|
}
|
|
|
|
o = elm_widget_parent_get(o);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
EAPI const Elm_Widget_Smart_Class *
|
|
|
|
elm_widget_smart_class_get(void)
|
|
|
|
{
|
|
|
|
static Elm_Widget_Smart_Class _sc =
|
|
|
|
ELM_WIDGET_SMART_CLASS_INIT_NAME_VERSION(SMART_NAME);
|
|
|
|
static const Elm_Widget_Smart_Class *class = NULL;
|
|
|
|
|
|
|
|
if (class)
|
|
|
|
return class;
|
|
|
|
|
|
|
|
_elm_widget_smart_set(&_sc);
|
|
|
|
class = &_sc;
|
|
|
|
|
|
|
|
return class;
|
|
|
|
}
|
|
|
|
|
2012-07-18 14:03:28 -07:00
|
|
|
EAPI Evas_Object *
|
|
|
|
elm_widget_add(Evas_Smart *smart,
|
|
|
|
Evas_Object *parent)
|
|
|
|
{
|
|
|
|
Evas *e;
|
|
|
|
Evas_Object *o;
|
|
|
|
|
|
|
|
e = evas_object_evas_get(parent);
|
|
|
|
if (!e) return NULL;
|
|
|
|
|
|
|
|
o = evas_object_smart_add(e, smart);
|
|
|
|
elm_widget_parent_set(o, parent);
|
|
|
|
|
|
|
|
return o;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_widget_parent_set(Evas_Object *obj,
|
|
|
|
Evas_Object *parent)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_DATA_GET(obj, sd);
|
|
|
|
|
|
|
|
if (!sd->api->parent_set) return;
|
|
|
|
|
|
|
|
sd->api->parent_set(obj, parent);
|
|
|
|
}
|
|
|
|
|
2010-09-13 00:56:23 -07:00
|
|
|
EAPI void
|
|
|
|
elm_widget_type_register(const char **ptr)
|
|
|
|
{
|
|
|
|
widtypes = eina_list_append(widtypes, (void *)ptr);
|
|
|
|
}
|
|
|
|
|
2011-08-04 10:10:17 -07:00
|
|
|
EAPI void
|
|
|
|
elm_widget_type_unregister(const char **ptr)
|
|
|
|
{
|
|
|
|
widtypes = eina_list_remove(widtypes, (void *)ptr);
|
|
|
|
}
|
|
|
|
|
2010-09-13 00:56:23 -07:00
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_widget_api_check(int ver)
|
|
|
|
{
|
|
|
|
if (ver != ELM_INTERNAL_API_VERSION)
|
|
|
|
{
|
|
|
|
CRITICAL("Elementary widget api versions do not match");
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
/* creating compat smart class */
|
2012-07-24 10:34:06 -07:00
|
|
|
ELM_INTERNAL_SMART_SUBCLASS_NEW
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
(SMART_NAME_COMPAT, _elm_widget_compat, Elm_Widget_Compat_Smart_Class,
|
|
|
|
Elm_Widget_Smart_Class, elm_widget_smart_class_get, NULL);
|
|
|
|
|
|
|
|
static void
|
|
|
|
_compat_smart_add(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
EVAS_SMART_DATA_ALLOC(obj, Elm_Widget_Compat_Smart_Data);
|
|
|
|
|
|
|
|
_elm_widget_compat_parent_sc->base.add(obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_compat_smart_del(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Edje_Signal_Data *esd;
|
|
|
|
|
|
|
|
ELM_WIDGET_DATA_GET(obj, sd);
|
|
|
|
|
|
|
|
if (COMPAT_SMART_DATA(sd)->del_pre)
|
|
|
|
COMPAT_SMART_DATA(sd)->del_pre(obj);
|
|
|
|
if (COMPAT_SMART_DATA(sd)->del)
|
|
|
|
COMPAT_SMART_DATA(sd)->del(obj);
|
|
|
|
|
|
|
|
if (COMPAT_SMART_DATA(sd)->type)
|
|
|
|
eina_stringshare_del(COMPAT_SMART_DATA(sd)->type);
|
|
|
|
|
|
|
|
EINA_LIST_FREE(COMPAT_SMART_DATA(sd)->edje_signals, esd)
|
|
|
|
{
|
|
|
|
eina_stringshare_del(esd->emission);
|
|
|
|
eina_stringshare_del(esd->source);
|
|
|
|
free(esd);
|
|
|
|
}
|
|
|
|
|
|
|
|
COMPAT_SMART_DATA(sd)->data = NULL;
|
|
|
|
|
|
|
|
_elm_widget_compat_parent_sc->base.del(obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_compat_smart_calculate(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_DATA_GET(obj, sd);
|
|
|
|
|
|
|
|
if (COMPAT_SMART_DATA(sd)->changed) COMPAT_SMART_DATA(sd)->changed(obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_widget_compat_smart_set_user(Elm_Widget_Compat_Smart_Class *sc)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_CLASS(sc)->base.add = _compat_smart_add;
|
|
|
|
ELM_WIDGET_CLASS(sc)->base.del = _compat_smart_del;
|
|
|
|
ELM_WIDGET_CLASS(sc)->base.calculate = _compat_smart_calculate;
|
|
|
|
|
|
|
|
/* proxying base class functions to instance ones on compat widgets
|
|
|
|
* (and overriding defaults -- unimplemented) */
|
|
|
|
#define API_BASE_COMPAT_SET(_cast, _prefix) \
|
|
|
|
ELM_WIDGET_CLASS(sc)->_prefix = (_cast)_elm_widget_##_prefix##_func_compat
|
|
|
|
|
|
|
|
/* base api */
|
|
|
|
API_BASE_COMPAT_SET(one_arg_class_func, on_focus);
|
|
|
|
API_BASE_COMPAT_SET(one_arg_class_func, disable);
|
|
|
|
API_BASE_COMPAT_SET(one_arg_class_func, theme);
|
|
|
|
API_BASE_COMPAT_SET(one_arg_class_func, translate);
|
|
|
|
API_BASE_COMPAT_SET(event_class_func, event);
|
|
|
|
API_BASE_COMPAT_SET(focus_next_func, focus_next);
|
|
|
|
API_BASE_COMPAT_SET(focus_direction_func, focus_direction);
|
|
|
|
|
|
|
|
#undef API_BASE_COMPAT_SET
|
|
|
|
}
|
|
|
|
|
2008-10-06 18:23:49 -07:00
|
|
|
EAPI Evas_Object *
|
2012-07-18 14:03:28 -07:00
|
|
|
elm_widget_compat_add(Evas *evas)
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
return evas_object_smart_add(evas, _elm_widget_compat_smart_class_new());
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_del_hook_set(Evas_Object *obj,
|
|
|
|
void (*func)(Evas_Object *obj))
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
|
|
|
COMPAT_SMART_DATA(sd)->del = func;
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
|
2008-10-24 19:11:06 -07:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_del_pre_hook_set(Evas_Object *obj,
|
|
|
|
void (*func)(Evas_Object *obj))
|
2008-10-24 19:11:06 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
|
|
|
COMPAT_SMART_DATA(sd)->del_pre = func;
|
2008-10-24 19:11:06 -07:00
|
|
|
}
|
|
|
|
|
2008-10-06 18:23:49 -07:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_focus_hook_set(Evas_Object *obj,
|
|
|
|
void (*func)(Evas_Object *obj))
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
|
|
|
COMPAT_SMART_DATA(sd)->focus = func;
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_activate_hook_set(Evas_Object *obj,
|
|
|
|
void (*func)(Evas_Object *obj))
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
|
|
|
COMPAT_SMART_DATA(sd)->activate = func;
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_disable_hook_set(Evas_Object *obj,
|
|
|
|
void (*func)(Evas_Object *obj))
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
|
|
|
COMPAT_SMART_DATA(sd)->disable = func;
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
|
2008-11-14 22:09:04 -08:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_theme_hook_set(Evas_Object *obj,
|
|
|
|
void (*func)(Evas_Object *obj))
|
2008-11-14 22:09:04 -08:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
|
|
|
COMPAT_SMART_DATA(sd)->theme = func;
|
2008-11-14 22:09:04 -08:00
|
|
|
}
|
|
|
|
|
2012-07-03 05:09:34 -07:00
|
|
|
EAPI void
|
|
|
|
elm_widget_access_hook_set(Evas_Object *obj,
|
|
|
|
void (*func)(Evas_Object *obj,
|
|
|
|
Eina_Bool is_access))
|
|
|
|
{
|
|
|
|
API_ENTRY return;
|
|
|
|
|
|
|
|
COMPAT_SMART_DATA(sd)->access = func;
|
|
|
|
}
|
|
|
|
|
2011-10-19 07:17:14 -07:00
|
|
|
EAPI void
|
|
|
|
elm_widget_translate_hook_set(Evas_Object *obj,
|
|
|
|
void (*func)(Evas_Object *obj))
|
|
|
|
{
|
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
|
|
|
COMPAT_SMART_DATA(sd)->translate = func;
|
2011-10-19 07:17:14 -07:00
|
|
|
}
|
|
|
|
|
2010-09-20 19:02:24 -07:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_event_hook_set(Evas_Object *obj,
|
|
|
|
Eina_Bool (*func)(Evas_Object *obj,
|
|
|
|
Evas_Object *source,
|
|
|
|
Evas_Callback_Type type,
|
|
|
|
void *event_info))
|
2010-09-20 19:02:24 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
|
|
|
COMPAT_SMART_DATA(sd)->event = func;
|
2010-09-20 19:02:24 -07:00
|
|
|
}
|
|
|
|
|
2011-06-28 23:41:10 -07:00
|
|
|
EAPI void
|
2011-07-04 02:18:16 -07:00
|
|
|
elm_widget_text_set_hook_set(Evas_Object *obj,
|
2012-01-09 16:33:51 -08:00
|
|
|
Elm_Widget_Text_Set_Cb func)
|
2011-06-28 23:41:10 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
|
|
|
COMPAT_SMART_DATA(sd)->text_set = func;
|
2011-06-28 23:41:10 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2011-07-04 02:18:16 -07:00
|
|
|
elm_widget_text_get_hook_set(Evas_Object *obj,
|
2012-01-09 16:33:51 -08:00
|
|
|
Elm_Widget_Text_Get_Cb func)
|
2011-06-28 23:41:10 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
|
|
|
COMPAT_SMART_DATA(sd)->text_get = func;
|
2011-06-28 23:41:10 -07:00
|
|
|
}
|
|
|
|
|
2011-07-27 02:49:14 -07:00
|
|
|
EAPI void
|
|
|
|
elm_widget_content_set_hook_set(Evas_Object *obj,
|
2012-01-09 16:33:51 -08:00
|
|
|
Elm_Widget_Content_Set_Cb func)
|
2011-07-27 02:49:14 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
|
|
|
COMPAT_SMART_DATA(sd)->content_set = func;
|
2011-07-27 02:49:14 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_widget_content_get_hook_set(Evas_Object *obj,
|
2012-01-09 16:33:51 -08:00
|
|
|
Elm_Widget_Content_Get_Cb func)
|
2011-07-27 02:49:14 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
|
|
|
COMPAT_SMART_DATA(sd)->content_get = func;
|
2011-07-27 02:49:14 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_widget_content_unset_hook_set(Evas_Object *obj,
|
2012-01-09 16:33:51 -08:00
|
|
|
Elm_Widget_Content_Unset_Cb func)
|
2011-07-27 02:49:14 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
|
|
|
COMPAT_SMART_DATA(sd)->content_unset = func;
|
2011-07-27 02:49:14 -07:00
|
|
|
}
|
|
|
|
|
2009-11-17 08:32:45 -08:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_changed_hook_set(Evas_Object *obj,
|
|
|
|
void (*func)(Evas_Object *obj))
|
2009-11-17 08:32:45 -08:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
|
|
|
COMPAT_SMART_DATA(sd)->changed = func;
|
2009-11-17 08:32:45 -08:00
|
|
|
}
|
|
|
|
|
2010-06-15 07:11:13 -07:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_signal_emit_hook_set(Evas_Object *obj,
|
|
|
|
void (*func)(Evas_Object *obj,
|
|
|
|
const char *emission,
|
|
|
|
const char *source))
|
2010-06-15 07:11:13 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
|
|
|
COMPAT_SMART_DATA(sd)->signal = func;
|
2010-06-15 07:11:13 -07:00
|
|
|
}
|
|
|
|
|
2010-06-25 15:38:32 -07:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_signal_callback_add_hook_set(Evas_Object *obj,
|
|
|
|
void (*func)(Evas_Object *obj,
|
|
|
|
const char *emission,
|
|
|
|
const char *source,
|
|
|
|
Edje_Signal_Cb func_cb,
|
|
|
|
void *data))
|
2010-06-25 15:38:32 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
|
|
|
COMPAT_SMART_DATA(sd)->callback_add = func;
|
2010-06-25 15:38:32 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_signal_callback_del_hook_set(Evas_Object *obj,
|
|
|
|
void (*func)(Evas_Object *obj,
|
|
|
|
const char *emission,
|
|
|
|
const char *source,
|
|
|
|
Edje_Signal_Cb func_cb,
|
|
|
|
void *data))
|
2010-06-25 15:38:32 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
|
|
|
COMPAT_SMART_DATA(sd)->callback_del = func;
|
2010-06-25 15:38:32 -07:00
|
|
|
}
|
|
|
|
|
2012-07-03 05:09:34 -07:00
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_widget_access(Evas_Object *obj, Eina_Bool is_access)
|
|
|
|
{
|
|
|
|
const Eina_List *l;
|
|
|
|
Evas_Object *child;
|
|
|
|
Eina_Bool ret = EINA_TRUE;
|
|
|
|
|
|
|
|
API_ENTRY return EINA_FALSE;
|
|
|
|
EINA_LIST_FOREACH(sd->subobjs, l, child)
|
|
|
|
ret &= elm_widget_access(child, is_access);
|
|
|
|
|
|
|
|
if (_elm_legacy_is(obj) && COMPAT_SMART_DATA(sd)->access)
|
|
|
|
COMPAT_SMART_DATA(sd)->access(obj, is_access);
|
|
|
|
else if (sd->api && sd->api->access)
|
|
|
|
sd->api->access(obj, is_access);
|
|
|
|
else
|
|
|
|
return EINA_FALSE;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-03-06 10:39:53 -08:00
|
|
|
EAPI Eina_Bool
|
2008-11-14 22:09:04 -08:00
|
|
|
elm_widget_theme(Evas_Object *obj)
|
|
|
|
{
|
2009-02-25 11:50:45 -08:00
|
|
|
const Eina_List *l;
|
|
|
|
Evas_Object *child;
|
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 *tt;
|
2010-09-25 15:01:19 -07:00
|
|
|
Elm_Cursor *cur;
|
2012-03-06 11:06:02 -08:00
|
|
|
Eina_Bool ret = EINA_TRUE;
|
2009-02-25 11:50:45 -08:00
|
|
|
|
2012-03-06 10:39:53 -08:00
|
|
|
API_ENTRY return EINA_FALSE;
|
2012-03-06 11:06:02 -08:00
|
|
|
EINA_LIST_FOREACH(sd->subobjs, l, child) ret &= elm_widget_theme(child);
|
2012-03-12 06:58:19 -07:00
|
|
|
if (sd->resize_obj && _elm_widget_is(sd->resize_obj))
|
|
|
|
ret &= elm_widget_theme(sd->resize_obj);
|
2012-03-06 11:06:02 -08:00
|
|
|
if (sd->hover_obj) ret &= elm_widget_theme(sd->hover_obj);
|
2010-11-05 01:37:31 -07:00
|
|
|
EINA_LIST_FOREACH(sd->tooltips, l, tt) elm_tooltip_theme(tt);
|
|
|
|
EINA_LIST_FOREACH(sd->cursors, l, cur) elm_cursor_theme(cur);
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
2012-05-20 21:17:11 -07:00
|
|
|
if (!sd->api) return EINA_FALSE;
|
|
|
|
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
ret &= sd->api->theme(obj);
|
2012-03-06 10:39:53 -08:00
|
|
|
|
2012-03-06 11:06:02 -08:00
|
|
|
return ret;
|
2010-11-05 01:37:31 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_theme_specific(Evas_Object *obj,
|
|
|
|
Elm_Theme *th,
|
|
|
|
Eina_Bool force)
|
2010-11-05 01:37:31 -07:00
|
|
|
{
|
|
|
|
const Eina_List *l;
|
|
|
|
Evas_Object *child;
|
|
|
|
Elm_Tooltip *tt;
|
|
|
|
Elm_Cursor *cur;
|
2011-01-10 23:48:02 -08:00
|
|
|
Elm_Theme *th2, *thdef;
|
2010-11-05 01:37:31 -07:00
|
|
|
|
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
2011-01-11 01:40:03 -08:00
|
|
|
thdef = elm_theme_default_get();
|
|
|
|
if (!th) th = thdef;
|
2010-11-05 01:37:31 -07:00
|
|
|
if (!force)
|
|
|
|
{
|
|
|
|
th2 = sd->theme;
|
2011-01-10 23:48:02 -08:00
|
|
|
if (!th2) th2 = thdef;
|
2010-11-05 01:37:31 -07:00
|
|
|
while (th2)
|
|
|
|
{
|
|
|
|
if (th2 == th)
|
|
|
|
{
|
2011-01-11 01:40:03 -08:00
|
|
|
force = EINA_TRUE;
|
|
|
|
break;
|
2010-11-05 01:37:31 -07:00
|
|
|
}
|
2011-01-10 23:48:02 -08:00
|
|
|
if (th2 == thdef) break;
|
2011-01-11 01:40:03 -08:00
|
|
|
th2 = th2->ref_theme;
|
|
|
|
if (!th2) th2 = thdef;
|
2010-11-05 01:37:31 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!force) return;
|
|
|
|
EINA_LIST_FOREACH(sd->subobjs, l, child)
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_theme_specific(child, th, force);
|
2010-11-05 01:37:31 -07:00
|
|
|
if (sd->resize_obj) elm_widget_theme(sd->resize_obj);
|
2008-11-14 22:09:04 -08:00
|
|
|
if (sd->hover_obj) elm_widget_theme(sd->hover_obj);
|
2010-09-13 00:56:23 -07:00
|
|
|
EINA_LIST_FOREACH(sd->tooltips, l, tt) elm_tooltip_theme(tt);
|
2010-09-25 15:01:19 -07:00
|
|
|
EINA_LIST_FOREACH(sd->cursors, l, cur) elm_cursor_theme(cur);
|
2012-05-20 21:17:11 -07:00
|
|
|
if (!sd->api) return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
sd->api->theme(obj);
|
2008-11-14 22:09:04 -08:00
|
|
|
}
|
|
|
|
|
2010-10-19 07:17:03 -07:00
|
|
|
/**
|
2010-12-07 11:17:50 -08:00
|
|
|
* @internal
|
|
|
|
*
|
2010-10-19 07:17:03 -07:00
|
|
|
* Set hook to get next object in object focus chain.
|
|
|
|
*
|
|
|
|
* @param obj The widget object.
|
|
|
|
* @param func The hook to be used with this widget.
|
|
|
|
*
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
2010-09-24 07:47:59 -07:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_focus_next_hook_set(Evas_Object *obj,
|
|
|
|
Eina_Bool (*func)(const Evas_Object *obj,
|
|
|
|
Elm_Focus_Direction dir,
|
|
|
|
Evas_Object **next))
|
2010-09-24 07:47:59 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
|
|
|
COMPAT_SMART_DATA(sd)->focus_next = func;
|
2010-09-24 07:47:59 -07:00
|
|
|
}
|
|
|
|
|
2012-05-02 20:02:54 -07:00
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Set hook to get near object in one direction.
|
|
|
|
*
|
|
|
|
* @param obj The widget object.
|
|
|
|
* @param func The hook to be used with this widget.
|
|
|
|
*
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
elm_widget_focus_direction_hook_set(Evas_Object *obj,
|
|
|
|
Eina_Bool (*func)(const Evas_Object *obj,
|
|
|
|
const Evas_Object *base,
|
|
|
|
double degree,
|
|
|
|
Evas_Object **direction,
|
|
|
|
double *weight))
|
|
|
|
{
|
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
COMPAT_SMART_DATA(sd)->focus_direction = func;
|
2012-05-02 20:02:54 -07:00
|
|
|
}
|
|
|
|
|
2011-02-03 07:52:49 -08:00
|
|
|
/**
|
|
|
|
* Returns the widget's mirrored mode.
|
|
|
|
*
|
|
|
|
* @param obj The widget.
|
|
|
|
* @return mirrored mode of the object.
|
|
|
|
*
|
|
|
|
**/
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_widget_mirrored_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
API_ENTRY return EINA_FALSE;
|
|
|
|
return sd->is_mirrored;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Sets the widget's mirrored mode.
|
|
|
|
*
|
|
|
|
* @param obj The widget.
|
|
|
|
* @param mirrored EINA_TRUE to set mirrored mode. EINA_FALSE to unset.
|
|
|
|
*/
|
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_mirrored_set(Evas_Object *obj,
|
2012-05-25 12:53:59 -07:00
|
|
|
Eina_Bool mirrored)
|
2011-02-03 07:52:49 -08:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
2012-05-25 12:53:59 -07:00
|
|
|
|
|
|
|
mirrored = !!mirrored;
|
|
|
|
|
|
|
|
if (sd->is_mirrored == mirrored) return;
|
|
|
|
|
|
|
|
sd->is_mirrored = mirrored;
|
|
|
|
elm_widget_theme(obj);
|
2011-02-03 07:52:49 -08:00
|
|
|
}
|
|
|
|
|
2012-05-25 12:53:59 -07:00
|
|
|
|
2011-02-09 08:13:58 -08:00
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
* Resets the mirrored mode from the system mirror mode for widgets that are in
|
|
|
|
* automatic mirroring mode. This function does not call elm_widget_theme.
|
|
|
|
*
|
|
|
|
* @param obj The widget.
|
|
|
|
* @param mirrored EINA_TRUE to set mirrored mode. EINA_FALSE to unset.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
_elm_widget_mirrored_reload(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
API_ENTRY return;
|
2012-03-06 04:04:25 -08:00
|
|
|
Eina_Bool mirrored = elm_config_mirrored_get();
|
2011-02-09 08:13:58 -08:00
|
|
|
if (elm_widget_mirrored_automatic_get(obj) && (sd->is_mirrored != mirrored))
|
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
sd->is_mirrored = mirrored;
|
2011-02-09 08:13:58 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the widget's mirrored mode setting.
|
|
|
|
*
|
|
|
|
* @param obj The widget.
|
|
|
|
* @return mirrored mode setting of the object.
|
|
|
|
*
|
|
|
|
**/
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_widget_mirrored_automatic_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
API_ENTRY return EINA_FALSE;
|
|
|
|
return sd->mirrored_auto_mode;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Sets the widget's mirrored mode setting.
|
|
|
|
* When widget in automatic mode, it follows the system mirrored mode set by
|
|
|
|
* elm_mirrored_set().
|
|
|
|
* @param obj The widget.
|
|
|
|
* @param automatic EINA_TRUE for auto mirrored mode. EINA_FALSE for manual.
|
|
|
|
*/
|
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_mirrored_automatic_set(Evas_Object *obj,
|
|
|
|
Eina_Bool automatic)
|
2011-02-09 08:13:58 -08:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
|
|
|
if (sd->mirrored_auto_mode != automatic)
|
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
sd->mirrored_auto_mode = automatic;
|
2011-02-09 08:13:58 -08:00
|
|
|
|
|
|
|
if (automatic)
|
|
|
|
{
|
2012-03-06 04:04:25 -08:00
|
|
|
elm_widget_mirrored_set(obj, elm_config_mirrored_get());
|
2011-02-09 08:13:58 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-10-06 18:23:49 -07:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_on_focus_hook_set(Evas_Object *obj,
|
|
|
|
void (*func)(void *data,
|
|
|
|
Evas_Object *obj),
|
|
|
|
void *data)
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
|
|
|
COMPAT_SMART_DATA(sd)->on_focus = func;
|
|
|
|
COMPAT_SMART_DATA(sd)->on_focus_data = data;
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_on_change_hook_set(Evas_Object *obj,
|
|
|
|
void (*func)(void *data,
|
|
|
|
Evas_Object *obj),
|
|
|
|
void *data)
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
|
|
|
COMPAT_SMART_DATA(sd)->on_change = func;
|
|
|
|
COMPAT_SMART_DATA(sd)->on_change_data = data;
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
|
2008-10-17 07:40:54 -07:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_on_show_region_hook_set(Evas_Object *obj,
|
|
|
|
void (*func)(void *data,
|
|
|
|
Evas_Object *obj),
|
|
|
|
void *data)
|
2008-10-17 07:40:54 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
|
|
|
sd->on_show_region = func;
|
2008-10-17 07:40:54 -07:00
|
|
|
sd->on_show_region_data = data;
|
|
|
|
}
|
|
|
|
|
2010-10-22 11:29:51 -07:00
|
|
|
/**
|
2010-12-07 11:17:50 -08:00
|
|
|
* @internal
|
|
|
|
*
|
2010-10-22 11:29:51 -07:00
|
|
|
* Set the hook to use to show the focused region.
|
|
|
|
*
|
|
|
|
* Whenever a new widget gets focused or it's needed to show the focused
|
|
|
|
* area of the current one, this hook will be called on objects that may
|
|
|
|
* want to move their children into their visible area.
|
|
|
|
* The area given in the hook function is relative to the @p obj widget.
|
|
|
|
*
|
|
|
|
* @param obj The widget object
|
|
|
|
* @param func The function to call to show the specified area.
|
|
|
|
*
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_focus_region_hook_set(Evas_Object *obj,
|
|
|
|
void (*func)(Evas_Object *obj,
|
|
|
|
Evas_Coord x,
|
|
|
|
Evas_Coord y,
|
|
|
|
Evas_Coord w,
|
|
|
|
Evas_Coord h))
|
2010-10-22 11:29:51 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
2012-07-04 14:36:50 -07:00
|
|
|
sd->focus_region = func;
|
2010-10-22 11:29:51 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2010-12-07 11:17:50 -08:00
|
|
|
* @internal
|
|
|
|
*
|
2010-10-22 11:29:51 -07:00
|
|
|
* Set the hook to retrieve the focused region of a widget.
|
|
|
|
*
|
|
|
|
* This hook will be called by elm_widget_focus_region_get() whenever
|
|
|
|
* it's needed to get the focused area of a widget. The area must be relative
|
|
|
|
* to the widget itself and if no hook is set, it will default to the entire
|
|
|
|
* object.
|
|
|
|
*
|
|
|
|
* @param obj The widget object
|
|
|
|
* @param func The function used to retrieve the focus region.
|
|
|
|
*
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_on_focus_region_hook_set(Evas_Object *obj,
|
|
|
|
void (*func)(const Evas_Object *obj,
|
|
|
|
Evas_Coord *x,
|
|
|
|
Evas_Coord *y,
|
|
|
|
Evas_Coord *w,
|
|
|
|
Evas_Coord *h))
|
2010-10-22 11:29:51 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
2012-07-25 15:03:15 -07:00
|
|
|
sd->on_focus_region = func;
|
2010-10-22 11:29:51 -07:00
|
|
|
}
|
|
|
|
|
2008-10-06 18:23:49 -07:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_data_set(Evas_Object *obj,
|
|
|
|
void *data)
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
|
|
|
if (!_elm_widget_is(obj)) return;
|
|
|
|
|
|
|
|
COMPAT_SMART_DATA(sd)->data = data;
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void *
|
2009-02-25 07:54:26 -08:00
|
|
|
elm_widget_data_get(const Evas_Object *obj)
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return NULL;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
|
|
|
if (!_elm_legacy_is(obj)) return NULL;
|
|
|
|
|
|
|
|
return COMPAT_SMART_DATA(sd)->data;
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
EAPI Eina_Bool
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_sub_object_add(Evas_Object *obj,
|
|
|
|
Evas_Object *sobj)
|
2008-09-29 23:58:56 -07:00
|
|
|
{
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
API_ENTRY return EINA_FALSE;
|
|
|
|
EINA_SAFETY_ON_TRUE_RETURN_VAL(obj == sobj, EINA_FALSE);
|
|
|
|
|
2012-05-20 21:17:11 -07:00
|
|
|
if (!sd->api) return EINA_FALSE;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
if (!_elm_legacy_is(obj)) return sd->api->sub_object_add(obj, sobj);
|
|
|
|
|
|
|
|
/* this part will go away once all widgets are migrated to the new schema */
|
2009-02-02 21:09:03 -08:00
|
|
|
double scale, pscale = elm_widget_scale_get(sobj);
|
2010-05-11 18:03:46 -07:00
|
|
|
Elm_Theme *th, *pth = elm_widget_theme_get(sobj);
|
2011-02-03 07:52:49 -08:00
|
|
|
Eina_Bool mirrored, pmirrored = elm_widget_mirrored_get(obj);
|
2009-10-17 23:03:03 -07:00
|
|
|
|
2012-02-10 04:29:04 -08:00
|
|
|
if (sobj == sd->parent_obj)
|
|
|
|
{
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
if (!elm_widget_sub_object_del(sobj, obj)) return EINA_FALSE;
|
2012-02-10 04:29:04 -08:00
|
|
|
WRN("You passed a parent object of obj = %p as the sub object = %p!", obj, sobj);
|
|
|
|
}
|
|
|
|
|
2010-10-08 09:27:01 -07:00
|
|
|
if (_elm_widget_is(sobj))
|
2008-09-29 23:58:56 -07:00
|
|
|
{
|
2012-05-03 15:40:58 -07:00
|
|
|
Elm_Widget_Smart_Data *sd2 = evas_object_smart_data_get(sobj);
|
2010-10-08 09:27:01 -07:00
|
|
|
if (sd2)
|
|
|
|
{
|
|
|
|
if (sd2->parent_obj == obj)
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
return EINA_TRUE;
|
2011-03-10 04:04:00 -08:00
|
|
|
if (sd2->parent_obj)
|
|
|
|
elm_widget_sub_object_del(sd2->parent_obj, sobj);
|
2010-10-08 09:27:01 -07:00
|
|
|
sd2->parent_obj = obj;
|
2012-03-20 01:42:23 -07:00
|
|
|
_elm_widget_top_win_focused_set(sobj, sd->top_win_focused);
|
2010-10-22 14:41:22 -07:00
|
|
|
if (!sd->child_can_focus && (_is_focusable(sobj)))
|
2012-05-31 00:15:28 -07:00
|
|
|
{
|
|
|
|
Elm_Widget_Smart_Data *sdt = evas_object_smart_data_get(obj);
|
|
|
|
sdt->child_can_focus = EINA_TRUE;
|
|
|
|
while (sdt->parent_obj)
|
|
|
|
{
|
|
|
|
sdt = evas_object_smart_data_get(sdt->parent_obj);
|
|
|
|
if (sdt->child_can_focus) break;
|
|
|
|
sdt->child_can_focus = EINA_TRUE;
|
|
|
|
}
|
|
|
|
}
|
2010-10-08 09:27:01 -07:00
|
|
|
}
|
2008-09-29 23:58:56 -07:00
|
|
|
}
|
2010-10-08 09:27:01 -07:00
|
|
|
else
|
2008-09-29 23:58:56 -07:00
|
|
|
{
|
2010-10-14 23:04:33 -07:00
|
|
|
void *data = evas_object_data_get(sobj, "elm-parent");
|
2010-10-08 09:27:01 -07:00
|
|
|
if (data)
|
|
|
|
{
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
if (data == obj) return EINA_TRUE;
|
2012-05-03 15:41:09 -07:00
|
|
|
elm_widget_sub_object_del(data, sobj);
|
2010-10-08 09:27:01 -07:00
|
|
|
}
|
2008-09-29 23:58:56 -07:00
|
|
|
}
|
2010-10-08 09:27:01 -07:00
|
|
|
sd->subobjs = eina_list_append(sd->subobjs, sobj);
|
2010-03-22 14:36:59 -07:00
|
|
|
evas_object_data_set(sobj, "elm-parent", obj);
|
2011-04-01 04:20:18 -07:00
|
|
|
evas_object_event_callback_add(sobj, EVAS_CALLBACK_DEL, _sub_obj_del, sd);
|
2011-03-19 08:13:14 -07:00
|
|
|
if (_elm_widget_is(sobj))
|
|
|
|
evas_object_event_callback_add(sobj, EVAS_CALLBACK_HIDE, _sub_obj_hide, sd);
|
2008-10-06 23:55:11 -07:00
|
|
|
evas_object_smart_callback_call(obj, "sub-object-add", sobj);
|
2009-02-02 21:09:03 -08:00
|
|
|
scale = elm_widget_scale_get(sobj);
|
2010-05-11 18:03:46 -07:00
|
|
|
th = elm_widget_theme_get(sobj);
|
2011-02-03 07:52:49 -08:00
|
|
|
mirrored = elm_widget_mirrored_get(sobj);
|
|
|
|
if ((scale != pscale) || (th != pth) || (pmirrored != mirrored)) elm_widget_theme(sobj);
|
2010-10-08 09:27:01 -07:00
|
|
|
if (elm_widget_focus_get(sobj)) _focus_parents(obj);
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
|
|
|
return EINA_TRUE;
|
2008-09-29 23:58:56 -07:00
|
|
|
}
|
|
|
|
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
EAPI Eina_Bool
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_sub_object_del(Evas_Object *obj,
|
|
|
|
Evas_Object *sobj)
|
2008-09-29 23:58:56 -07:00
|
|
|
{
|
2010-03-22 14:36:59 -07:00
|
|
|
Evas_Object *sobj_parent;
|
|
|
|
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
API_ENTRY return EINA_FALSE;
|
|
|
|
EINA_SAFETY_ON_TRUE_RETURN_VAL(obj == sobj, EINA_FALSE);
|
|
|
|
|
|
|
|
if (!sobj) return EINA_FALSE;
|
|
|
|
|
2012-05-20 21:17:11 -07:00
|
|
|
if (!sd->api) return EINA_FALSE;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
if (!_elm_legacy_is(obj)) return sd->api->sub_object_del(obj, sobj);
|
|
|
|
|
|
|
|
/* this part will go away once all widgets are migrated to the new schema */
|
2010-03-22 14:36:59 -07:00
|
|
|
sobj_parent = evas_object_data_del(sobj, "elm-parent");
|
|
|
|
if (sobj_parent != obj)
|
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
static int abort_on_warn = -1;
|
2011-12-04 19:26:19 -08:00
|
|
|
ERR("removing sub object %p (%s) from parent %p (%s), "
|
2011-12-04 19:27:32 -08:00
|
|
|
"but elm-parent is different %p (%s)!",
|
2011-12-04 19:26:19 -08:00
|
|
|
sobj, elm_widget_type_get(sobj), obj, elm_widget_type_get(obj),
|
2011-12-04 19:27:32 -08:00
|
|
|
sobj_parent, elm_widget_type_get(sobj_parent));
|
2011-04-01 04:20:18 -07:00
|
|
|
if (EINA_UNLIKELY(abort_on_warn == -1))
|
|
|
|
{
|
|
|
|
if (getenv("ELM_ERROR_ABORT")) abort_on_warn = 1;
|
|
|
|
else abort_on_warn = 0;
|
|
|
|
}
|
|
|
|
if (abort_on_warn == 1) abort();
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
|
|
|
return EINA_FALSE;
|
2010-03-22 14:36:59 -07:00
|
|
|
}
|
|
|
|
if (_elm_widget_is(sobj))
|
2008-10-24 19:11:06 -07:00
|
|
|
{
|
2011-11-18 19:47:27 -08:00
|
|
|
if (elm_widget_focus_get(sobj))
|
|
|
|
{
|
|
|
|
elm_widget_tree_unfocusable_set(sobj, EINA_TRUE);
|
|
|
|
elm_widget_tree_unfocusable_set(sobj, EINA_FALSE);
|
|
|
|
}
|
2011-06-17 22:47:57 -07:00
|
|
|
if ((sd->child_can_focus) && (_is_focusable(sobj)))
|
|
|
|
{
|
|
|
|
Evas_Object *subobj;
|
|
|
|
const Eina_List *l;
|
2012-05-31 00:15:28 -07:00
|
|
|
Elm_Widget_Smart_Data *sdt = evas_object_smart_data_get(obj);
|
|
|
|
while (1)
|
2011-06-17 22:47:57 -07:00
|
|
|
{
|
2012-05-31 00:15:28 -07:00
|
|
|
sdt->child_can_focus = EINA_FALSE;
|
|
|
|
EINA_LIST_FOREACH(sdt->subobjs, l, subobj)
|
2011-06-17 22:47:57 -07:00
|
|
|
{
|
2012-05-31 00:15:28 -07:00
|
|
|
if ((subobj != sobj) && (_is_focusable(subobj)))
|
|
|
|
{
|
|
|
|
sdt->child_can_focus = EINA_TRUE;
|
|
|
|
break;
|
|
|
|
}
|
2011-06-17 22:47:57 -07:00
|
|
|
}
|
2012-05-31 00:15:28 -07:00
|
|
|
if (sdt->child_can_focus) break;
|
|
|
|
if (!sdt->parent_obj) break;
|
|
|
|
sdt = evas_object_smart_data_get(sdt->parent_obj);
|
2011-06-17 22:47:57 -07:00
|
|
|
}
|
|
|
|
}
|
2012-05-03 15:40:58 -07:00
|
|
|
Elm_Widget_Smart_Data *sd2 = evas_object_smart_data_get(sobj);
|
2011-11-18 19:50:58 -08:00
|
|
|
if (sd2)
|
|
|
|
{
|
|
|
|
sd2->parent_obj = NULL;
|
2012-05-03 15:41:09 -07:00
|
|
|
if (sd2->resize_obj == sobj) sd2->resize_obj = NULL;
|
|
|
|
|
|
|
|
sd->subobjs = eina_list_remove(sd->subobjs, sobj);
|
2011-11-18 19:50:58 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
sd->subobjs = eina_list_remove(sd->subobjs, sobj);
|
2008-10-24 19:11:06 -07:00
|
|
|
}
|
2010-10-18 10:01:11 -07:00
|
|
|
else
|
|
|
|
sd->subobjs = eina_list_remove(sd->subobjs, sobj);
|
2011-03-09 23:22:22 -08:00
|
|
|
evas_object_event_callback_del_full(sobj, EVAS_CALLBACK_DEL,
|
2010-09-13 00:56:23 -07:00
|
|
|
_sub_obj_del, sd);
|
2011-03-19 08:13:14 -07:00
|
|
|
if (_elm_widget_is(sobj))
|
|
|
|
evas_object_event_callback_del_full(sobj, EVAS_CALLBACK_HIDE,
|
|
|
|
_sub_obj_hide, sd);
|
2008-10-06 23:55:11 -07:00
|
|
|
evas_object_smart_callback_call(obj, "sub-object-del", sobj);
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
|
|
|
return EINA_TRUE;
|
2012-05-02 18:19:05 -07:00
|
|
|
}
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70627
2012-05-02 09:57:38 -07:00
|
|
|
|
2012-05-03 15:41:09 -07:00
|
|
|
/* a resize object is a sub object with some more callbacks on it and
|
|
|
|
* a smart member of the parent
|
|
|
|
*/
|
2008-10-06 18:23:49 -07:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_resize_object_set(Evas_Object *obj,
|
|
|
|
Evas_Object *sobj)
|
2008-09-29 23:58:56 -07:00
|
|
|
{
|
2012-05-03 15:41:09 -07:00
|
|
|
Evas_Object *parent;
|
|
|
|
|
2008-10-06 18:23:49 -07:00
|
|
|
API_ENTRY return;
|
2012-05-03 15:41:09 -07:00
|
|
|
|
|
|
|
if (sd->resize_obj == sobj) return;
|
|
|
|
|
2010-10-14 23:04:33 -07:00
|
|
|
// orphan previous resize obj
|
2008-10-07 23:38:20 -07:00
|
|
|
if (sd->resize_obj)
|
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
evas_object_clip_unset(sd->resize_obj);
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
2012-02-15 01:02:07 -08:00
|
|
|
evas_object_event_callback_del_full(sd->resize_obj,
|
|
|
|
EVAS_CALLBACK_MOUSE_DOWN,
|
2011-10-31 01:26:12 -07:00
|
|
|
_sub_obj_mouse_down, sd);
|
2012-02-15 01:02:07 -08:00
|
|
|
evas_object_event_callback_del_full(sd->resize_obj,
|
|
|
|
EVAS_CALLBACK_MOUSE_MOVE,
|
2011-10-31 01:26:12 -07:00
|
|
|
_sub_obj_mouse_move, sd);
|
2012-02-15 01:02:07 -08:00
|
|
|
evas_object_event_callback_del_full(sd->resize_obj,
|
|
|
|
EVAS_CALLBACK_MOUSE_UP,
|
2011-08-08 03:32:32 -07:00
|
|
|
_sub_obj_mouse_up, sd);
|
2011-04-01 04:20:18 -07:00
|
|
|
evas_object_smart_member_del(sd->resize_obj);
|
2012-02-15 01:02:07 -08:00
|
|
|
|
2010-09-28 22:27:42 -07:00
|
|
|
if (_elm_widget_is(sd->resize_obj))
|
|
|
|
{
|
|
|
|
if (elm_widget_focus_get(sd->resize_obj)) _unfocus_parents(obj);
|
|
|
|
}
|
2012-05-03 15:41:09 -07:00
|
|
|
|
|
|
|
elm_widget_sub_object_del(obj, sd->resize_obj);
|
2008-10-07 23:38:20 -07:00
|
|
|
}
|
2011-10-19 10:07:15 -07:00
|
|
|
|
2011-10-19 10:36:51 -07:00
|
|
|
sd->resize_obj = sobj;
|
2011-10-19 10:07:15 -07:00
|
|
|
if (!sobj) return;
|
|
|
|
|
2010-10-14 23:04:33 -07:00
|
|
|
// orphan new resize obj
|
2012-05-03 15:41:09 -07:00
|
|
|
parent = evas_object_data_get(sobj, "elm-parent");
|
|
|
|
if (parent && parent != obj)
|
2012-05-02 18:19:05 -07:00
|
|
|
{
|
2012-05-03 15:41:09 -07:00
|
|
|
ELM_WIDGET_DATA_GET(parent, sdp);
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
2012-05-03 15:41:09 -07:00
|
|
|
/* should be there, just being paranoid */
|
|
|
|
if (sdp)
|
|
|
|
{
|
|
|
|
if (sdp->resize_obj == sobj)
|
|
|
|
elm_widget_resize_object_set(parent, NULL);
|
|
|
|
else
|
|
|
|
elm_widget_sub_object_del(parent, sobj);
|
|
|
|
}
|
2012-05-02 18:19:05 -07:00
|
|
|
}
|
2011-10-19 10:07:15 -07:00
|
|
|
|
2012-05-03 15:41:09 -07:00
|
|
|
elm_widget_sub_object_add(obj, sobj);
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
2011-10-19 10:07:15 -07:00
|
|
|
evas_object_smart_member_add(sobj, obj);
|
2012-05-03 15:41:09 -07:00
|
|
|
|
2011-10-31 01:26:12 -07:00
|
|
|
evas_object_event_callback_add(sobj, EVAS_CALLBACK_MOUSE_DOWN,
|
|
|
|
_sub_obj_mouse_down, sd);
|
|
|
|
evas_object_event_callback_add(sobj, EVAS_CALLBACK_MOUSE_MOVE,
|
|
|
|
_sub_obj_mouse_move, sd);
|
2011-10-19 10:07:15 -07:00
|
|
|
evas_object_event_callback_add(sobj, EVAS_CALLBACK_MOUSE_UP,
|
|
|
|
_sub_obj_mouse_up, sd);
|
|
|
|
_smart_reconfigure(sd);
|
2008-10-07 23:38:20 -07:00
|
|
|
}
|
|
|
|
|
2012-05-03 15:41:09 -07:00
|
|
|
/* WARNING: the programmer is responsible, in the scenario of
|
|
|
|
* exchanging a hover object, of cleaning the old hover "target"
|
|
|
|
* before
|
|
|
|
*/
|
2008-10-07 23:38:20 -07:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_hover_object_set(Evas_Object *obj,
|
|
|
|
Evas_Object *sobj)
|
2008-10-07 23:38:20 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
|
|
|
if (sd->hover_obj)
|
2009-10-22 15:10:23 -07:00
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
evas_object_event_callback_del_full(sd->hover_obj, EVAS_CALLBACK_DEL,
|
|
|
|
_sub_obj_del, sd);
|
2009-10-22 15:10:23 -07:00
|
|
|
}
|
2008-10-07 23:38:20 -07:00
|
|
|
sd->hover_obj = sobj;
|
|
|
|
if (sd->hover_obj)
|
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
evas_object_event_callback_add(sobj, EVAS_CALLBACK_DEL,
|
2010-09-13 00:56:23 -07:00
|
|
|
_sub_obj_del, sd);
|
2011-04-01 04:20:18 -07:00
|
|
|
_smart_reconfigure(sd);
|
2008-10-07 23:38:20 -07:00
|
|
|
}
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_can_focus_set(Evas_Object *obj,
|
|
|
|
Eina_Bool can_focus)
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
2012-02-21 04:36:54 -08:00
|
|
|
|
|
|
|
can_focus = !!can_focus;
|
|
|
|
|
|
|
|
if (sd->can_focus == can_focus) return;
|
2012-02-22 20:09:05 -08:00
|
|
|
sd->can_focus = can_focus;
|
|
|
|
if (sd->can_focus)
|
2010-09-20 19:02:24 -07:00
|
|
|
{
|
|
|
|
evas_object_event_callback_add(obj, EVAS_CALLBACK_KEY_DOWN,
|
|
|
|
_propagate_event,
|
2011-04-02 23:43:17 -07:00
|
|
|
(void *)(long)EVAS_CALLBACK_KEY_DOWN);
|
2010-09-20 19:02:24 -07:00
|
|
|
evas_object_event_callback_add(obj, EVAS_CALLBACK_KEY_UP,
|
|
|
|
_propagate_event,
|
2011-04-02 23:43:17 -07:00
|
|
|
(void *)(long)EVAS_CALLBACK_KEY_UP);
|
2010-12-06 04:45:41 -08:00
|
|
|
evas_object_event_callback_add(obj, EVAS_CALLBACK_MOUSE_WHEEL,
|
|
|
|
_propagate_event,
|
|
|
|
(void *)(long)EVAS_CALLBACK_MOUSE_WHEEL);
|
2010-09-20 19:02:24 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
evas_object_event_callback_del(obj, EVAS_CALLBACK_KEY_DOWN,
|
|
|
|
_propagate_event);
|
|
|
|
evas_object_event_callback_del(obj, EVAS_CALLBACK_KEY_UP,
|
|
|
|
_propagate_event);
|
2010-12-06 04:45:41 -08:00
|
|
|
evas_object_event_callback_del(obj, EVAS_CALLBACK_MOUSE_WHEEL,
|
|
|
|
_propagate_event);
|
2010-09-20 19:02:24 -07:00
|
|
|
}
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
|
2010-09-24 07:47:52 -07:00
|
|
|
EAPI Eina_Bool
|
2009-02-25 07:54:26 -08:00
|
|
|
elm_widget_can_focus_get(const Evas_Object *obj)
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
2010-09-24 07:47:52 -07:00
|
|
|
API_ENTRY return EINA_FALSE;
|
|
|
|
return sd->can_focus;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_widget_child_can_focus_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
API_ENTRY return EINA_FALSE;
|
|
|
|
return sd->child_can_focus;
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
|
2011-07-27 23:58:29 -07:00
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* This API makes the widget object and its children to be unfocusable.
|
|
|
|
*
|
|
|
|
* This API can be helpful for an object to be deleted.
|
2011-07-28 01:14:30 -07:00
|
|
|
* When an object will be deleted soon, it and its children may not
|
2011-07-27 23:58:29 -07:00
|
|
|
* want to get focus (by focus reverting or by other focus controls).
|
|
|
|
* Then, just use this API before deleting.
|
|
|
|
*
|
|
|
|
* @param obj The widget root of sub-tree
|
|
|
|
* @param tree_unfocusable If true, set the object sub-tree as unfocusable
|
|
|
|
*
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
elm_widget_tree_unfocusable_set(Evas_Object *obj,
|
|
|
|
Eina_Bool tree_unfocusable)
|
|
|
|
{
|
|
|
|
API_ENTRY return;
|
|
|
|
|
2012-02-21 04:36:54 -08:00
|
|
|
tree_unfocusable = !!tree_unfocusable;
|
2011-07-27 23:58:29 -07:00
|
|
|
if (sd->tree_unfocusable == tree_unfocusable) return;
|
2012-02-21 04:36:54 -08:00
|
|
|
sd->tree_unfocusable = tree_unfocusable;
|
2011-07-27 23:58:29 -07:00
|
|
|
elm_widget_focus_tree_unfocusable_handle(obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* This returns true, if the object sub-tree is unfocusable.
|
|
|
|
*
|
|
|
|
* @param obj The widget root of sub-tree
|
|
|
|
* @return EINA_TRUE if the object sub-tree is unfocusable
|
|
|
|
*
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_widget_tree_unfocusable_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
API_ENTRY return EINA_FALSE;
|
|
|
|
return sd->tree_unfocusable;
|
|
|
|
}
|
|
|
|
|
2011-08-05 01:25:07 -07:00
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Get the list of focusable child objects.
|
|
|
|
*
|
|
|
|
* This function retruns list of child objects which can get focus.
|
|
|
|
*
|
|
|
|
* @param obj The parent widget
|
|
|
|
* @retrun list of focusable child objects.
|
|
|
|
*
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
|
|
|
EAPI Eina_List *
|
|
|
|
elm_widget_can_focus_child_list_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
API_ENTRY return NULL;
|
|
|
|
|
|
|
|
const Eina_List *l;
|
|
|
|
Eina_List *child_list = NULL;
|
|
|
|
Evas_Object *child;
|
|
|
|
|
|
|
|
if (sd->subobjs)
|
|
|
|
{
|
|
|
|
EINA_LIST_FOREACH(sd->subobjs, l, child)
|
|
|
|
{
|
|
|
|
if ((elm_widget_can_focus_get(child)) &&
|
|
|
|
(evas_object_visible_get(child)) &&
|
|
|
|
(!elm_widget_disabled_get(child)))
|
|
|
|
child_list = eina_list_append(child_list, child);
|
|
|
|
else if (elm_widget_is(child))
|
|
|
|
{
|
|
|
|
Eina_List *can_focus_list;
|
|
|
|
can_focus_list = elm_widget_can_focus_child_list_get(child);
|
|
|
|
if (can_focus_list)
|
|
|
|
child_list = eina_list_merge(child_list, can_focus_list);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return child_list;
|
|
|
|
}
|
|
|
|
|
Begins highlight on focused object.
There's still work to do here, particularly in the theme, but it has
something nice and fun to see the code working.
The idea behind this:
Window tracks focused object and sends the highlight object(s) to it. These
are simple edje objects, one on top, one below the focused widget for nice
effects. Widgets can choose to ignore the highlight and this will be sent to
the parent object, if it doesn't ignore it as well.
About the bottom object, it doesn't work now. For the most part, focused
widget will always be a member of some smart object, so stacking won't work
and the desired effect is nowhere to be seen. This will be worked out later.
To be done now:
- Let the theme for a widget define its own highlight, disabling if needed
the standard one for those objects.
- Needed base in code to allow animations when switching focus. All in theme.
- Properly test all widgets and fix some things that will most likely work
in weird ways, given the nature of Evas/Edje and how Elementary makes use
of them.
- Forgot the rest, stay tuned, test, report, give ideas, plant a tree.
Work started by glima, continued with some refactors by me when he
decided he needed vacations.
SVN revision: 52524
2010-09-20 15:18:58 -07:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_highlight_ignore_set(Evas_Object *obj,
|
|
|
|
Eina_Bool ignore)
|
Begins highlight on focused object.
There's still work to do here, particularly in the theme, but it has
something nice and fun to see the code working.
The idea behind this:
Window tracks focused object and sends the highlight object(s) to it. These
are simple edje objects, one on top, one below the focused widget for nice
effects. Widgets can choose to ignore the highlight and this will be sent to
the parent object, if it doesn't ignore it as well.
About the bottom object, it doesn't work now. For the most part, focused
widget will always be a member of some smart object, so stacking won't work
and the desired effect is nowhere to be seen. This will be worked out later.
To be done now:
- Let the theme for a widget define its own highlight, disabling if needed
the standard one for those objects.
- Needed base in code to allow animations when switching focus. All in theme.
- Properly test all widgets and fix some things that will most likely work
in weird ways, given the nature of Evas/Edje and how Elementary makes use
of them.
- Forgot the rest, stay tuned, test, report, give ideas, plant a tree.
Work started by glima, continued with some refactors by me when he
decided he needed vacations.
SVN revision: 52524
2010-09-20 15:18:58 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
|
|
|
sd->highlight_ignore = !!ignore;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_widget_highlight_ignore_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
API_ENTRY return EINA_FALSE;
|
|
|
|
return sd->highlight_ignore;
|
|
|
|
}
|
|
|
|
|
2010-09-22 15:33:57 -07:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_highlight_in_theme_set(Evas_Object *obj,
|
|
|
|
Eina_Bool highlight)
|
2010-09-22 15:33:57 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
|
|
|
sd->highlight_in_theme = !!highlight;
|
|
|
|
/* FIXME: if focused, it should switch from one mode to the other */
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_widget_highlight_in_theme_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
API_ENTRY return EINA_FALSE;
|
|
|
|
return sd->highlight_in_theme;
|
|
|
|
}
|
|
|
|
|
2010-09-27 21:28:14 -07:00
|
|
|
EAPI Eina_Bool
|
2009-02-25 07:54:26 -08:00
|
|
|
elm_widget_focus_get(const Evas_Object *obj)
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
2010-09-27 21:28:14 -07:00
|
|
|
API_ENTRY return EINA_FALSE;
|
2008-10-06 18:23:49 -07:00
|
|
|
return sd->focused;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Evas_Object *
|
2009-02-25 07:54:26 -08:00
|
|
|
elm_widget_focused_object_get(const Evas_Object *obj)
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
2009-02-25 07:54:26 -08:00
|
|
|
const Evas_Object *subobj;
|
|
|
|
const Eina_List *l;
|
2008-10-06 18:23:49 -07:00
|
|
|
API_ENTRY return NULL;
|
2009-10-17 23:03:03 -07:00
|
|
|
|
2008-10-06 18:23:49 -07:00
|
|
|
if (!sd->focused) return NULL;
|
2009-02-25 07:54:26 -08:00
|
|
|
EINA_LIST_FOREACH(sd->subobjs, l, subobj)
|
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
Evas_Object *fobj = elm_widget_focused_object_get(subobj);
|
|
|
|
if (fobj) return fobj;
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
2009-02-25 07:54:26 -08:00
|
|
|
return (Evas_Object *)obj;
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
|
2008-11-18 02:11:57 -08:00
|
|
|
EAPI Evas_Object *
|
2009-02-25 07:54:26 -08:00
|
|
|
elm_widget_top_get(const Evas_Object *obj)
|
2008-11-18 02:11:57 -08:00
|
|
|
{
|
|
|
|
API_ENTRY return NULL;
|
|
|
|
if (sd->parent_obj) return elm_widget_top_get(sd->parent_obj);
|
2009-02-25 07:54:26 -08:00
|
|
|
return (Evas_Object *)obj;
|
2008-11-18 02:11:57 -08:00
|
|
|
}
|
|
|
|
|
2010-03-22 14:36:59 -07:00
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_widget_is(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
return _elm_widget_is(obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Evas_Object *
|
|
|
|
elm_widget_parent_widget_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Evas_Object *parent;
|
|
|
|
|
|
|
|
if (_elm_widget_is(obj))
|
|
|
|
{
|
2012-05-03 15:40:58 -07:00
|
|
|
Elm_Widget_Smart_Data *sd = evas_object_smart_data_get(obj);
|
2011-04-01 04:20:18 -07:00
|
|
|
if (!sd) return NULL;
|
|
|
|
parent = sd->parent_obj;
|
2010-03-22 14:36:59 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
parent = evas_object_data_get(obj, "elm-parent");
|
|
|
|
if (!parent) parent = evas_object_smart_parent_get(obj);
|
2010-03-22 14:36:59 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
while (parent)
|
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
Evas_Object *elm_parent;
|
|
|
|
if (_elm_widget_is(parent)) break;
|
|
|
|
elm_parent = evas_object_data_get(parent, "elm-parent");
|
2010-09-13 00:56:23 -07:00
|
|
|
if (elm_parent) parent = elm_parent;
|
2011-04-01 04:20:18 -07:00
|
|
|
else parent = evas_object_smart_parent_get(parent);
|
2010-03-22 14:36:59 -07:00
|
|
|
}
|
|
|
|
return parent;
|
|
|
|
}
|
|
|
|
|
2011-08-02 03:34:30 -07:00
|
|
|
EAPI Evas_Object *
|
|
|
|
elm_widget_parent2_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
if (_elm_widget_is(obj))
|
|
|
|
{
|
2012-05-03 15:40:58 -07:00
|
|
|
Elm_Widget_Smart_Data *sd = evas_object_smart_data_get(obj);
|
2011-08-02 03:34:30 -07:00
|
|
|
if (sd) return sd->parent2;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_widget_parent2_set(Evas_Object *obj, Evas_Object *parent)
|
|
|
|
{
|
|
|
|
API_ENTRY return;
|
|
|
|
sd->parent2 = parent;
|
|
|
|
}
|
|
|
|
|
2010-11-29 05:56:30 -08:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_event_callback_add(Evas_Object *obj,
|
|
|
|
Elm_Event_Cb func,
|
|
|
|
const void *data)
|
2010-11-29 05:56:30 -08:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(func);
|
2010-11-29 05:56:30 -08:00
|
|
|
Elm_Event_Cb_Data *ecb = ELM_NEW(Elm_Event_Cb_Data);
|
|
|
|
ecb->func = func;
|
|
|
|
ecb->data = data;
|
|
|
|
sd->event_cb = eina_list_append(sd->event_cb, ecb);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void *
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_event_callback_del(Evas_Object *obj,
|
|
|
|
Elm_Event_Cb func,
|
|
|
|
const void *data)
|
2010-11-29 05:56:30 -08:00
|
|
|
{
|
|
|
|
API_ENTRY return NULL;
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(func, NULL);
|
2010-11-29 05:56:30 -08:00
|
|
|
Eina_List *l;
|
|
|
|
Elm_Event_Cb_Data *ecd;
|
|
|
|
EINA_LIST_FOREACH(sd->event_cb, l, ecd)
|
2011-04-02 23:43:17 -07:00
|
|
|
if ((ecd->func == func) && (ecd->data == data))
|
|
|
|
{
|
|
|
|
free(ecd);
|
|
|
|
sd->event_cb = eina_list_remove_list(sd->event_cb, l);
|
|
|
|
return (void *)data;
|
|
|
|
}
|
2010-11-29 05:56:30 -08:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2010-09-20 19:02:24 -07:00
|
|
|
EAPI Eina_Bool
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_event_propagate(Evas_Object *obj,
|
|
|
|
Evas_Callback_Type type,
|
|
|
|
void *event_info,
|
|
|
|
Evas_Event_Flags *event_flags)
|
2010-09-20 19:02:24 -07:00
|
|
|
{
|
2010-11-29 05:56:30 -08:00
|
|
|
API_ENTRY return EINA_FALSE; //TODO reduce.
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
2010-11-29 05:56:30 -08:00
|
|
|
if (!_elm_widget_is(obj)) return EINA_FALSE;
|
|
|
|
Evas_Object *parent = obj;
|
|
|
|
Elm_Event_Cb_Data *ecd;
|
|
|
|
Eina_List *l, *l_prev;
|
2010-10-08 09:27:04 -07:00
|
|
|
|
|
|
|
while (parent &&
|
|
|
|
(!(event_flags && ((*event_flags) & EVAS_EVENT_FLAG_ON_HOLD))))
|
2010-09-20 19:02:24 -07:00
|
|
|
{
|
|
|
|
sd = evas_object_smart_data_get(parent);
|
|
|
|
if ((!sd) || (!_elm_widget_is(obj)))
|
|
|
|
return EINA_FALSE; //Not Elm Widget
|
2012-05-20 21:17:11 -07:00
|
|
|
if (!sd->api) return EINA_FALSE;
|
2010-11-29 05:56:30 -08:00
|
|
|
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
if (sd->api->event(parent, obj, type, event_info))
|
2010-09-20 19:02:24 -07:00
|
|
|
return EINA_TRUE;
|
2010-11-29 05:56:30 -08:00
|
|
|
|
|
|
|
EINA_LIST_FOREACH_SAFE(sd->event_cb, l, l_prev, ecd)
|
|
|
|
{
|
|
|
|
if (ecd->func((void *)ecd->data, parent, obj, type, event_info) ||
|
|
|
|
(event_flags && ((*event_flags) & EVAS_EVENT_FLAG_ON_HOLD)))
|
2011-04-01 04:20:18 -07:00
|
|
|
return EINA_TRUE;
|
2010-11-29 05:56:30 -08:00
|
|
|
}
|
2010-09-20 19:02:24 -07:00
|
|
|
parent = sd->parent_obj;
|
|
|
|
}
|
|
|
|
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
2010-10-19 07:17:03 -07:00
|
|
|
/**
|
2010-12-07 11:17:50 -08:00
|
|
|
* @internal
|
|
|
|
*
|
2010-10-19 07:17:03 -07:00
|
|
|
* Set custom focus chain.
|
|
|
|
*
|
|
|
|
* This function i set one new and overwrite any previous custom focus chain
|
|
|
|
* with the list of objects. The previous list will be deleted and this list
|
|
|
|
* will be managed. After setted, don't modity it.
|
|
|
|
*
|
|
|
|
* @note On focus cycle, only will be evaluated children of this container.
|
|
|
|
*
|
|
|
|
* @param obj The container widget
|
|
|
|
* @param objs Chain of objects to pass focus
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
2010-10-06 13:24:22 -07:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_focus_custom_chain_set(Evas_Object *obj,
|
|
|
|
Eina_List *objs)
|
2010-10-06 13:24:22 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
|
|
|
if (!_elm_widget_focus_chain_manager_is(obj)) return;
|
2010-10-06 13:24:22 -07:00
|
|
|
|
|
|
|
elm_widget_focus_custom_chain_unset(obj);
|
|
|
|
|
|
|
|
Eina_List *l;
|
|
|
|
Evas_Object *o;
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH(objs, l, o)
|
|
|
|
{
|
|
|
|
evas_object_event_callback_add(o, EVAS_CALLBACK_DEL,
|
|
|
|
_elm_object_focus_chain_del_cb, sd);
|
|
|
|
}
|
|
|
|
|
|
|
|
sd->focus_chain = objs;
|
|
|
|
}
|
|
|
|
|
2010-10-19 07:17:03 -07:00
|
|
|
/**
|
2010-12-07 11:17:50 -08:00
|
|
|
* @internal
|
|
|
|
*
|
2010-10-19 07:17:03 -07:00
|
|
|
* Get custom focus chain
|
|
|
|
*
|
|
|
|
* @param obj The container widget
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
|
|
|
EAPI const Eina_List *
|
|
|
|
elm_widget_focus_custom_chain_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
API_ENTRY return NULL;
|
2012-02-22 20:09:43 -08:00
|
|
|
return (const Eina_List *)sd->focus_chain;
|
2010-10-19 07:17:03 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2010-12-07 11:17:50 -08:00
|
|
|
* @internal
|
|
|
|
*
|
2010-10-19 07:17:03 -07:00
|
|
|
* Unset custom focus chain
|
|
|
|
*
|
|
|
|
* @param obj The container widget
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
elm_widget_focus_custom_chain_unset(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
API_ENTRY return;
|
|
|
|
Eina_List *l, *l_next;
|
|
|
|
Evas_Object *o;
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH_SAFE(sd->focus_chain, l, l_next, o)
|
|
|
|
{
|
|
|
|
evas_object_event_callback_del_full(o, EVAS_CALLBACK_DEL,
|
|
|
|
_elm_object_focus_chain_del_cb, sd);
|
|
|
|
sd->focus_chain = eina_list_remove_list(sd->focus_chain, l);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2010-12-07 11:17:50 -08:00
|
|
|
* @internal
|
|
|
|
*
|
2010-10-19 07:17:03 -07:00
|
|
|
* Append object to custom focus chain.
|
|
|
|
*
|
|
|
|
* @note If relative_child equal to NULL or not in custom chain, the object
|
|
|
|
* will be added in end.
|
|
|
|
*
|
|
|
|
* @note On focus cycle, only will be evaluated children of this container.
|
|
|
|
*
|
|
|
|
* @param obj The container widget
|
|
|
|
* @param child The child to be added in custom chain
|
|
|
|
* @param relative_child The relative object to position the child
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
2010-10-06 13:24:22 -07:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_focus_custom_chain_append(Evas_Object *obj,
|
|
|
|
Evas_Object *child,
|
|
|
|
Evas_Object *relative_child)
|
2010-10-06 13:24:22 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(child);
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
|
|
|
if (!_elm_widget_focus_chain_manager_is(obj)) return;
|
2010-10-06 13:24:22 -07:00
|
|
|
|
|
|
|
evas_object_event_callback_del_full(child, EVAS_CALLBACK_DEL,
|
|
|
|
_elm_object_focus_chain_del_cb, sd);
|
|
|
|
|
|
|
|
if (!relative_child)
|
2012-02-21 04:36:54 -08:00
|
|
|
sd->focus_chain = eina_list_append(sd->focus_chain, child);
|
|
|
|
else
|
|
|
|
sd->focus_chain = eina_list_append_relative(sd->focus_chain,
|
|
|
|
child, relative_child);
|
2010-10-06 13:24:22 -07:00
|
|
|
}
|
|
|
|
|
2010-10-19 07:17:03 -07:00
|
|
|
/**
|
2010-12-07 11:17:50 -08:00
|
|
|
* @internal
|
|
|
|
*
|
2010-10-19 07:17:03 -07:00
|
|
|
* Prepend object to custom focus chain.
|
|
|
|
*
|
|
|
|
* @note If relative_child equal to NULL or not in custom chain, the object
|
|
|
|
* will be added in begin.
|
|
|
|
*
|
|
|
|
* @note On focus cycle, only will be evaluated children of this container.
|
|
|
|
*
|
|
|
|
* @param obj The container widget
|
|
|
|
* @param child The child to be added in custom chain
|
|
|
|
* @param relative_child The relative object to position the child
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
2010-10-06 13:24:22 -07:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_focus_custom_chain_prepend(Evas_Object *obj,
|
|
|
|
Evas_Object *child,
|
|
|
|
Evas_Object *relative_child)
|
2010-10-06 13:24:22 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(child);
|
2012-02-21 04:36:54 -08:00
|
|
|
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
if (!_elm_widget_focus_chain_manager_is(obj)) return;
|
2010-10-06 13:24:22 -07:00
|
|
|
|
|
|
|
evas_object_event_callback_del_full(child, EVAS_CALLBACK_DEL,
|
|
|
|
_elm_object_focus_chain_del_cb, sd);
|
|
|
|
|
|
|
|
if (!relative_child)
|
2012-02-21 04:36:54 -08:00
|
|
|
sd->focus_chain = eina_list_prepend(sd->focus_chain, child);
|
|
|
|
else
|
|
|
|
sd->focus_chain = eina_list_prepend_relative(sd->focus_chain,
|
|
|
|
child, relative_child);
|
2010-10-06 13:24:22 -07:00
|
|
|
}
|
|
|
|
|
2010-10-19 07:17:03 -07:00
|
|
|
/**
|
2010-12-07 11:17:50 -08:00
|
|
|
* @internal
|
|
|
|
*
|
2010-10-19 07:17:03 -07:00
|
|
|
* Give focus to next object in object tree.
|
|
|
|
*
|
|
|
|
* Give focus to next object in focus chain of one object sub-tree.
|
|
|
|
* If the last object of chain already have focus, the focus will go to the
|
|
|
|
* first object of chain.
|
|
|
|
*
|
|
|
|
* @param obj The widget root of sub-tree
|
|
|
|
* @param dir Direction to cycle the focus
|
|
|
|
*
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
2010-10-06 13:24:16 -07:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_focus_cycle(Evas_Object *obj,
|
|
|
|
Elm_Focus_Direction dir)
|
2010-10-06 13:24:16 -07:00
|
|
|
{
|
2010-10-20 05:38:27 -07:00
|
|
|
Evas_Object *target = NULL;
|
2010-10-28 06:38:55 -07:00
|
|
|
if (!_elm_widget_is(obj))
|
|
|
|
return;
|
2010-10-06 13:24:16 -07:00
|
|
|
elm_widget_focus_next_get(obj, dir, &target);
|
|
|
|
if (target)
|
|
|
|
elm_widget_focus_steal(target);
|
|
|
|
}
|
|
|
|
|
2010-10-20 05:38:27 -07:00
|
|
|
/**
|
2010-12-07 11:17:50 -08:00
|
|
|
* @internal
|
|
|
|
*
|
2012-05-02 20:02:54 -07:00
|
|
|
* Give focus to near object(in object tree) in one direction.
|
2010-10-20 05:38:27 -07:00
|
|
|
*
|
2012-05-02 20:02:54 -07:00
|
|
|
* Give focus to near object(in object tree) in direction of current focused object.
|
|
|
|
* If none focusable object in given direction or none focused object in object tree,
|
|
|
|
* the focus will not change.
|
2010-10-20 05:38:27 -07:00
|
|
|
*
|
|
|
|
* @param obj The reference widget
|
2012-05-02 20:02:54 -07:00
|
|
|
* @param degree Degree changes clockwise. i.e. 0-degree: Up,
|
|
|
|
* 90-degree: Right, 180-degree: Down, and 270-degree: Left
|
|
|
|
* @return EINA_TRUE if focus is moved.
|
|
|
|
*
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_widget_focus_direction_go(Evas_Object *obj, double degree)
|
|
|
|
{
|
|
|
|
Evas_Object *target = NULL;
|
|
|
|
Evas_Object *current_focused = NULL;
|
|
|
|
double weight = 0.0;
|
|
|
|
|
|
|
|
if (!_elm_widget_is(obj)) return EINA_FALSE;
|
|
|
|
if (!elm_widget_focus_get(obj)) return EINA_FALSE;
|
|
|
|
|
|
|
|
current_focused = elm_widget_focused_object_get(obj);
|
|
|
|
|
|
|
|
if (elm_widget_focus_direction_get(obj, current_focused, degree, &target, &weight))
|
|
|
|
{
|
|
|
|
elm_widget_focus_steal(target);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Get near object in one direction of base object.
|
|
|
|
*
|
|
|
|
* Get near object(in the object sub-tree) in one direction of
|
|
|
|
* base object. Return the near object by reference.
|
|
|
|
* By initializing weight, you can filter objects locating far
|
|
|
|
* from base object. If object is in the specific direction,
|
|
|
|
* weight is (1/(distance^2)). If object is not exactly in one
|
|
|
|
* direction, some penalty will be added.
|
|
|
|
*
|
|
|
|
* @param obj The widget root of sub-tree
|
|
|
|
* @param base The base object of the direction
|
|
|
|
* @param degree Degree changes clockwise. i.e. 0-degree: Up,
|
|
|
|
* 90-degree: Right, 180-degree: Down, and 270-degree: Left
|
|
|
|
* @param direction The near object in one direction
|
|
|
|
* @param weight The weight is bigger when the object is located near
|
|
|
|
* @return EINA_TRUE if near object is updated.
|
|
|
|
*
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_widget_focus_direction_get(const Evas_Object *obj,
|
|
|
|
const Evas_Object *base,
|
|
|
|
double degree,
|
|
|
|
Evas_Object **direction,
|
|
|
|
double *weight)
|
|
|
|
{
|
|
|
|
API_ENTRY return EINA_FALSE;
|
|
|
|
|
|
|
|
/* -1 means the best was already decided. Don't need any more searching. */
|
|
|
|
if (!direction || !weight || !base || (obj == base))
|
|
|
|
return EINA_FALSE;
|
|
|
|
|
|
|
|
/* Ignore if disabled */
|
|
|
|
if ((!evas_object_visible_get(obj))
|
|
|
|
|| (elm_widget_disabled_get(obj))
|
|
|
|
|| (elm_widget_tree_unfocusable_get(obj)))
|
|
|
|
return EINA_FALSE;
|
|
|
|
|
2012-05-20 21:17:11 -07:00
|
|
|
if (!sd->api) return EINA_FALSE;
|
|
|
|
|
2012-05-02 20:02:54 -07:00
|
|
|
/* Try use hook */
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
if (_elm_widget_focus_direction_manager_is(obj))
|
|
|
|
return sd->api->focus_direction(obj, base, degree, direction, weight);
|
2012-05-02 20:02:54 -07:00
|
|
|
|
|
|
|
if (!elm_widget_can_focus_get(obj) || elm_widget_focus_get(obj))
|
|
|
|
return EINA_FALSE;
|
|
|
|
|
|
|
|
double c_weight = _direction_weight_get(base, obj, degree);
|
|
|
|
if ((c_weight == -1.0) || ((c_weight != 0.0) && (*weight != -1.0) &&
|
|
|
|
((int)(*weight * 1000000) <= (int)(c_weight * 1000000))))
|
|
|
|
{
|
|
|
|
if ((int)(*weight * 1000000) == (int)(c_weight * 1000000))
|
|
|
|
{
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
Elm_Widget_Smart_Data *sd1 =
|
|
|
|
evas_object_smart_data_get(*direction);
|
2012-05-02 20:02:54 -07:00
|
|
|
if (sd1)
|
|
|
|
{
|
|
|
|
if (sd->focus_order <= sd1->focus_order)
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
*direction = (Evas_Object *)obj;
|
|
|
|
*weight = c_weight;
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Get near object in one direction of base object in list.
|
|
|
|
*
|
|
|
|
* Get near object in one direction of base object in the specific
|
|
|
|
* object list. Return the near object by reference.
|
|
|
|
* By initializing weight, you can filter objects locating far
|
|
|
|
* from base object. If object is in the specific direction,
|
|
|
|
* weight is (1/(distance^2)). If object is not exactly in one
|
|
|
|
* direction, some penalty will be added.
|
|
|
|
*
|
|
|
|
* @param obj The widget root of sub-tree
|
|
|
|
* @param base The base object of the direction
|
|
|
|
* @param items list with ordered objects
|
|
|
|
* @param list_data_get function to get the object from one item of list
|
|
|
|
* @param degree Degree changes clockwise. i.e. 0-degree: Up,
|
|
|
|
* 90-degree: Right, 180-degree: Down, and 270-degree: Left
|
|
|
|
* @param direction The near object in one direction
|
|
|
|
* @param weight The weight is bigger when the object is located near
|
|
|
|
* @return EINA_TRUE if near object is updated.
|
2010-10-20 05:38:27 -07:00
|
|
|
*
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
2012-05-02 20:02:54 -07:00
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_widget_focus_list_direction_get(const Evas_Object *obj,
|
|
|
|
const Evas_Object *base,
|
|
|
|
const Eina_List *items,
|
|
|
|
void *(*list_data_get)(const Eina_List *list),
|
|
|
|
double degree,
|
|
|
|
Evas_Object **direction,
|
|
|
|
double *weight)
|
2010-10-20 05:38:27 -07:00
|
|
|
{
|
2012-05-02 20:02:54 -07:00
|
|
|
API_ENTRY return EINA_FALSE;
|
|
|
|
if (!direction || !weight || !base || !items)
|
|
|
|
return EINA_FALSE;
|
|
|
|
|
|
|
|
const Eina_List *l = items;
|
|
|
|
Evas_Object *current_best = *direction;
|
|
|
|
|
|
|
|
for (; l; l = eina_list_next(l))
|
|
|
|
{
|
|
|
|
Evas_Object *cur = list_data_get(l);
|
|
|
|
elm_widget_focus_direction_get(cur, base, degree, direction, weight);
|
|
|
|
}
|
|
|
|
if (current_best != *direction)
|
|
|
|
return EINA_TRUE;
|
|
|
|
else
|
|
|
|
return EINA_FALSE;
|
2010-10-20 05:38:27 -07:00
|
|
|
}
|
|
|
|
|
2010-10-19 07:17:03 -07:00
|
|
|
/**
|
2010-12-07 11:17:50 -08:00
|
|
|
* @internal
|
|
|
|
*
|
2010-10-19 07:17:03 -07:00
|
|
|
* Get next object in focus chain of object tree.
|
|
|
|
*
|
|
|
|
* Get next object in focus chain of one object sub-tree.
|
|
|
|
* Return the next object by reference. If don't have any candidate to receive
|
|
|
|
* focus before chain end, the first candidate will be returned.
|
|
|
|
*
|
|
|
|
* @param obj The widget root of sub-tree
|
|
|
|
* @param dir Direction os focus chain
|
|
|
|
* @param next The next object in focus chain
|
|
|
|
* @return EINA_TRUE if don't need focus chain restart/loop back
|
|
|
|
* to use 'next' obj.
|
|
|
|
*
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
2010-09-24 07:47:59 -07:00
|
|
|
EAPI Eina_Bool
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_focus_next_get(const Evas_Object *obj,
|
|
|
|
Elm_Focus_Direction dir,
|
|
|
|
Evas_Object **next)
|
2010-09-24 07:47:59 -07:00
|
|
|
{
|
2010-10-06 13:24:09 -07:00
|
|
|
if (!next)
|
|
|
|
return EINA_FALSE;
|
|
|
|
*next = NULL;
|
|
|
|
|
2010-09-24 07:47:59 -07:00
|
|
|
API_ENTRY return EINA_FALSE;
|
|
|
|
|
2010-10-01 12:02:55 -07:00
|
|
|
/* Ignore if disabled */
|
2011-07-27 23:58:29 -07:00
|
|
|
if ((!evas_object_visible_get(obj))
|
|
|
|
|| (elm_widget_disabled_get(obj))
|
|
|
|
|| (elm_widget_tree_unfocusable_get(obj)))
|
2010-10-01 12:02:55 -07:00
|
|
|
return EINA_FALSE;
|
|
|
|
|
2012-05-20 21:17:11 -07:00
|
|
|
if (!sd->api) return EINA_FALSE;
|
|
|
|
|
2010-10-01 12:02:55 -07:00
|
|
|
/* Try use hook */
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
if (_elm_widget_focus_chain_manager_is(obj))
|
|
|
|
return sd->api->focus_next(obj, dir, next);
|
2010-10-01 12:02:55 -07:00
|
|
|
|
2010-10-06 13:24:09 -07:00
|
|
|
if (!elm_widget_can_focus_get(obj))
|
2010-10-01 12:02:55 -07:00
|
|
|
return EINA_FALSE;
|
|
|
|
|
2010-10-06 13:24:09 -07:00
|
|
|
/* Return */
|
2010-10-06 13:24:19 -07:00
|
|
|
*next = (Evas_Object *)obj;
|
2010-10-06 13:24:09 -07:00
|
|
|
return !elm_widget_focus_get(obj);
|
2010-09-24 07:47:59 -07:00
|
|
|
}
|
|
|
|
|
2010-10-19 07:17:03 -07:00
|
|
|
/**
|
2010-12-07 11:17:50 -08:00
|
|
|
* @internal
|
|
|
|
*
|
2010-10-19 07:17:03 -07:00
|
|
|
* Get next object in focus chain of object tree in list.
|
|
|
|
*
|
|
|
|
* Get next object in focus chain of one object sub-tree ordered by one list.
|
|
|
|
* Return the next object by reference. If don't have any candidate to receive
|
|
|
|
* focus before list end, the first candidate will be returned.
|
|
|
|
*
|
|
|
|
* @param obj The widget root of sub-tree
|
|
|
|
* @param dir Direction os focus chain
|
|
|
|
* @param items list with ordered objects
|
|
|
|
* @param list_data_get function to get the object from one item of list
|
|
|
|
* @param next The next object in focus chain
|
|
|
|
* @return EINA_TRUE if don't need focus chain restart/loop back
|
|
|
|
* to use 'next' obj.
|
|
|
|
*
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
2010-10-06 13:24:09 -07:00
|
|
|
EAPI Eina_Bool
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_focus_list_next_get(const Evas_Object *obj,
|
|
|
|
const Eina_List *items,
|
|
|
|
void *(*list_data_get)(const Eina_List * list),
|
|
|
|
Elm_Focus_Direction dir,
|
|
|
|
Evas_Object **next)
|
2010-09-24 07:47:59 -07:00
|
|
|
{
|
2011-08-05 01:25:07 -07:00
|
|
|
Eina_List *(*list_next)(const Eina_List * list) = NULL;
|
2010-10-06 13:24:09 -07:00
|
|
|
|
|
|
|
if (!next)
|
|
|
|
return EINA_FALSE;
|
|
|
|
*next = NULL;
|
2010-09-24 07:47:59 -07:00
|
|
|
|
2010-10-21 11:58:43 -07:00
|
|
|
if (!_elm_widget_is(obj))
|
2010-10-21 11:58:40 -07:00
|
|
|
return EINA_FALSE;
|
|
|
|
|
2010-09-24 07:47:59 -07:00
|
|
|
if (!items)
|
2010-10-06 13:24:09 -07:00
|
|
|
return EINA_FALSE;
|
2010-09-24 07:47:59 -07:00
|
|
|
|
|
|
|
/* Direction */
|
|
|
|
if (dir == ELM_FOCUS_PREVIOUS)
|
|
|
|
{
|
2010-10-06 13:24:09 -07:00
|
|
|
items = eina_list_last(items);
|
2010-09-24 07:47:59 -07:00
|
|
|
list_next = eina_list_prev;
|
|
|
|
}
|
|
|
|
else if (dir == ELM_FOCUS_NEXT)
|
2011-08-06 00:39:31 -07:00
|
|
|
list_next = eina_list_next;
|
2010-09-24 07:47:59 -07:00
|
|
|
else
|
2010-10-06 13:24:09 -07:00
|
|
|
return EINA_FALSE;
|
|
|
|
|
2011-08-06 00:39:31 -07:00
|
|
|
const Eina_List *l = items;
|
2010-09-24 07:47:59 -07:00
|
|
|
|
2011-08-06 00:39:31 -07:00
|
|
|
/* Recovery last focused sub item */
|
|
|
|
if (elm_widget_focus_get(obj))
|
|
|
|
for (; l; l = list_next(l))
|
|
|
|
{
|
|
|
|
Evas_Object *cur = list_data_get(l);
|
|
|
|
if (elm_widget_focus_get(cur)) break;
|
|
|
|
}
|
2010-09-24 07:47:59 -07:00
|
|
|
|
2011-08-06 00:39:31 -07:00
|
|
|
const Eina_List *start = l;
|
|
|
|
Evas_Object *to_focus = NULL;
|
2010-10-06 13:24:22 -07:00
|
|
|
|
2011-08-06 00:39:31 -07:00
|
|
|
/* Interate sub items */
|
|
|
|
/* Go to end of list */
|
|
|
|
for (; l; l = list_next(l))
|
|
|
|
{
|
|
|
|
Evas_Object *tmp = NULL;
|
|
|
|
Evas_Object *cur = list_data_get(l);
|
2011-08-05 01:25:07 -07:00
|
|
|
|
2011-08-06 00:39:31 -07:00
|
|
|
if (elm_widget_parent_get(cur) != obj)
|
|
|
|
continue;
|
2010-10-06 13:24:09 -07:00
|
|
|
|
2011-08-06 00:39:31 -07:00
|
|
|
/* Try Focus cycle in subitem */
|
|
|
|
if (elm_widget_focus_next_get(cur, dir, &tmp))
|
|
|
|
{
|
|
|
|
*next = tmp;
|
|
|
|
return EINA_TRUE;
|
2011-08-05 01:25:07 -07:00
|
|
|
}
|
2011-08-06 00:39:31 -07:00
|
|
|
else if ((tmp) && (!to_focus))
|
|
|
|
to_focus = tmp;
|
2011-08-05 01:25:07 -07:00
|
|
|
}
|
2011-08-06 00:39:31 -07:00
|
|
|
|
|
|
|
l = items;
|
|
|
|
|
|
|
|
/* Get First possible */
|
|
|
|
for (; l != start; l = list_next(l))
|
2010-10-06 13:24:09 -07:00
|
|
|
{
|
|
|
|
Evas_Object *tmp = NULL;
|
2011-08-06 00:39:31 -07:00
|
|
|
Evas_Object *cur = list_data_get(l);
|
2010-10-06 13:24:22 -07:00
|
|
|
|
2011-08-06 00:39:31 -07:00
|
|
|
if (elm_widget_parent_get(cur) != obj)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Try Focus cycle in subitem */
|
|
|
|
elm_widget_focus_next_get(cur, dir, &tmp);
|
|
|
|
if (tmp)
|
2010-10-06 13:24:09 -07:00
|
|
|
{
|
2011-08-06 00:39:31 -07:00
|
|
|
*next = tmp;
|
|
|
|
return EINA_FALSE;
|
2010-10-06 13:24:09 -07:00
|
|
|
}
|
|
|
|
}
|
2010-09-24 07:47:59 -07:00
|
|
|
|
2011-08-06 00:39:31 -07:00
|
|
|
*next = to_focus;
|
2010-10-06 13:24:09 -07:00
|
|
|
return EINA_FALSE;
|
2010-09-24 07:47:59 -07:00
|
|
|
}
|
|
|
|
|
2010-06-15 07:11:13 -07:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_signal_emit(Evas_Object *obj,
|
|
|
|
const char *emission,
|
|
|
|
const char *source)
|
2010-06-15 07:11:13 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
|
|
|
if (_elm_legacy_is(obj) && COMPAT_SMART_DATA(sd)->signal)
|
|
|
|
COMPAT_SMART_DATA(sd)->signal(obj, emission, source);
|
2012-05-03 15:41:26 -07:00
|
|
|
else if (evas_object_smart_type_check(obj, "elm_layout"))
|
|
|
|
elm_layout_signal_emit(obj, emission, source);
|
2012-05-28 13:35:35 -07:00
|
|
|
else if (evas_object_smart_type_check(obj, "elm_icon"))
|
|
|
|
{
|
|
|
|
WRN("Deprecated function. This functionality on icon objects"
|
|
|
|
" will be dropped on a next release.");
|
|
|
|
_elm_icon_signal_emit(obj, emission, source);
|
|
|
|
}
|
2010-06-15 07:11:13 -07:00
|
|
|
}
|
|
|
|
|
2010-10-29 11:21:58 -07:00
|
|
|
static void
|
2011-04-02 23:43:17 -07:00
|
|
|
_edje_signal_callback(void *data,
|
|
|
|
Evas_Object *obj __UNUSED__,
|
|
|
|
const char *emission,
|
|
|
|
const char *source)
|
2010-10-29 11:21:58 -07:00
|
|
|
{
|
|
|
|
Edje_Signal_Data *esd = data;
|
|
|
|
esd->func(esd->data, esd->obj, emission, source);
|
|
|
|
}
|
|
|
|
|
2010-06-25 15:38:32 -07:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_signal_callback_add(Evas_Object *obj,
|
|
|
|
const char *emission,
|
|
|
|
const char *source,
|
|
|
|
Edje_Signal_Cb func,
|
|
|
|
void *data)
|
2010-06-25 15:38:32 -07:00
|
|
|
{
|
2010-10-29 11:21:58 -07:00
|
|
|
Edje_Signal_Data *esd;
|
2010-06-25 15:38:32 -07:00
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(func);
|
2010-10-29 11:21:58 -07:00
|
|
|
|
2012-05-03 15:41:26 -07:00
|
|
|
if (_elm_legacy_is(obj))
|
|
|
|
{
|
2012-05-25 12:53:59 -07:00
|
|
|
if (!COMPAT_SMART_DATA(sd)->callback_add) return;
|
|
|
|
|
2012-05-03 15:41:26 -07:00
|
|
|
esd = ELM_NEW(Edje_Signal_Data);
|
|
|
|
if (!esd) return;
|
2012-05-02 09:58:10 -07:00
|
|
|
|
2012-05-03 15:41:26 -07:00
|
|
|
esd->obj = obj;
|
|
|
|
esd->func = func;
|
|
|
|
esd->emission = eina_stringshare_add(emission);
|
|
|
|
esd->source = eina_stringshare_add(source);
|
|
|
|
esd->data = data;
|
|
|
|
COMPAT_SMART_DATA(sd)->edje_signals = eina_list_append
|
|
|
|
(COMPAT_SMART_DATA(sd)->edje_signals, esd);
|
|
|
|
|
|
|
|
COMPAT_SMART_DATA(sd)->callback_add
|
|
|
|
(obj, emission, source, _edje_signal_callback, esd);
|
|
|
|
}
|
2012-05-25 12:53:59 -07:00
|
|
|
|
2012-06-21 16:37:49 -07:00
|
|
|
else if (evas_object_smart_type_check(obj, "elm_layout"))
|
2012-05-03 15:41:26 -07:00
|
|
|
elm_layout_signal_callback_add(obj, emission, source, func, data);
|
2012-05-28 13:35:35 -07:00
|
|
|
else if (evas_object_smart_type_check(obj, "elm_icon"))
|
|
|
|
{
|
|
|
|
WRN("Deprecated function. This functionality on icon objects"
|
|
|
|
" will be dropped on a next release.");
|
|
|
|
|
|
|
|
_elm_icon_signal_callback_add(obj, emission, source, func, data);
|
|
|
|
}
|
2010-06-25 15:38:32 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void *
|
2012-08-09 13:40:27 -07:00
|
|
|
elm_widget_signal_callback_del(Evas_Object *obj,
|
|
|
|
const char *emission,
|
|
|
|
const char *source,
|
2011-04-02 23:43:17 -07:00
|
|
|
Edje_Signal_Cb func)
|
2010-06-25 15:38:32 -07:00
|
|
|
{
|
2010-10-29 11:21:58 -07:00
|
|
|
Edje_Signal_Data *esd;
|
|
|
|
Eina_List *l;
|
|
|
|
void *data = NULL;
|
2010-06-25 15:38:32 -07:00
|
|
|
API_ENTRY return NULL;
|
2012-05-03 15:41:26 -07:00
|
|
|
|
|
|
|
if (_elm_legacy_is(obj))
|
2010-10-29 11:21:58 -07:00
|
|
|
{
|
2012-05-25 12:53:59 -07:00
|
|
|
if (!COMPAT_SMART_DATA(sd)->callback_del) return NULL;
|
|
|
|
|
2012-05-03 15:41:26 -07:00
|
|
|
EINA_LIST_FOREACH (COMPAT_SMART_DATA(sd)->edje_signals, l, esd)
|
2010-10-29 11:21:58 -07:00
|
|
|
{
|
2012-05-03 15:41:26 -07:00
|
|
|
if ((esd->func == func) && (!strcmp(esd->emission, emission)) &&
|
|
|
|
(!strcmp(esd->source, source)))
|
|
|
|
{
|
|
|
|
COMPAT_SMART_DATA(sd)->edje_signals = eina_list_remove_list
|
2012-08-09 13:40:27 -07:00
|
|
|
(COMPAT_SMART_DATA(sd)->edje_signals, l);
|
2012-05-03 15:41:26 -07:00
|
|
|
eina_stringshare_del(esd->emission);
|
|
|
|
eina_stringshare_del(esd->source);
|
|
|
|
data = esd->data;
|
|
|
|
free(esd);
|
|
|
|
break;
|
|
|
|
}
|
2010-10-29 11:21:58 -07:00
|
|
|
}
|
2012-05-03 15:41:26 -07:00
|
|
|
|
|
|
|
COMPAT_SMART_DATA(sd)->callback_del
|
|
|
|
(obj, emission, source, _edje_signal_callback, esd);
|
2010-10-29 11:21:58 -07:00
|
|
|
}
|
2012-06-21 16:37:49 -07:00
|
|
|
else if (evas_object_smart_type_check(obj, "elm_layout"))
|
2012-08-09 13:40:27 -07:00
|
|
|
data = elm_layout_signal_callback_del(obj, emission, source, func);
|
2012-05-28 13:35:35 -07:00
|
|
|
else if (evas_object_smart_type_check(obj, "elm_icon"))
|
|
|
|
{
|
|
|
|
WRN("Deprecated function. This functionality on icon objects"
|
|
|
|
" will be dropped on a next release.");
|
|
|
|
|
2012-08-09 13:40:27 -07:00
|
|
|
data = _elm_icon_signal_callback_del(obj, emission, source, func);
|
2012-05-28 13:35:35 -07:00
|
|
|
}
|
2012-03-07 11:43:23 -08:00
|
|
|
|
2010-10-29 11:21:58 -07:00
|
|
|
return data;
|
2010-06-25 15:38:32 -07:00
|
|
|
}
|
|
|
|
|
2008-10-06 18:23:49 -07:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_focus_set(Evas_Object *obj,
|
|
|
|
int first)
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
2012-05-20 21:17:11 -07:00
|
|
|
if (!sd->api) return;
|
|
|
|
|
2008-10-06 18:23:49 -07:00
|
|
|
if (!sd->focused)
|
|
|
|
{
|
2010-06-21 00:39:49 -07:00
|
|
|
focus_order++;
|
|
|
|
sd->focus_order = focus_order;
|
2011-04-01 04:20:18 -07:00
|
|
|
sd->focused = EINA_TRUE;
|
2012-08-03 09:43:17 -07:00
|
|
|
sd->api->on_focus(obj);
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
2012-08-03 09:43:17 -07:00
|
|
|
if (_elm_legacy_is(obj) && COMPAT_SMART_DATA(sd)->focus)
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
2012-08-03 09:43:17 -07:00
|
|
|
COMPAT_SMART_DATA(sd)->focus(obj);
|
2011-04-01 04:20:18 -07:00
|
|
|
return;
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
if (first)
|
|
|
|
{
|
|
|
|
if ((_is_focusable(sd->resize_obj)) &&
|
|
|
|
(!elm_widget_disabled_get(sd->resize_obj)))
|
|
|
|
{
|
|
|
|
elm_widget_focus_set(sd->resize_obj, first);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
const Eina_List *l;
|
|
|
|
Evas_Object *child;
|
|
|
|
EINA_LIST_FOREACH(sd->subobjs, l, child)
|
|
|
|
{
|
|
|
|
if ((_is_focusable(child)) &&
|
|
|
|
(!elm_widget_disabled_get(child)))
|
|
|
|
{
|
|
|
|
elm_widget_focus_set(child, first);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
const Eina_List *l;
|
|
|
|
Evas_Object *child;
|
|
|
|
EINA_LIST_REVERSE_FOREACH(sd->subobjs, l, child)
|
|
|
|
{
|
|
|
|
if ((_is_focusable(child)) &&
|
|
|
|
(!elm_widget_disabled_get(child)))
|
|
|
|
{
|
|
|
|
elm_widget_focus_set(child, first);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!l)
|
|
|
|
{
|
|
|
|
if ((_is_focusable(sd->resize_obj)) &&
|
|
|
|
(!elm_widget_disabled_get(sd->resize_obj)))
|
|
|
|
{
|
|
|
|
elm_widget_focus_set(sd->resize_obj, first);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Evas_Object *
|
2009-02-25 07:54:26 -08:00
|
|
|
elm_widget_parent_get(const Evas_Object *obj)
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return NULL;
|
|
|
|
return sd->parent_obj;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_widget_focused_object_clear(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
2012-05-20 21:17:11 -07:00
|
|
|
if (!sd->api) return;
|
|
|
|
|
2008-10-06 18:23:49 -07:00
|
|
|
if (!sd->focused) return;
|
2011-12-18 23:22:25 -08:00
|
|
|
if (sd->resize_obj && elm_widget_focus_get(sd->resize_obj))
|
2011-04-01 04:20:18 -07:00
|
|
|
elm_widget_focused_object_clear(sd->resize_obj);
|
2008-12-30 08:19:46 -08:00
|
|
|
else
|
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
const Eina_List *l;
|
|
|
|
Evas_Object *child;
|
|
|
|
EINA_LIST_FOREACH(sd->subobjs, l, child)
|
|
|
|
{
|
|
|
|
if (elm_widget_focus_get(child))
|
|
|
|
{
|
|
|
|
elm_widget_focused_object_clear(child);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
2010-09-27 21:28:14 -07:00
|
|
|
sd->focused = EINA_FALSE;
|
2012-08-03 09:43:17 -07:00
|
|
|
sd->api->on_focus(obj);
|
|
|
|
if (_elm_legacy_is(obj) && COMPAT_SMART_DATA(sd)->focus)
|
|
|
|
COMPAT_SMART_DATA(sd)->focus(obj);
|
2008-12-30 08:19:46 -08:00
|
|
|
}
|
|
|
|
|
2008-10-06 18:23:49 -07:00
|
|
|
EAPI void
|
|
|
|
elm_widget_focus_steal(Evas_Object *obj)
|
|
|
|
{
|
2011-08-02 03:34:30 -07:00
|
|
|
Evas_Object *parent, *parent2, *o;
|
2008-10-06 18:23:49 -07:00
|
|
|
API_ENTRY return;
|
2009-10-17 23:03:03 -07:00
|
|
|
|
2008-10-06 18:23:49 -07:00
|
|
|
if (sd->focused) return;
|
|
|
|
if (sd->disabled) return;
|
2011-05-27 03:47:52 -07:00
|
|
|
if (!sd->can_focus) return;
|
2011-07-27 23:58:29 -07:00
|
|
|
if (sd->tree_unfocusable) return;
|
2008-10-06 18:23:49 -07:00
|
|
|
parent = obj;
|
|
|
|
for (;;)
|
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
o = elm_widget_parent_get(parent);
|
|
|
|
if (!o) break;
|
|
|
|
sd = evas_object_smart_data_get(o);
|
2011-07-27 23:58:29 -07:00
|
|
|
if (sd->disabled || sd->tree_unfocusable) return;
|
2011-04-01 04:20:18 -07:00
|
|
|
if (sd->focused) break;
|
|
|
|
parent = o;
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
2011-08-02 03:34:30 -07:00
|
|
|
if ((!elm_widget_parent_get(parent)) &&
|
|
|
|
(!elm_widget_parent2_get(parent)))
|
|
|
|
elm_widget_focused_object_clear(parent);
|
2008-12-30 08:19:46 -08:00
|
|
|
else
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
2011-08-02 03:34:30 -07:00
|
|
|
parent2 = elm_widget_parent_get(parent);
|
|
|
|
if (!parent2) parent2 = elm_widget_parent2_get(parent);
|
|
|
|
parent = parent2;
|
2011-04-01 04:20:18 -07:00
|
|
|
sd = evas_object_smart_data_get(parent);
|
2011-08-02 03:34:30 -07:00
|
|
|
if (sd)
|
2011-04-01 04:20:18 -07:00
|
|
|
{
|
2011-08-02 03:34:30 -07:00
|
|
|
if ((sd->resize_obj) && (elm_widget_focus_get(sd->resize_obj)))
|
|
|
|
elm_widget_focused_object_clear(sd->resize_obj);
|
|
|
|
else
|
2011-04-01 04:20:18 -07:00
|
|
|
{
|
2011-08-02 03:34:30 -07:00
|
|
|
const Eina_List *l;
|
|
|
|
Evas_Object *child;
|
|
|
|
EINA_LIST_FOREACH(sd->subobjs, l, child)
|
2011-04-01 04:20:18 -07:00
|
|
|
{
|
2011-08-02 03:34:30 -07:00
|
|
|
if (elm_widget_focus_get(child))
|
|
|
|
{
|
|
|
|
elm_widget_focused_object_clear(child);
|
|
|
|
break;
|
|
|
|
}
|
2011-04-01 04:20:18 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
2010-09-13 00:56:23 -07:00
|
|
|
_parent_focus(obj);
|
2008-10-06 18:23:49 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-08-09 01:36:02 -07:00
|
|
|
EAPI void
|
|
|
|
elm_widget_focus_restore(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Evas_Object *newest = NULL;
|
|
|
|
unsigned int newest_focus_order = 0;
|
|
|
|
API_ENTRY return;
|
|
|
|
|
|
|
|
newest = _newest_focus_order_get(obj, &newest_focus_order, EINA_TRUE);
|
|
|
|
if (newest)
|
|
|
|
{
|
|
|
|
elm_object_focus_set(newest, EINA_FALSE);
|
|
|
|
elm_object_focus_set(newest, EINA_TRUE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-09-06 23:15:55 -07:00
|
|
|
void
|
|
|
|
_elm_widget_top_win_focused_set(Evas_Object *obj, Eina_Bool top_win_focused)
|
|
|
|
{
|
|
|
|
const Eina_List *l;
|
|
|
|
Evas_Object *child;
|
|
|
|
API_ENTRY return;
|
|
|
|
|
|
|
|
if (sd->top_win_focused == top_win_focused) return;
|
|
|
|
if (sd->resize_obj)
|
|
|
|
_elm_widget_top_win_focused_set(sd->resize_obj, top_win_focused);
|
|
|
|
EINA_LIST_FOREACH(sd->subobjs, l, child)
|
|
|
|
{
|
|
|
|
_elm_widget_top_win_focused_set(child, top_win_focused);
|
|
|
|
}
|
|
|
|
sd->top_win_focused = top_win_focused;
|
|
|
|
}
|
|
|
|
|
|
|
|
Eina_Bool
|
|
|
|
_elm_widget_top_win_focused_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
API_ENTRY return EINA_FALSE;
|
|
|
|
return sd->top_win_focused;
|
|
|
|
}
|
|
|
|
|
2008-10-06 18:23:49 -07:00
|
|
|
EAPI void
|
|
|
|
elm_widget_activate(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
2008-10-06 18:23:49 -07:00
|
|
|
elm_widget_change(obj);
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
if (_elm_legacy_is(obj) && COMPAT_SMART_DATA(sd)->activate)
|
|
|
|
COMPAT_SMART_DATA(sd)->activate(obj);
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_widget_change(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
2008-10-06 18:23:49 -07:00
|
|
|
elm_widget_change(elm_widget_parent_get(obj));
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
if (_elm_legacy_is(obj) && COMPAT_SMART_DATA(sd)->on_change)
|
|
|
|
COMPAT_SMART_DATA(sd)->on_change
|
|
|
|
(COMPAT_SMART_DATA(sd)->on_change_data, obj);
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_disabled_set(Evas_Object *obj,
|
2011-04-27 09:12:56 -07:00
|
|
|
Eina_Bool disabled)
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
2009-10-17 23:03:03 -07:00
|
|
|
|
2009-08-26 09:52:53 -07:00
|
|
|
if (sd->disabled == disabled) return;
|
2011-04-27 09:12:56 -07:00
|
|
|
sd->disabled = !!disabled;
|
2011-07-12 01:22:16 -07:00
|
|
|
elm_widget_focus_disabled_handle(obj);
|
2012-05-20 21:17:11 -07:00
|
|
|
if (!sd->api) return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
sd->api->disable(obj);
|
2008-10-06 18:23:49 -07:00
|
|
|
}
|
|
|
|
|
2011-04-27 09:12:56 -07:00
|
|
|
EAPI Eina_Bool
|
2009-02-25 07:54:26 -08:00
|
|
|
elm_widget_disabled_get(const Evas_Object *obj)
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return 0;
|
|
|
|
return sd->disabled;
|
|
|
|
}
|
|
|
|
|
2008-10-17 07:40:54 -07:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_show_region_set(Evas_Object *obj,
|
|
|
|
Evas_Coord x,
|
|
|
|
Evas_Coord y,
|
|
|
|
Evas_Coord w,
|
2011-07-08 00:50:36 -07:00
|
|
|
Evas_Coord h,
|
|
|
|
Eina_Bool forceshow)
|
2008-10-17 07:40:54 -07:00
|
|
|
{
|
2010-12-16 01:53:25 -08:00
|
|
|
Evas_Object *parent_obj, *child_obj;
|
|
|
|
Evas_Coord px, py, cx, cy;
|
|
|
|
|
2008-10-17 07:40:54 -07:00
|
|
|
API_ENTRY return;
|
2012-03-28 02:02:22 -07:00
|
|
|
|
2012-02-20 04:23:46 -08:00
|
|
|
evas_smart_objects_calculate(evas_object_evas_get(obj));
|
2012-03-28 02:02:22 -07:00
|
|
|
|
|
|
|
if (!forceshow && (x == sd->rx) && (y == sd->ry) &&
|
2012-02-20 04:23:46 -08:00
|
|
|
(w == sd->rw) && (h == sd->rh)) return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
2008-10-17 07:40:54 -07:00
|
|
|
sd->rx = x;
|
|
|
|
sd->ry = y;
|
|
|
|
sd->rw = w;
|
|
|
|
sd->rh = h;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
if (sd->on_show_region)
|
|
|
|
sd->on_show_region
|
|
|
|
(sd->on_show_region_data, obj);
|
2010-12-16 01:53:25 -08:00
|
|
|
|
|
|
|
do
|
2010-10-08 05:50:40 -07:00
|
|
|
{
|
2011-03-09 23:22:22 -08:00
|
|
|
parent_obj = sd->parent_obj;
|
2011-03-23 00:15:01 -07:00
|
|
|
child_obj = sd->obj;
|
2011-03-17 05:10:02 -07:00
|
|
|
if ((!parent_obj) || (!_elm_widget_is(parent_obj))) break;
|
2010-12-16 01:53:25 -08:00
|
|
|
sd = evas_object_smart_data_get(parent_obj);
|
2011-03-17 05:10:02 -07:00
|
|
|
if (!sd) break;
|
2010-12-16 01:53:25 -08:00
|
|
|
|
|
|
|
evas_object_geometry_get(parent_obj, &px, &py, NULL, NULL);
|
|
|
|
evas_object_geometry_get(child_obj, &cx, &cy, NULL, NULL);
|
|
|
|
|
|
|
|
x += (cx - px);
|
|
|
|
y += (cy - py);
|
|
|
|
sd->rx = x;
|
|
|
|
sd->ry = y;
|
|
|
|
sd->rw = w;
|
|
|
|
sd->rh = h;
|
|
|
|
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
if (sd->on_show_region)
|
2010-10-08 05:50:40 -07:00
|
|
|
{
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
sd->on_show_region
|
|
|
|
(sd->on_show_region_data, parent_obj);
|
2010-10-08 05:50:40 -07:00
|
|
|
}
|
|
|
|
}
|
2010-12-16 01:53:25 -08:00
|
|
|
while (parent_obj);
|
2008-10-17 07:40:54 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_show_region_get(const Evas_Object *obj,
|
|
|
|
Evas_Coord *x,
|
|
|
|
Evas_Coord *y,
|
|
|
|
Evas_Coord *w,
|
|
|
|
Evas_Coord *h)
|
2008-10-17 07:40:54 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
|
|
|
if (x) *x = sd->rx;
|
|
|
|
if (y) *y = sd->ry;
|
|
|
|
if (w) *w = sd->rw;
|
|
|
|
if (h) *h = sd->rh;
|
|
|
|
}
|
|
|
|
|
2010-10-22 11:29:51 -07:00
|
|
|
/**
|
2010-12-07 11:17:50 -08:00
|
|
|
* @internal
|
|
|
|
*
|
2010-10-22 11:29:51 -07:00
|
|
|
* Get the focus region of the given widget.
|
|
|
|
*
|
|
|
|
* The focus region is the area of a widget that should brought into the
|
|
|
|
* visible area when the widget is focused. Mostly used to show the part of
|
|
|
|
* an entry where the cursor is, for example. The area returned is relative
|
|
|
|
* to the object @p obj.
|
|
|
|
* If the @p obj doesn't have the proper on_focus_region_hook set, this
|
|
|
|
* function will return the full size of the object.
|
|
|
|
*
|
|
|
|
* @param obj The widget object
|
|
|
|
* @param x Where to store the x coordinate of the area
|
|
|
|
* @param y Where to store the y coordinate of the area
|
|
|
|
* @param w Where to store the width of the area
|
|
|
|
* @param h Where to store the height of the area
|
|
|
|
*
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_focus_region_get(const Evas_Object *obj,
|
|
|
|
Evas_Coord *x,
|
|
|
|
Evas_Coord *y,
|
|
|
|
Evas_Coord *w,
|
|
|
|
Evas_Coord *h)
|
2010-10-22 11:29:51 -07:00
|
|
|
{
|
2012-05-03 15:40:58 -07:00
|
|
|
Elm_Widget_Smart_Data *sd;
|
2010-10-22 11:29:51 -07:00
|
|
|
|
|
|
|
if (!obj) return;
|
|
|
|
|
|
|
|
sd = evas_object_smart_data_get(obj);
|
2012-07-25 15:03:15 -07:00
|
|
|
if (!sd || !_elm_widget_is(obj) || !sd->on_focus_region)
|
2010-10-22 11:29:51 -07:00
|
|
|
{
|
|
|
|
evas_object_geometry_get(obj, NULL, NULL, w, h);
|
|
|
|
if (x) *x = 0;
|
|
|
|
if (y) *y = 0;
|
|
|
|
return;
|
|
|
|
}
|
2012-07-25 15:03:15 -07:00
|
|
|
sd->on_focus_region(obj, x, y, w, h);
|
2010-10-22 11:29:51 -07:00
|
|
|
}
|
|
|
|
|
2008-11-18 02:11:57 -08:00
|
|
|
EAPI void
|
|
|
|
elm_widget_scroll_hold_push(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
API_ENTRY return;
|
|
|
|
sd->scroll_hold++;
|
2009-03-20 08:08:33 -07:00
|
|
|
if (sd->scroll_hold == 1)
|
2012-07-04 14:41:01 -07:00
|
|
|
{
|
|
|
|
if (_elm_scrollable_is(obj))
|
|
|
|
{
|
|
|
|
ELM_SCROLLABLE_IFACE_GET(obj, s_iface);
|
|
|
|
s_iface->hold_set(obj, EINA_TRUE);
|
|
|
|
}
|
|
|
|
else /* FIXME: this will vanish as soon as we don't have
|
|
|
|
* any legacy widget anymore */
|
|
|
|
evas_object_smart_callback_call(obj, "scroll-hold-on", obj);
|
|
|
|
}
|
2008-11-18 02:11:57 -08:00
|
|
|
if (sd->parent_obj) elm_widget_scroll_hold_push(sd->parent_obj);
|
2009-09-07 21:41:36 -07:00
|
|
|
// FIXME: on delete/reparent hold pop
|
2008-11-18 02:11:57 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_widget_scroll_hold_pop(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
API_ENTRY return;
|
|
|
|
sd->scroll_hold--;
|
2010-10-22 14:41:27 -07:00
|
|
|
if (!sd->scroll_hold)
|
2012-07-04 14:41:01 -07:00
|
|
|
{
|
|
|
|
if (_elm_scrollable_is(obj))
|
|
|
|
{
|
|
|
|
ELM_SCROLLABLE_IFACE_GET(obj, s_iface);
|
|
|
|
s_iface->hold_set(obj, EINA_FALSE);
|
|
|
|
}
|
|
|
|
else /* FIXME: this will vanish as soon as we don't have
|
|
|
|
* any legacy widget anymore */
|
|
|
|
evas_object_smart_callback_call(obj, "scroll-hold-off", obj);
|
|
|
|
}
|
2008-11-18 02:11:57 -08:00
|
|
|
if (sd->parent_obj) elm_widget_scroll_hold_pop(sd->parent_obj);
|
2012-01-08 23:03:28 -08:00
|
|
|
if (sd->scroll_hold < 0) sd->scroll_hold = 0;
|
2008-11-18 02:11:57 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI int
|
2009-02-25 07:54:26 -08:00
|
|
|
elm_widget_scroll_hold_get(const Evas_Object *obj)
|
2008-11-18 02:11:57 -08:00
|
|
|
{
|
|
|
|
API_ENTRY return 0;
|
|
|
|
return sd->scroll_hold;
|
|
|
|
}
|
|
|
|
|
2009-03-20 08:08:33 -07:00
|
|
|
EAPI void
|
|
|
|
elm_widget_scroll_freeze_push(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
API_ENTRY return;
|
|
|
|
sd->scroll_freeze++;
|
|
|
|
if (sd->scroll_freeze == 1)
|
2012-07-04 14:41:01 -07:00
|
|
|
{
|
|
|
|
if (_elm_scrollable_is(obj))
|
|
|
|
{
|
|
|
|
ELM_SCROLLABLE_IFACE_GET(obj, s_iface);
|
|
|
|
s_iface->freeze_set(obj, EINA_TRUE);
|
|
|
|
}
|
|
|
|
else /* FIXME: this will vanish as soon as we don't have
|
|
|
|
* any legacy widget anymore */
|
|
|
|
evas_object_smart_callback_call(obj, "scroll-freeze-on", obj);
|
|
|
|
}
|
2009-03-20 08:08:33 -07:00
|
|
|
if (sd->parent_obj) elm_widget_scroll_freeze_push(sd->parent_obj);
|
2009-09-07 21:41:36 -07:00
|
|
|
// FIXME: on delete/reparent freeze pop
|
2009-03-20 08:08:33 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_widget_scroll_freeze_pop(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
API_ENTRY return;
|
|
|
|
sd->scroll_freeze--;
|
2010-10-22 14:41:27 -07:00
|
|
|
if (!sd->scroll_freeze)
|
2012-07-04 14:41:01 -07:00
|
|
|
{
|
|
|
|
if (_elm_scrollable_is(obj))
|
|
|
|
{
|
|
|
|
ELM_SCROLLABLE_IFACE_GET(obj, s_iface);
|
|
|
|
s_iface->freeze_set(obj, EINA_FALSE);
|
|
|
|
}
|
|
|
|
else /* FIXME: this will vanish as soon as we don't have
|
|
|
|
* any legacy widget anymore */
|
|
|
|
evas_object_smart_callback_call(obj, "scroll-freeze-off", obj);
|
|
|
|
}
|
2009-03-20 08:08:33 -07:00
|
|
|
if (sd->parent_obj) elm_widget_scroll_freeze_pop(sd->parent_obj);
|
2012-01-08 22:59:33 -08:00
|
|
|
if (sd->scroll_freeze < 0) sd->scroll_freeze = 0;
|
2009-03-20 08:08:33 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI int
|
|
|
|
elm_widget_scroll_freeze_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
API_ENTRY return 0;
|
|
|
|
return sd->scroll_freeze;
|
|
|
|
}
|
|
|
|
|
2009-02-02 21:09:03 -08:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_scale_set(Evas_Object *obj,
|
|
|
|
double scale)
|
2009-02-02 21:09:03 -08:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
|
|
|
if (scale <= 0.0) scale = 0.0;
|
|
|
|
if (sd->scale != scale)
|
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
sd->scale = scale;
|
|
|
|
elm_widget_theme(obj);
|
2009-02-02 21:09:03 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI double
|
2009-02-25 07:54:26 -08:00
|
|
|
elm_widget_scale_get(const Evas_Object *obj)
|
2009-02-02 21:09:03 -08:00
|
|
|
{
|
|
|
|
API_ENTRY return 1.0;
|
2010-06-21 00:39:49 -07:00
|
|
|
// FIXME: save walking up the tree by storing/caching parent scale
|
2009-06-12 15:55:06 -07:00
|
|
|
if (sd->scale == 0.0)
|
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
if (sd->parent_obj)
|
|
|
|
return elm_widget_scale_get(sd->parent_obj);
|
|
|
|
else
|
|
|
|
return 1.0;
|
2009-06-12 15:55:06 -07:00
|
|
|
}
|
2009-02-02 21:09:03 -08:00
|
|
|
return sd->scale;
|
|
|
|
}
|
|
|
|
|
2010-05-11 18:03:46 -07:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_theme_set(Evas_Object *obj,
|
|
|
|
Elm_Theme *th)
|
2010-05-11 18:03:46 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
|
|
|
if (sd->theme != th)
|
|
|
|
{
|
|
|
|
if (sd->theme) elm_theme_free(sd->theme);
|
|
|
|
sd->theme = th;
|
|
|
|
if (th) th->ref++;
|
|
|
|
elm_widget_theme(obj);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-06-28 23:40:59 -07:00
|
|
|
EAPI void
|
2011-08-03 05:27:57 -07:00
|
|
|
elm_widget_text_part_set(Evas_Object *obj, const char *part, const char *label)
|
2011-06-28 23:40:59 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
|
|
|
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
if (_elm_legacy_is(obj) && COMPAT_SMART_DATA(sd)->text_set)
|
|
|
|
COMPAT_SMART_DATA(sd)->text_set(obj, part, label);
|
2012-05-03 15:41:26 -07:00
|
|
|
else if (evas_object_smart_type_check(obj, "elm_layout"))
|
|
|
|
elm_layout_text_set(obj, part, label);
|
2011-06-28 23:40:59 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI const char *
|
2011-08-03 05:27:57 -07:00
|
|
|
elm_widget_text_part_get(const Evas_Object *obj, const char *part)
|
2011-06-28 23:40:59 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return NULL;
|
|
|
|
|
2012-05-03 15:41:26 -07:00
|
|
|
if (_elm_legacy_is(obj) && COMPAT_SMART_DATA(sd)->text_get)
|
|
|
|
return COMPAT_SMART_DATA(sd)->text_get(obj, part);
|
|
|
|
else if (evas_object_smart_type_check(obj, "elm_layout"))
|
|
|
|
return elm_layout_text_get(obj, part);
|
2011-06-28 23:40:59 -07:00
|
|
|
|
2012-05-03 15:41:26 -07:00
|
|
|
return NULL;
|
2011-06-28 23:40:59 -07:00
|
|
|
}
|
|
|
|
|
2011-10-19 07:17:14 -07:00
|
|
|
EAPI void
|
|
|
|
elm_widget_domain_translatable_text_part_set(Evas_Object *obj, const char *part, const char *domain, const char *label)
|
|
|
|
{
|
|
|
|
const char *str;
|
|
|
|
Eina_List *l;
|
|
|
|
Elm_Translate_String_Data *ts = NULL;
|
|
|
|
API_ENTRY return;
|
|
|
|
|
|
|
|
str = eina_stringshare_add(part);
|
|
|
|
EINA_LIST_FOREACH(sd->translate_strings, l, ts)
|
|
|
|
if (ts->id == str)
|
|
|
|
break;
|
|
|
|
else
|
|
|
|
ts = NULL;
|
|
|
|
|
|
|
|
if (!ts && !label)
|
|
|
|
eina_stringshare_del(str);
|
|
|
|
else if (!ts)
|
|
|
|
{
|
|
|
|
ts = malloc(sizeof(Elm_Translate_String_Data));
|
|
|
|
if (!ts) return;
|
|
|
|
|
|
|
|
ts->id = str;
|
|
|
|
ts->domain = eina_stringshare_add(domain);
|
|
|
|
ts->string = eina_stringshare_add(label);
|
|
|
|
sd->translate_strings = eina_list_append(sd->translate_strings, ts);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (label)
|
|
|
|
{
|
|
|
|
eina_stringshare_replace(&ts->domain, domain);
|
|
|
|
eina_stringshare_replace(&ts->string, label);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
sd->translate_strings = eina_list_remove_list(
|
|
|
|
sd->translate_strings, l);
|
|
|
|
eina_stringshare_del(ts->id);
|
|
|
|
eina_stringshare_del(ts->domain);
|
|
|
|
eina_stringshare_del(ts->string);
|
|
|
|
free(ts);
|
|
|
|
}
|
|
|
|
eina_stringshare_del(str);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef HAVE_GETTEXT
|
|
|
|
if (label && label[0])
|
|
|
|
label = dgettext(domain, label);
|
|
|
|
#endif
|
|
|
|
elm_widget_text_part_set(obj, part, label);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI const char *
|
|
|
|
elm_widget_translatable_text_part_get(const Evas_Object *obj, const char *part)
|
|
|
|
{
|
|
|
|
const char *str, *ret = NULL;
|
|
|
|
Eina_List *l;
|
|
|
|
Elm_Translate_String_Data *ts;
|
|
|
|
API_ENTRY return NULL;
|
|
|
|
|
|
|
|
str = eina_stringshare_add(part);
|
|
|
|
EINA_LIST_FOREACH(sd->translate_strings, l, ts)
|
|
|
|
if (ts->id == str)
|
|
|
|
{
|
|
|
|
ret = ts->string;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
eina_stringshare_del(str);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_widget_translate(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
const Eina_List *l;
|
|
|
|
Evas_Object *child;
|
2011-11-20 05:58:35 -08:00
|
|
|
#ifdef HAVE_GETTEXT
|
2011-10-19 07:17:14 -07:00
|
|
|
Elm_Translate_String_Data *ts;
|
2011-11-20 05:58:35 -08:00
|
|
|
#endif
|
2011-10-19 07:17:14 -07:00
|
|
|
|
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
2011-10-19 07:17:14 -07:00
|
|
|
EINA_LIST_FOREACH(sd->subobjs, l, child) elm_widget_translate(child);
|
|
|
|
if (sd->resize_obj) elm_widget_translate(sd->resize_obj);
|
|
|
|
if (sd->hover_obj) elm_widget_translate(sd->hover_obj);
|
2012-05-20 21:17:11 -07:00
|
|
|
if (!sd->api) return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
sd->api->translate(obj);
|
2011-10-19 07:17:14 -07:00
|
|
|
|
|
|
|
#ifdef HAVE_GETTEXT
|
|
|
|
EINA_LIST_FOREACH(sd->translate_strings, l, ts)
|
|
|
|
{
|
|
|
|
const char *s = dgettext(ts->domain, ts->string);
|
|
|
|
elm_widget_text_part_set(obj, ts->id, s);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2011-07-27 02:49:14 -07:00
|
|
|
EAPI void
|
2011-08-03 05:27:57 -07:00
|
|
|
elm_widget_content_part_set(Evas_Object *obj, const char *part, Evas_Object *content)
|
2011-07-27 02:49:14 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
|
|
|
|
2012-05-20 21:17:11 -07:00
|
|
|
if (!sd->api) return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
if (_elm_legacy_is(obj) && COMPAT_SMART_DATA(sd)->content_set)
|
|
|
|
COMPAT_SMART_DATA(sd)->content_set(obj, part, content);
|
2012-05-03 15:41:26 -07:00
|
|
|
else if (evas_object_smart_type_check(obj, "elm_container"))
|
|
|
|
ELM_CONTAINER_CLASS(sd->api)->content_set(obj, part, content);
|
2011-07-27 02:49:14 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Evas_Object *
|
2011-08-03 05:27:57 -07:00
|
|
|
elm_widget_content_part_get(const Evas_Object *obj, const char *part)
|
2011-07-27 02:49:14 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return NULL;
|
|
|
|
|
2012-05-20 21:17:11 -07:00
|
|
|
if (!sd->api) return NULL;
|
|
|
|
|
2012-05-03 15:41:26 -07:00
|
|
|
if (_elm_legacy_is(obj) && COMPAT_SMART_DATA(sd)->content_get)
|
|
|
|
return COMPAT_SMART_DATA(sd)->content_get(obj, part);
|
|
|
|
else if (evas_object_smart_type_check(obj, "elm_container"))
|
|
|
|
return ELM_CONTAINER_CLASS(sd->api)->content_get(obj, part);
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
2012-05-03 15:41:26 -07:00
|
|
|
return NULL;
|
2011-07-27 02:49:14 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Evas_Object *
|
2011-08-03 05:27:57 -07:00
|
|
|
elm_widget_content_part_unset(Evas_Object *obj, const char *part)
|
2011-07-27 02:49:14 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return NULL;
|
|
|
|
|
2012-05-20 21:17:11 -07:00
|
|
|
if (!sd->api) return NULL;
|
2012-05-03 15:41:26 -07:00
|
|
|
if (_elm_legacy_is(obj) && COMPAT_SMART_DATA(sd)->content_unset)
|
|
|
|
return COMPAT_SMART_DATA(sd)->content_unset(obj, part);
|
|
|
|
else if (evas_object_smart_type_check(obj, "elm_container"))
|
|
|
|
return ELM_CONTAINER_CLASS(sd->api)->content_unset(obj, part);
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
2012-05-03 15:41:26 -07:00
|
|
|
return NULL;
|
2011-07-27 02:49:14 -07:00
|
|
|
}
|
|
|
|
|
2011-08-19 04:47:30 -07:00
|
|
|
EAPI void
|
|
|
|
elm_widget_access_info_set(Evas_Object *obj, const char *txt)
|
|
|
|
{
|
|
|
|
API_ENTRY return;
|
|
|
|
if (sd->access_info) eina_stringshare_del(sd->access_info);
|
|
|
|
if (!txt) sd->access_info = NULL;
|
|
|
|
else sd->access_info = eina_stringshare_add(txt);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI const char *
|
2012-02-20 04:13:08 -08:00
|
|
|
elm_widget_access_info_get(const Evas_Object *obj)
|
2011-08-19 04:47:30 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return NULL;
|
|
|
|
return sd->access_info;
|
|
|
|
}
|
|
|
|
|
2010-05-11 18:03:46 -07:00
|
|
|
EAPI Elm_Theme *
|
|
|
|
elm_widget_theme_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
API_ENTRY return NULL;
|
|
|
|
if (!sd->theme)
|
|
|
|
{
|
|
|
|
if (sd->parent_obj)
|
2011-04-01 04:20:18 -07:00
|
|
|
return elm_widget_theme_get(sd->parent_obj);
|
2010-05-11 18:03:46 -07:00
|
|
|
else
|
2011-04-01 04:20:18 -07:00
|
|
|
return NULL;
|
2010-05-11 18:03:46 -07:00
|
|
|
}
|
|
|
|
return sd->theme;
|
|
|
|
}
|
|
|
|
|
2012-03-06 10:39:53 -08:00
|
|
|
EAPI Eina_Bool
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_style_set(Evas_Object *obj,
|
|
|
|
const char *style)
|
2009-04-22 21:03:27 -07:00
|
|
|
{
|
2012-03-06 10:39:53 -08:00
|
|
|
API_ENTRY return EINA_FALSE;
|
2011-03-09 23:22:22 -08:00
|
|
|
|
2010-03-13 13:01:26 -08:00
|
|
|
if (eina_stringshare_replace(&sd->style, style))
|
2012-03-06 10:39:53 -08:00
|
|
|
return elm_widget_theme(obj);
|
|
|
|
|
|
|
|
return EINA_TRUE;
|
2009-04-22 21:03:27 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI const char *
|
|
|
|
elm_widget_style_get(const Evas_Object *obj)
|
|
|
|
{
|
2010-10-21 11:58:40 -07:00
|
|
|
API_ENTRY return NULL;
|
2009-04-22 21:03:27 -07:00
|
|
|
if (sd->style) return sd->style;
|
|
|
|
return "default";
|
|
|
|
}
|
|
|
|
|
2009-05-13 05:21:52 -07:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_type_set(Evas_Object *obj,
|
|
|
|
const char *type)
|
2009-05-13 05:21:52 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
|
|
|
if (!_elm_legacy_is(obj)) return;
|
|
|
|
|
|
|
|
eina_stringshare_replace(&(COMPAT_SMART_DATA(sd)->type), type);
|
2009-05-13 05:21:52 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI const char *
|
|
|
|
elm_widget_type_get(const Evas_Object *obj)
|
|
|
|
{
|
2010-10-21 11:58:40 -07:00
|
|
|
API_ENTRY return NULL;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
|
|
|
if (_elm_legacy_is(obj) && (COMPAT_SMART_DATA(sd)->type))
|
|
|
|
return COMPAT_SMART_DATA(sd)->type;
|
|
|
|
|
|
|
|
return evas_object_type_get(obj);
|
2009-05-13 05:21:52 -07:00
|
|
|
}
|
|
|
|
|
2010-09-13 00:56:23 -07:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_tooltip_add(Evas_Object *obj,
|
|
|
|
Elm_Tooltip *tt)
|
2010-09-10 17:52:33 -07:00
|
|
|
{
|
|
|
|
API_ENTRY 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
|
|
|
sd->tooltips = eina_list_append(sd->tooltips, tt);
|
|
|
|
}
|
|
|
|
|
2010-09-13 00:56:23 -07:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_tooltip_del(Evas_Object *obj,
|
|
|
|
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
|
|
|
{
|
|
|
|
API_ENTRY return;
|
|
|
|
sd->tooltips = eina_list_remove(sd->tooltips, tt);
|
2010-09-10 17:52:33 -07:00
|
|
|
}
|
2010-05-07 06:21:45 -07:00
|
|
|
|
2010-09-25 15:01:19 -07:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_cursor_add(Evas_Object *obj,
|
|
|
|
Elm_Cursor *cur)
|
2010-09-25 15:01:19 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
|
|
|
sd->cursors = eina_list_append(sd->cursors, cur);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_cursor_del(Evas_Object *obj,
|
|
|
|
Elm_Cursor *cur)
|
2010-09-25 15:01:19 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
|
|
|
sd->cursors = eina_list_remove(sd->cursors, cur);
|
|
|
|
}
|
|
|
|
|
2010-05-07 06:21:45 -07:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_drag_lock_x_set(Evas_Object *obj,
|
|
|
|
Eina_Bool lock)
|
2010-05-07 06:21:45 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
|
|
|
if (sd->drag_x_locked == lock) return;
|
|
|
|
sd->drag_x_locked = lock;
|
|
|
|
if (sd->drag_x_locked) _propagate_x_drag_lock(obj, 1);
|
|
|
|
else _propagate_x_drag_lock(obj, -1);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_drag_lock_y_set(Evas_Object *obj,
|
|
|
|
Eina_Bool lock)
|
2010-05-07 06:21:45 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
|
|
|
if (sd->drag_y_locked == lock) return;
|
|
|
|
sd->drag_y_locked = lock;
|
|
|
|
if (sd->drag_y_locked) _propagate_y_drag_lock(obj, 1);
|
|
|
|
else _propagate_y_drag_lock(obj, -1);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
2010-07-10 15:05:37 -07:00
|
|
|
elm_widget_drag_lock_x_get(const Evas_Object *obj)
|
2010-05-07 06:21:45 -07:00
|
|
|
{
|
2010-06-05 06:12:45 -07:00
|
|
|
API_ENTRY return EINA_FALSE;
|
2010-05-07 06:21:45 -07:00
|
|
|
return sd->drag_x_locked;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
2010-07-10 15:05:37 -07:00
|
|
|
elm_widget_drag_lock_y_get(const Evas_Object *obj)
|
2010-05-07 06:21:45 -07:00
|
|
|
{
|
2010-06-05 06:12:45 -07:00
|
|
|
API_ENTRY return EINA_FALSE;
|
2010-05-07 06:21:45 -07:00
|
|
|
return sd->drag_y_locked;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI int
|
2010-07-10 15:05:37 -07:00
|
|
|
elm_widget_drag_child_locked_x_get(const Evas_Object *obj)
|
2010-05-07 06:21:45 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return 0;
|
|
|
|
return sd->child_drag_x_locked;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI int
|
2010-07-10 15:05:37 -07:00
|
|
|
elm_widget_drag_child_locked_y_get(const Evas_Object *obj)
|
2010-05-07 06:21:45 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return 0;
|
|
|
|
return sd->child_drag_y_locked;
|
|
|
|
}
|
|
|
|
|
2010-10-21 11:58:40 -07:00
|
|
|
EAPI Eina_Bool
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_theme_object_set(Evas_Object *obj,
|
|
|
|
Evas_Object *edj,
|
|
|
|
const char *wname,
|
|
|
|
const char *welement,
|
|
|
|
const char *wstyle)
|
2010-09-13 00:56:23 -07:00
|
|
|
{
|
2010-10-21 11:58:40 -07:00
|
|
|
API_ENTRY return EINA_FALSE;
|
2010-09-13 00:56:23 -07:00
|
|
|
return _elm_theme_object_set(obj, edj, wname, welement, wstyle);
|
|
|
|
}
|
2010-05-07 06:21:45 -07:00
|
|
|
|
2011-08-28 07:12:38 -07:00
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_widget_is_check(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
static int abort_on_warn = -1;
|
|
|
|
if (elm_widget_is(obj))
|
|
|
|
return EINA_TRUE;
|
|
|
|
|
|
|
|
ERR("Passing Object: %p.", obj);
|
|
|
|
if (abort_on_warn == -1)
|
|
|
|
{
|
|
|
|
if (getenv("ELM_ERROR_ABORT")) abort_on_warn = 1;
|
|
|
|
else abort_on_warn = 0;
|
|
|
|
}
|
|
|
|
if (abort_on_warn == 1) abort();
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
2010-09-13 00:56:23 -07:00
|
|
|
EAPI Eina_Bool
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_type_check(const Evas_Object *obj,
|
2011-09-11 19:06:27 -07:00
|
|
|
const char *type,
|
|
|
|
const char *func)
|
2008-09-29 23:58:56 -07:00
|
|
|
{
|
2010-09-13 00:56:23 -07:00
|
|
|
const char *provided, *expected = "(unknown)";
|
|
|
|
static int abort_on_warn = -1;
|
|
|
|
provided = elm_widget_type_get(obj);
|
2012-05-03 15:41:26 -07:00
|
|
|
if (_elm_legacy_is(obj) && EINA_LIKELY(provided == type))
|
|
|
|
return EINA_TRUE;
|
|
|
|
/* TODO: eventually migrate to check_ptr version */
|
|
|
|
else if (evas_object_smart_type_check(obj, type)) return EINA_TRUE;
|
2010-09-13 00:56:23 -07:00
|
|
|
if (type) expected = type;
|
2010-10-22 14:41:27 -07:00
|
|
|
if ((!provided) || (!provided[0]))
|
2008-10-06 18:23:49 -07:00
|
|
|
{
|
2010-09-13 00:56:23 -07:00
|
|
|
provided = evas_object_type_get(obj);
|
2010-10-22 14:41:27 -07:00
|
|
|
if ((!provided) || (!provided[0]))
|
2011-04-01 04:20:18 -07:00
|
|
|
provided = "(unknown)";
|
2008-10-07 23:38:20 -07:00
|
|
|
}
|
2011-09-11 19:06:27 -07:00
|
|
|
ERR("Passing Object: %p in function: %s, of type: '%s' when expecting type: '%s'", obj, func, provided, expected);
|
2010-09-13 00:56:23 -07:00
|
|
|
if (abort_on_warn == -1)
|
2008-10-07 23:38:20 -07:00
|
|
|
{
|
2010-09-13 00:56:23 -07:00
|
|
|
if (getenv("ELM_ERROR_ABORT")) abort_on_warn = 1;
|
|
|
|
else abort_on_warn = 0;
|
2008-10-07 23:38:20 -07:00
|
|
|
}
|
2010-09-13 00:56:23 -07:00
|
|
|
if (abort_on_warn == 1) abort();
|
|
|
|
return EINA_FALSE;
|
2008-09-29 23:58:56 -07:00
|
|
|
}
|
|
|
|
|
2011-12-27 21:51:10 -08:00
|
|
|
static Evas_Object *
|
2011-12-27 22:01:31 -08:00
|
|
|
_widget_name_find(const Evas_Object *obj, const char *name, int recurse)
|
2011-12-27 21:51:10 -08:00
|
|
|
{
|
|
|
|
Eina_List *l;
|
|
|
|
Evas_Object *child;
|
|
|
|
const char *s;
|
|
|
|
INTERNAL_ENTRY NULL;
|
2012-03-28 02:02:22 -07:00
|
|
|
|
2011-12-27 21:51:10 -08:00
|
|
|
if (!_elm_widget_is(obj)) return NULL;
|
|
|
|
if (sd->resize_obj)
|
|
|
|
{
|
|
|
|
s = evas_object_name_get(sd->resize_obj);
|
|
|
|
if ((s) && (!strcmp(s, name))) return sd->resize_obj;
|
2012-03-28 02:02:22 -07:00
|
|
|
if ((recurse != 0) &&
|
2011-12-27 22:01:31 -08:00
|
|
|
((child = _widget_name_find(sd->resize_obj, name, recurse - 1))))
|
2011-12-27 21:51:10 -08:00
|
|
|
return child;
|
|
|
|
}
|
|
|
|
EINA_LIST_FOREACH(sd->subobjs, l, child)
|
|
|
|
{
|
|
|
|
s = evas_object_name_get(child);
|
|
|
|
if ((s) && (!strcmp(s, name))) return child;
|
2012-03-28 02:02:22 -07:00
|
|
|
if ((recurse != 0) &&
|
2011-12-27 22:01:31 -08:00
|
|
|
((child = _widget_name_find(child, name, recurse - 1))))
|
2011-12-27 21:51:10 -08:00
|
|
|
return child;
|
|
|
|
}
|
|
|
|
if (sd->hover_obj)
|
|
|
|
{
|
|
|
|
s = evas_object_name_get(sd->hover_obj);
|
|
|
|
if ((s) && (!strcmp(s, name))) return sd->hover_obj;
|
2012-03-28 02:02:22 -07:00
|
|
|
if ((recurse != 0) &&
|
2011-12-27 22:01:31 -08:00
|
|
|
((child = _widget_name_find(sd->hover_obj, name, recurse - 1))))
|
2011-12-27 21:51:10 -08:00
|
|
|
return child;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Evas_Object *
|
2011-12-27 22:01:31 -08:00
|
|
|
elm_widget_name_find(const Evas_Object *obj, const char *name, int recurse)
|
2011-12-27 21:51:10 -08:00
|
|
|
{
|
|
|
|
API_ENTRY return NULL;
|
|
|
|
if (!name) return NULL;
|
|
|
|
return _widget_name_find(obj, name, recurse);
|
|
|
|
}
|
|
|
|
|
2010-10-21 11:58:40 -07:00
|
|
|
/**
|
2010-12-07 11:17:50 -08:00
|
|
|
* @internal
|
|
|
|
*
|
2010-10-21 11:58:40 -07:00
|
|
|
* Split string in words
|
|
|
|
*
|
|
|
|
* @param str Source string
|
|
|
|
* @return List of const words
|
|
|
|
*
|
|
|
|
* @see elm_widget_stringlist_free()
|
2010-12-07 11:17:50 -08:00
|
|
|
* @ingroup Widget
|
2010-10-21 11:58:40 -07:00
|
|
|
*/
|
2010-09-13 00:56:23 -07:00
|
|
|
EAPI Eina_List *
|
|
|
|
elm_widget_stringlist_get(const char *str)
|
2010-06-21 00:39:49 -07:00
|
|
|
{
|
2010-09-13 00:56:23 -07:00
|
|
|
Eina_List *list = NULL;
|
|
|
|
const char *s, *b;
|
|
|
|
if (!str) return NULL;
|
|
|
|
for (b = s = str; 1; s++)
|
2010-06-21 00:39:49 -07:00
|
|
|
{
|
2011-04-01 04:20:18 -07:00
|
|
|
if ((*s == ' ') || (!*s))
|
|
|
|
{
|
|
|
|
char *t = malloc(s - b + 1);
|
|
|
|
if (t)
|
|
|
|
{
|
|
|
|
strncpy(t, b, s - b);
|
|
|
|
t[s - b] = 0;
|
|
|
|
list = eina_list_append(list, eina_stringshare_add(t));
|
|
|
|
free(t);
|
|
|
|
}
|
|
|
|
b = s + 1;
|
|
|
|
}
|
|
|
|
if (!*s) break;
|
2010-06-21 00:39:49 -07:00
|
|
|
}
|
2010-09-13 00:56:23 -07:00
|
|
|
return list;
|
2010-06-21 00:39:49 -07:00
|
|
|
}
|
|
|
|
|
2010-09-13 00:56:23 -07:00
|
|
|
EAPI void
|
|
|
|
elm_widget_stringlist_free(Eina_List *list)
|
2010-06-23 19:54:03 -07:00
|
|
|
{
|
2010-09-13 00:56:23 -07:00
|
|
|
const char *s;
|
|
|
|
EINA_LIST_FREE(list, s) eina_stringshare_del(s);
|
2010-06-23 19:54:03 -07:00
|
|
|
}
|
|
|
|
|
2011-04-14 05:47:16 -07:00
|
|
|
EAPI void
|
|
|
|
elm_widget_focus_hide_handle(Evas_Object *obj)
|
|
|
|
{
|
2012-02-20 04:23:46 -08:00
|
|
|
if (!_elm_widget_is(obj))
|
|
|
|
return;
|
2011-04-14 05:47:16 -07:00
|
|
|
_if_focused_revert(obj, EINA_TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2011-08-08 03:32:32 -07:00
|
|
|
elm_widget_focus_mouse_up_handle(Evas_Object *obj)
|
2011-04-14 05:47:16 -07:00
|
|
|
{
|
|
|
|
Evas_Object *o = obj;
|
|
|
|
do
|
|
|
|
{
|
|
|
|
if (_elm_widget_is(o)) break;
|
|
|
|
o = evas_object_smart_parent_get(o);
|
|
|
|
}
|
|
|
|
while (o);
|
|
|
|
if (!o) return;
|
|
|
|
if (!_is_focusable(o)) return;
|
|
|
|
elm_widget_focus_steal(o);
|
|
|
|
}
|
|
|
|
|
2011-07-12 01:22:16 -07:00
|
|
|
EAPI void
|
2011-07-27 23:58:29 -07:00
|
|
|
elm_widget_focus_tree_unfocusable_handle(Evas_Object *obj)
|
2011-07-12 01:22:16 -07:00
|
|
|
{
|
|
|
|
API_ENTRY return;
|
|
|
|
|
2012-02-21 04:36:54 -08:00
|
|
|
//FIXME: Need to check whether the object is unfocusable or not.
|
|
|
|
|
2011-07-12 01:22:16 -07:00
|
|
|
if (!elm_widget_parent_get(obj))
|
|
|
|
elm_widget_focused_object_clear(obj);
|
|
|
|
else
|
|
|
|
_if_focused_revert(obj, EINA_TRUE);
|
|
|
|
}
|
|
|
|
|
2011-07-27 23:58:29 -07:00
|
|
|
EAPI void
|
|
|
|
elm_widget_focus_disabled_handle(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
API_ENTRY return;
|
|
|
|
|
|
|
|
elm_widget_focus_tree_unfocusable_handle(obj);
|
|
|
|
}
|
|
|
|
|
2012-02-21 02:54:46 -08:00
|
|
|
EAPI unsigned int
|
|
|
|
elm_widget_focus_order_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
API_ENTRY return 0;
|
2012-02-21 02:55:30 -08:00
|
|
|
return sd->focus_order;
|
2012-02-21 02:54:46 -08:00
|
|
|
}
|
|
|
|
|
2010-09-13 00:56:23 -07:00
|
|
|
/**
|
2010-12-07 11:17:50 -08:00
|
|
|
* @internal
|
|
|
|
*
|
2010-09-13 00:56:23 -07:00
|
|
|
* Allocate a new Elm_Widget_Item-derived structure.
|
|
|
|
*
|
|
|
|
* The goal of this structure is to provide common ground for actions
|
|
|
|
* that a widget item have, such as the owner widget, callback to
|
|
|
|
* notify deletion, data pointer and maybe more.
|
|
|
|
*
|
|
|
|
* @param widget the owner widget that holds this item, must be an elm_widget!
|
|
|
|
* @param alloc_size any number greater than sizeof(Elm_Widget_Item) that will
|
|
|
|
* be used to allocate memory.
|
|
|
|
*
|
|
|
|
* @return allocated memory that is already zeroed out, or NULL on errors.
|
|
|
|
*
|
|
|
|
* @see elm_widget_item_new() convenience macro.
|
|
|
|
* @see elm_widget_item_del() to release memory.
|
2010-12-07 11:17:50 -08:00
|
|
|
* @ingroup Widget
|
2010-09-13 00:56:23 -07:00
|
|
|
*/
|
|
|
|
EAPI Elm_Widget_Item *
|
2011-04-02 23:43:17 -07:00
|
|
|
_elm_widget_item_new(Evas_Object *widget,
|
|
|
|
size_t alloc_size)
|
2008-09-29 23:58:56 -07:00
|
|
|
{
|
2010-10-28 06:38:55 -07:00
|
|
|
if (!_elm_widget_is(widget))
|
|
|
|
return NULL;
|
|
|
|
|
2010-09-13 00:56:23 -07:00
|
|
|
Elm_Widget_Item *item;
|
2010-09-09 18:54:05 -07:00
|
|
|
|
|
|
|
EINA_SAFETY_ON_TRUE_RETURN_VAL(alloc_size < sizeof(Elm_Widget_Item), NULL);
|
|
|
|
EINA_SAFETY_ON_TRUE_RETURN_VAL(!_elm_widget_is(widget), NULL);
|
|
|
|
|
|
|
|
item = calloc(1, alloc_size);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(item, NULL);
|
|
|
|
|
|
|
|
EINA_MAGIC_SET(item, ELM_WIDGET_ITEM_MAGIC);
|
|
|
|
item->widget = widget;
|
|
|
|
return item;
|
|
|
|
}
|
|
|
|
|
2012-02-20 04:17:45 -08:00
|
|
|
EAPI void
|
elementary/menu, ctxpopup, index, segment_control, diskselector, multibuttonentry, toolbar, naviframe, slideshow, hoversel, filpselector - deprecated xxxx_item_del() APIs.
But instead, made to use the elm_object_item_del() APIs
for this, elm_widget_item needed to provide elm_widget_item_del_pre_hook.
SVN revision: 67010
2012-01-09 21:02:11 -08:00
|
|
|
_elm_widget_item_free(Elm_Widget_Item *item)
|
|
|
|
{
|
2012-04-03 00:30:11 -07:00
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
2012-02-23 20:31:03 -08:00
|
|
|
|
2012-03-29 02:54:21 -07:00
|
|
|
_elm_access_item_unregister(item);
|
2012-02-23 20:31:03 -08:00
|
|
|
|
elementary/menu, ctxpopup, index, segment_control, diskselector, multibuttonentry, toolbar, naviframe, slideshow, hoversel, filpselector - deprecated xxxx_item_del() APIs.
But instead, made to use the elm_object_item_del() APIs
for this, elm_widget_item needed to provide elm_widget_item_del_pre_hook.
SVN revision: 67010
2012-01-09 21:02:11 -08:00
|
|
|
if (item->del_func)
|
|
|
|
item->del_func((void *)item->data, item->widget, item);
|
|
|
|
|
|
|
|
if (item->view)
|
|
|
|
evas_object_del(item->view);
|
|
|
|
|
|
|
|
if (item->access)
|
|
|
|
{
|
|
|
|
_elm_access_clear(item->access);
|
|
|
|
free(item->access);
|
|
|
|
}
|
2012-01-27 03:56:14 -08:00
|
|
|
|
elementary/menu, ctxpopup, index, segment_control, diskselector, multibuttonentry, toolbar, naviframe, slideshow, hoversel, filpselector - deprecated xxxx_item_del() APIs.
But instead, made to use the elm_object_item_del() APIs
for this, elm_widget_item needed to provide elm_widget_item_del_pre_hook.
SVN revision: 67010
2012-01-09 21:02:11 -08:00
|
|
|
if (item->access_info)
|
2012-01-27 03:56:14 -08:00
|
|
|
eina_stringshare_del(item->access_info);
|
elementary/menu, ctxpopup, index, segment_control, diskselector, multibuttonentry, toolbar, naviframe, slideshow, hoversel, filpselector - deprecated xxxx_item_del() APIs.
But instead, made to use the elm_object_item_del() APIs
for this, elm_widget_item needed to provide elm_widget_item_del_pre_hook.
SVN revision: 67010
2012-01-09 21:02:11 -08:00
|
|
|
|
|
|
|
EINA_MAGIC_SET(item, EINA_MAGIC_NONE);
|
|
|
|
free(item);
|
|
|
|
}
|
|
|
|
|
2010-09-09 18:54:05 -07:00
|
|
|
/**
|
2010-12-07 11:17:50 -08:00
|
|
|
* @internal
|
|
|
|
*
|
2010-09-09 18:54:05 -07:00
|
|
|
* Releases widget item memory, calling back del_cb() if it exists.
|
|
|
|
*
|
|
|
|
* If there is a Elm_Widget_Item::del_cb, then it will be called prior
|
|
|
|
* to memory release. Note that elm_widget_item_pre_notify_del() calls
|
|
|
|
* this function and then unset it, thus being useful for 2 step
|
|
|
|
* cleanup whenever the del_cb may use any of the data that must be
|
|
|
|
* deleted from item.
|
|
|
|
*
|
|
|
|
* The Elm_Widget_Item::view will be deleted (evas_object_del()) if it
|
|
|
|
* is presented!
|
|
|
|
*
|
|
|
|
* @param item a valid #Elm_Widget_Item to be deleted.
|
|
|
|
* @see elm_widget_item_del() convenience macro.
|
2010-12-07 11:17:50 -08:00
|
|
|
* @ingroup Widget
|
2010-09-09 18:54:05 -07:00
|
|
|
*/
|
2010-09-13 00:56:23 -07:00
|
|
|
EAPI void
|
2010-09-09 18:54:05 -07:00
|
|
|
_elm_widget_item_del(Elm_Widget_Item *item)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
|
2012-01-27 03:56:14 -08:00
|
|
|
//Widget item delete callback
|
2012-01-09 16:33:51 -08:00
|
|
|
if (item->del_pre_func)
|
2012-01-27 03:56:14 -08:00
|
|
|
{
|
2012-03-06 03:51:42 -08:00
|
|
|
if (item->del_pre_func((Elm_Object_Item *)item))
|
2012-01-27 03:56:14 -08:00
|
|
|
_elm_widget_item_free(item);
|
|
|
|
}
|
2012-02-23 20:31:03 -08:00
|
|
|
else
|
|
|
|
_elm_widget_item_free(item);
|
2010-09-09 18:54:05 -07:00
|
|
|
}
|
|
|
|
|
2012-01-09 16:33:51 -08:00
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Set the function to notify to widgets when item is being deleted by user.
|
|
|
|
*
|
|
|
|
* @param item a valid #Elm_Widget_Item to be notified
|
|
|
|
* @see elm_widget_item_del_pre_hook_set() convenience macro.
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
2012-01-09 16:02:58 -08:00
|
|
|
EAPI void
|
2012-01-09 17:00:23 -08:00
|
|
|
_elm_widget_item_del_pre_hook_set(Elm_Widget_Item *item, Elm_Widget_Del_Pre_Cb func)
|
2012-01-09 16:02:58 -08:00
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
2012-01-09 16:33:51 -08:00
|
|
|
item->del_pre_func = func;
|
2012-01-09 16:02:58 -08:00
|
|
|
}
|
|
|
|
|
2010-09-09 18:54:05 -07:00
|
|
|
/**
|
2010-12-07 11:17:50 -08:00
|
|
|
* @internal
|
|
|
|
*
|
2010-09-09 18:54:05 -07:00
|
|
|
* Notify object will be deleted without actually deleting it.
|
|
|
|
*
|
|
|
|
* This function will callback Elm_Widget_Item::del_cb if it is set
|
|
|
|
* and then unset it so it is not called twice (ie: from
|
|
|
|
* elm_widget_item_del()).
|
|
|
|
*
|
|
|
|
* @param item a valid #Elm_Widget_Item to be notified
|
|
|
|
* @see elm_widget_item_pre_notify_del() convenience macro.
|
2010-12-07 11:17:50 -08:00
|
|
|
* @ingroup Widget
|
2010-09-09 18:54:05 -07:00
|
|
|
*/
|
2010-09-13 00:56:23 -07:00
|
|
|
EAPI void
|
2010-09-09 18:54:05 -07:00
|
|
|
_elm_widget_item_pre_notify_del(Elm_Widget_Item *item)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
2012-01-09 16:33:51 -08:00
|
|
|
if (!item->del_func) return;
|
|
|
|
item->del_func((void *)item->data, item->widget, item);
|
|
|
|
item->del_func = NULL;
|
2010-09-09 18:54:05 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2010-12-07 11:17:50 -08:00
|
|
|
* @internal
|
|
|
|
*
|
2010-09-09 18:54:05 -07:00
|
|
|
* Set the function to notify when item is being deleted.
|
|
|
|
*
|
|
|
|
* This function will complain if there was a callback set already,
|
|
|
|
* however it will set the new one.
|
|
|
|
*
|
|
|
|
* The callback will be called from elm_widget_item_pre_notify_del()
|
|
|
|
* or elm_widget_item_del() will be called with:
|
|
|
|
* - data: the Elm_Widget_Item::data value.
|
|
|
|
* - obj: the Elm_Widget_Item::widget evas object.
|
|
|
|
* - event_info: the item being deleted.
|
|
|
|
*
|
|
|
|
* @param item a valid #Elm_Widget_Item to be notified
|
|
|
|
* @see elm_widget_item_del_cb_set() convenience macro.
|
2010-12-07 11:17:50 -08:00
|
|
|
* @ingroup Widget
|
2010-09-09 18:54:05 -07:00
|
|
|
*/
|
2010-09-13 00:56:23 -07:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
_elm_widget_item_del_cb_set(Elm_Widget_Item *item,
|
2012-01-09 16:33:51 -08:00
|
|
|
Evas_Smart_Cb func)
|
2010-09-09 18:54:05 -07:00
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
|
2012-01-09 16:33:51 -08:00
|
|
|
if ((item->del_func) && (item->del_func != func))
|
2010-09-09 18:54:05 -07:00
|
|
|
WRN("You're replacing a previously set del_cb %p of item %p with %p",
|
2012-01-09 16:33:51 -08:00
|
|
|
item->del_func, item, func);
|
2010-09-09 18:54:05 -07:00
|
|
|
|
2012-01-09 16:33:51 -08:00
|
|
|
item->del_func = func;
|
2010-09-09 18:54:05 -07:00
|
|
|
}
|
|
|
|
|
2012-07-01 18:38:21 -07:00
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* Retrieves owner widget of this item.
|
|
|
|
*
|
|
|
|
* @param item a valid #Elm_Widget_Item to get data from.
|
|
|
|
* @return owner widget of this item.
|
|
|
|
* @ingroup Widget
|
|
|
|
*/
|
|
|
|
EAPI Evas_Object *
|
|
|
|
_elm_widget_item_widget_get(const Elm_Widget_Item *item)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item, NULL);
|
|
|
|
return item->widget;
|
|
|
|
}
|
|
|
|
|
2010-09-09 18:54:05 -07:00
|
|
|
/**
|
2010-12-07 11:17:50 -08:00
|
|
|
* @internal
|
|
|
|
*
|
2010-09-09 18:54:05 -07:00
|
|
|
* Set user-data in this item.
|
|
|
|
*
|
|
|
|
* User data may be used to identify this item or just store any
|
|
|
|
* application data. It is automatically given as the first parameter
|
|
|
|
* of the deletion notify callback.
|
|
|
|
*
|
|
|
|
* @param item a valid #Elm_Widget_Item to store data in.
|
|
|
|
* @param data user data to store.
|
|
|
|
* @see elm_widget_item_del_cb_set() convenience macro.
|
2010-12-07 11:17:50 -08:00
|
|
|
* @ingroup Widget
|
2010-09-09 18:54:05 -07:00
|
|
|
*/
|
2010-09-13 00:56:23 -07:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
_elm_widget_item_data_set(Elm_Widget_Item *item,
|
|
|
|
const void *data)
|
2010-09-09 18:54:05 -07:00
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
if ((item->data) && (item->data != data))
|
|
|
|
DBG("Replacing item %p data %p with %p", item, item->data, data);
|
|
|
|
item->data = data;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2010-12-07 11:17:50 -08:00
|
|
|
* @internal
|
|
|
|
*
|
2010-09-09 18:54:05 -07:00
|
|
|
* Retrieves user-data of this item.
|
|
|
|
*
|
|
|
|
* @param item a valid #Elm_Widget_Item to get data from.
|
|
|
|
* @see elm_widget_item_data_set()
|
2010-12-07 11:17:50 -08:00
|
|
|
* @ingroup Widget
|
2010-09-09 18:54:05 -07:00
|
|
|
*/
|
2010-09-13 00:56:23 -07:00
|
|
|
EAPI void *
|
2010-09-09 18:54:05 -07:00
|
|
|
_elm_widget_item_data_get(const Elm_Widget_Item *item)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item, NULL);
|
|
|
|
return (void *)item->data;
|
|
|
|
}
|
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
|
|
|
|
2011-11-16 17:58:03 -08:00
|
|
|
EAPI void
|
|
|
|
_elm_widget_item_disabled_set(Elm_Widget_Item *item, Eina_Bool disabled)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
|
|
|
|
if (item->disabled == disabled) return;
|
|
|
|
item->disabled = !!disabled;
|
|
|
|
if (item->disable_func) item->disable_func(item);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
|
|
|
_elm_widget_item_disabled_get(const Elm_Widget_Item *item)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item, EINA_FALSE);
|
|
|
|
return item->disabled;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2012-01-09 17:00:23 -08:00
|
|
|
_elm_widget_item_disable_hook_set(Elm_Widget_Item *item,
|
|
|
|
Elm_Widget_Disable_Cb func)
|
2011-11-16 17:58:03 -08:00
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
item->disable_func = 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
|
|
|
typedef struct _Elm_Widget_Item_Tooltip Elm_Widget_Item_Tooltip;
|
2010-09-13 00:56:23 -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
|
|
|
struct _Elm_Widget_Item_Tooltip
|
|
|
|
{
|
2011-04-02 23:43:17 -07:00
|
|
|
Elm_Widget_Item *item;
|
|
|
|
Elm_Tooltip_Item_Content_Cb func;
|
|
|
|
Evas_Smart_Cb del_cb;
|
|
|
|
const void *data;
|
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
|
|
|
};
|
|
|
|
|
|
|
|
static Evas_Object *
|
2011-04-02 23:43:17 -07:00
|
|
|
_elm_widget_item_tooltip_label_create(void *data,
|
2011-07-26 02:38:23 -07:00
|
|
|
Evas_Object *obj __UNUSED__,
|
|
|
|
Evas_Object *tooltip,
|
2011-04-02 23:43:17 -07:00
|
|
|
void *item __UNUSED__)
|
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
|
|
|
{
|
2011-07-26 02:38:23 -07:00
|
|
|
Evas_Object *label = elm_label_add(tooltip);
|
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 (!label)
|
|
|
|
return NULL;
|
|
|
|
elm_object_style_set(label, "tooltip");
|
2011-06-28 23:41:31 -07:00
|
|
|
elm_object_text_set(label, data);
|
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
|
|
|
return label;
|
|
|
|
}
|
|
|
|
|
2011-10-19 07:17:14 -07:00
|
|
|
static Evas_Object *
|
|
|
|
_elm_widget_item_tooltip_trans_label_create(void *data,
|
|
|
|
Evas_Object *obj __UNUSED__,
|
|
|
|
Evas_Object *tooltip,
|
|
|
|
void *item __UNUSED__)
|
|
|
|
{
|
|
|
|
Evas_Object *label = elm_label_add(tooltip);
|
|
|
|
if (!label)
|
|
|
|
return NULL;
|
|
|
|
elm_object_style_set(label, "tooltip");
|
|
|
|
elm_object_translatable_text_set(label, data);
|
|
|
|
return label;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
static void
|
2011-04-02 23:43:17 -07:00
|
|
|
_elm_widget_item_tooltip_label_del_cb(void *data,
|
|
|
|
Evas_Object *obj __UNUSED__,
|
|
|
|
void *event_info __UNUSED__)
|
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_stringshare_del(data);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2010-12-07 11:17:50 -08:00
|
|
|
* @internal
|
|
|
|
*
|
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 text to be shown in the widget item.
|
|
|
|
*
|
|
|
|
* @param item Target item
|
|
|
|
* @param text The text to set in the content
|
|
|
|
*
|
|
|
|
* Setup the text as tooltip to object. The item can have only one tooltip,
|
|
|
|
* so any previous tooltip data is removed.
|
|
|
|
*
|
2010-12-07 11:17:50 -08:00
|
|
|
* @ingroup Widget
|
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
|
|
|
*/
|
2010-09-13 00:56:23 -07:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
_elm_widget_item_tooltip_text_set(Elm_Widget_Item *item,
|
|
|
|
const char *text)
|
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
|
|
|
{
|
2010-10-21 11:58:40 -07:00
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
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_RETURN(text);
|
|
|
|
|
|
|
|
text = eina_stringshare_add(text);
|
|
|
|
_elm_widget_item_tooltip_content_cb_set
|
2011-04-02 23:43:17 -07:00
|
|
|
(item, _elm_widget_item_tooltip_label_create, text,
|
|
|
|
_elm_widget_item_tooltip_label_del_cb);
|
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
|
|
|
}
|
|
|
|
|
2011-10-19 07:17:14 -07:00
|
|
|
EAPI void
|
|
|
|
_elm_widget_item_tooltip_translatable_text_set(Elm_Widget_Item *item,
|
|
|
|
const char *text)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(text);
|
|
|
|
|
|
|
|
text = eina_stringshare_add(text);
|
|
|
|
_elm_widget_item_tooltip_content_cb_set
|
|
|
|
(item, _elm_widget_item_tooltip_trans_label_create, text,
|
|
|
|
_elm_widget_item_tooltip_label_del_cb);
|
|
|
|
}
|
|
|
|
|
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
|
|
|
static Evas_Object *
|
2011-04-02 23:43:17 -07:00
|
|
|
_elm_widget_item_tooltip_create(void *data,
|
2011-07-26 02:38:23 -07:00
|
|
|
Evas_Object *obj,
|
|
|
|
Evas_Object *tooltip)
|
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_Item_Tooltip *wit = data;
|
2011-07-26 02:38:23 -07:00
|
|
|
return wit->func((void *)wit->data, obj, tooltip, wit->item);
|
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
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-04-02 23:43:17 -07:00
|
|
|
_elm_widget_item_tooltip_del_cb(void *data,
|
|
|
|
Evas_Object *obj,
|
|
|
|
void *event_info __UNUSED__)
|
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_Item_Tooltip *wit = data;
|
|
|
|
if (wit->del_cb) wit->del_cb((void *)wit->data, obj, wit->item);
|
|
|
|
free(wit);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2010-12-07 11:17:50 -08:00
|
|
|
* @internal
|
|
|
|
*
|
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 item
|
|
|
|
*
|
|
|
|
* Setup the tooltip to item. The item 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 item the widget item 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
|
|
|
|
* another callback replaces @func, the tooltip is unset with
|
|
|
|
* elm_widget_item_tooltip_unset() or the owner @a item
|
|
|
|
* dies. This callback receives as the first parameter the
|
|
|
|
* given @a data, and @c event_info is the item.
|
|
|
|
*
|
2010-12-07 11:17:50 -08:00
|
|
|
* @ingroup Widget
|
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
|
|
|
*/
|
2010-09-13 00:56:23 -07:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
_elm_widget_item_tooltip_content_cb_set(Elm_Widget_Item *item,
|
|
|
|
Elm_Tooltip_Item_Content_Cb func,
|
|
|
|
const void *data,
|
|
|
|
Evas_Smart_Cb del_cb)
|
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_Item_Tooltip *wit;
|
|
|
|
|
2010-10-14 07:12:26 -07:00
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_GOTO(item, error_noitem);
|
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 (!func)
|
|
|
|
{
|
|
|
|
_elm_widget_item_tooltip_unset(item);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
wit = ELM_NEW(Elm_Widget_Item_Tooltip);
|
|
|
|
if (!wit) goto error;
|
|
|
|
wit->item = item;
|
|
|
|
wit->func = func;
|
|
|
|
wit->data = data;
|
|
|
|
wit->del_cb = del_cb;
|
|
|
|
|
|
|
|
elm_object_sub_tooltip_content_cb_set
|
2011-04-02 23:43:17 -07:00
|
|
|
(item->view, item->widget, _elm_widget_item_tooltip_create, wit,
|
|
|
|
_elm_widget_item_tooltip_del_cb);
|
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
|
|
|
|
|
|
|
return;
|
|
|
|
|
2011-04-01 04:20:18 -07:00
|
|
|
error_noitem:
|
2010-10-14 07:12:26 -07:00
|
|
|
if (del_cb) del_cb((void *)data, NULL, item);
|
|
|
|
return;
|
2011-04-01 04:20:18 -07:00
|
|
|
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, item->widget, item);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2010-12-07 11:17:50 -08:00
|
|
|
* @internal
|
|
|
|
*
|
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
|
|
|
* Unset tooltip from item
|
|
|
|
*
|
|
|
|
* @param item widget item to remove previously set tooltip.
|
|
|
|
*
|
|
|
|
* Remove tooltip from item. The callback provided as del_cb to
|
|
|
|
* elm_widget_item_tooltip_content_cb_set() will be called to notify
|
|
|
|
* it is not used anymore.
|
|
|
|
*
|
|
|
|
* @see elm_widget_item_tooltip_content_cb_set()
|
|
|
|
*
|
2010-12-07 11:17:50 -08:00
|
|
|
* @ingroup Widget
|
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
|
|
|
*/
|
2010-09-13 00:56:23 -07:00
|
|
|
EAPI 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_widget_item_tooltip_unset(Elm_Widget_Item *item)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
elm_object_tooltip_unset(item->view);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2010-12-07 11:17:50 -08:00
|
|
|
* @internal
|
|
|
|
*
|
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
|
|
|
* Sets a different style for this item tooltip.
|
|
|
|
*
|
|
|
|
* @note before you set a style you should define a tooltip with
|
|
|
|
* elm_widget_item_tooltip_content_cb_set() or
|
|
|
|
* elm_widget_item_tooltip_text_set()
|
|
|
|
*
|
|
|
|
* @param item widget item with tooltip already set.
|
|
|
|
* @param style the theme style to use (default, transparent, ...)
|
|
|
|
*
|
2010-12-07 11:17:50 -08:00
|
|
|
* @ingroup Widget
|
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
|
|
|
*/
|
2010-09-13 00:56:23 -07:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
_elm_widget_item_tooltip_style_set(Elm_Widget_Item *item,
|
|
|
|
const char *style)
|
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_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
elm_object_tooltip_style_set(item->view, style);
|
|
|
|
}
|
|
|
|
|
2011-07-26 02:38:23 -07:00
|
|
|
EAPI Eina_Bool
|
2011-12-05 09:14:07 -08:00
|
|
|
_elm_widget_item_tooltip_window_mode_set(Elm_Widget_Item *item, Eina_Bool disable)
|
2011-07-26 02:38:23 -07:00
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item, EINA_FALSE);
|
2011-12-05 07:25:09 -08:00
|
|
|
return elm_object_tooltip_window_mode_set(item->view, disable);
|
2011-07-26 02:38:23 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
2011-12-05 09:14:07 -08:00
|
|
|
_elm_widget_item_tooltip_window_mode_get(const Elm_Widget_Item *item)
|
2011-07-26 02:38:23 -07:00
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item, EINA_FALSE);
|
2011-12-05 07:25:09 -08:00
|
|
|
return elm_object_tooltip_window_mode_get(item->view);
|
2011-07-26 02:38:23 -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
|
|
|
/**
|
2010-12-07 11:17:50 -08:00
|
|
|
* @internal
|
|
|
|
*
|
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
|
|
|
* Get the style for this item tooltip.
|
|
|
|
*
|
|
|
|
* @param item widget item 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.
|
|
|
|
*
|
2010-12-07 11:17:50 -08:00
|
|
|
* @ingroup Widget
|
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
|
|
|
*/
|
2010-09-13 00:56:23 -07:00
|
|
|
EAPI const char *
|
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_item_tooltip_style_get(const Elm_Widget_Item *item)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item, NULL);
|
|
|
|
return elm_object_tooltip_style_get(item->view);
|
|
|
|
}
|
2010-09-13 00:56:23 -07:00
|
|
|
|
2010-09-17 11:24:10 -07:00
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
_elm_widget_item_cursor_set(Elm_Widget_Item *item,
|
|
|
|
const char *cursor)
|
2010-09-17 11:24:10 -07:00
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
2010-09-25 15:01:19 -07:00
|
|
|
elm_object_sub_cursor_set(item->view, item->widget, cursor);
|
2010-09-17 11:24:10 -07:00
|
|
|
}
|
|
|
|
|
2010-11-04 17:46:54 -07:00
|
|
|
EAPI const char *
|
|
|
|
_elm_widget_item_cursor_get(const Elm_Widget_Item *item)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item, NULL);
|
|
|
|
return elm_object_cursor_get(item->view);
|
|
|
|
}
|
|
|
|
|
2010-09-17 11:24:10 -07:00
|
|
|
EAPI void
|
|
|
|
_elm_widget_item_cursor_unset(Elm_Widget_Item *item)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
elm_object_cursor_unset(item->view);
|
|
|
|
}
|
|
|
|
|
2010-09-25 15:01:19 -07:00
|
|
|
/**
|
2010-12-07 11:17:50 -08:00
|
|
|
* @internal
|
|
|
|
*
|
2010-09-25 15:01:19 -07:00
|
|
|
* Sets a different style for this item cursor.
|
|
|
|
*
|
|
|
|
* @note before you set a style you should define a cursor with
|
|
|
|
* elm_widget_item_cursor_set()
|
|
|
|
*
|
|
|
|
* @param item widget item with cursor already set.
|
|
|
|
* @param style the theme style to use (default, transparent, ...)
|
|
|
|
*
|
2010-12-07 11:17:50 -08:00
|
|
|
* @ingroup Widget
|
2010-09-25 15:01:19 -07:00
|
|
|
*/
|
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
_elm_widget_item_cursor_style_set(Elm_Widget_Item *item,
|
|
|
|
const char *style)
|
2010-09-25 15:01:19 -07:00
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
elm_object_cursor_style_set(item->view, style);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2010-12-07 11:17:50 -08:00
|
|
|
* @internal
|
|
|
|
*
|
2010-09-25 15:01:19 -07:00
|
|
|
* Get the style for this item cursor.
|
|
|
|
*
|
|
|
|
* @param item widget item with cursor already set.
|
|
|
|
* @return style the theme style in use, defaults to "default". If the
|
|
|
|
* object does not have a cursor set, then NULL is returned.
|
|
|
|
*
|
2010-12-07 11:17:50 -08:00
|
|
|
* @ingroup Widget
|
2010-09-25 15:01:19 -07:00
|
|
|
*/
|
|
|
|
EAPI const char *
|
|
|
|
_elm_widget_item_cursor_style_get(const Elm_Widget_Item *item)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item, NULL);
|
|
|
|
return elm_object_cursor_style_get(item->view);
|
|
|
|
}
|
|
|
|
|
2010-09-25 15:03:37 -07:00
|
|
|
/**
|
2010-12-07 11:17:50 -08:00
|
|
|
* @internal
|
|
|
|
*
|
2010-09-25 15:03:37 -07:00
|
|
|
* Set if the cursor set should be searched on the theme or should use
|
|
|
|
* the provided by the engine, only.
|
|
|
|
*
|
|
|
|
* @note before you set if should look on theme you should define a cursor
|
|
|
|
* with elm_object_cursor_set(). By default it will only look for cursors
|
|
|
|
* provided by the engine.
|
|
|
|
*
|
|
|
|
* @param item widget item with cursor already set.
|
|
|
|
* @param engine_only boolean to define it cursors should be looked only
|
|
|
|
* between the provided by the engine or searched on widget's theme as well.
|
|
|
|
*
|
2010-12-07 11:17:50 -08:00
|
|
|
* @ingroup Widget
|
2010-09-25 15:03:37 -07:00
|
|
|
*/
|
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
_elm_widget_item_cursor_engine_only_set(Elm_Widget_Item *item,
|
|
|
|
Eina_Bool engine_only)
|
2010-09-25 15:03:37 -07:00
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
2012-03-05 01:15:04 -08:00
|
|
|
elm_object_cursor_theme_search_enabled_set(item->view, engine_only);
|
2010-09-25 15:03:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2010-12-07 11:17:50 -08:00
|
|
|
* @internal
|
|
|
|
*
|
2010-09-25 15:03:37 -07:00
|
|
|
* Get the cursor engine only usage for this item cursor.
|
|
|
|
*
|
|
|
|
* @param item widget item with cursor already set.
|
|
|
|
* @return engine_only boolean to define it cursors should be looked only
|
|
|
|
* between the provided by the engine or searched on widget's theme as well. If
|
|
|
|
* the object does not have a cursor set, then EINA_FALSE is returned.
|
|
|
|
*
|
2010-12-07 11:17:50 -08:00
|
|
|
* @ingroup Widget
|
2010-09-25 15:03:37 -07:00
|
|
|
*/
|
|
|
|
EAPI Eina_Bool
|
|
|
|
_elm_widget_item_cursor_engine_only_get(const Elm_Widget_Item *item)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item, EINA_FALSE);
|
2012-03-05 01:15:04 -08:00
|
|
|
return elm_object_cursor_theme_search_enabled_get(item->view);
|
2010-09-25 15:03:37 -07:00
|
|
|
}
|
|
|
|
|
2010-09-13 00:56:23 -07:00
|
|
|
// smart object funcs
|
|
|
|
static void
|
2012-05-03 15:40:58 -07:00
|
|
|
_smart_reconfigure(Elm_Widget_Smart_Data *sd)
|
2010-09-13 00:56:23 -07:00
|
|
|
{
|
|
|
|
if (sd->resize_obj)
|
|
|
|
{
|
2011-01-19 03:59:53 -08:00
|
|
|
evas_object_move(sd->resize_obj, sd->x, sd->y);
|
2011-04-01 04:20:18 -07:00
|
|
|
evas_object_resize(sd->resize_obj, sd->w, sd->h);
|
2010-09-13 00:56:23 -07:00
|
|
|
}
|
|
|
|
if (sd->hover_obj)
|
|
|
|
{
|
2011-01-19 03:59:53 -08:00
|
|
|
evas_object_move(sd->hover_obj, sd->x, sd->y);
|
2011-04-01 04:20:18 -07:00
|
|
|
evas_object_resize(sd->hover_obj, sd->w, sd->h);
|
2010-09-13 00:56:23 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-08-03 02:34:00 -07:00
|
|
|
EAPI void
|
2012-04-12 23:28:43 -07:00
|
|
|
_elm_widget_item_part_content_set(Elm_Widget_Item *item,
|
2012-04-12 08:35:12 -07:00
|
|
|
const char *part,
|
|
|
|
Evas_Object *content)
|
2011-08-03 02:34:00 -07:00
|
|
|
{
|
2011-08-03 04:55:24 -07:00
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
2012-04-12 08:35:12 -07:00
|
|
|
if (!item->content_set_func)
|
|
|
|
{
|
|
|
|
ERR("%s does not support elm_object_item_part_content_set() API.",
|
|
|
|
elm_widget_type_get(item->widget));
|
|
|
|
return;
|
|
|
|
}
|
2012-03-06 03:51:42 -08:00
|
|
|
item->content_set_func((Elm_Object_Item *)item, part, content);
|
2011-08-03 02:34:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Evas_Object *
|
2012-04-12 23:28:43 -07:00
|
|
|
_elm_widget_item_part_content_get(const Elm_Widget_Item *item,
|
2011-08-03 22:06:02 -07:00
|
|
|
const char *part)
|
2011-08-03 02:34:00 -07:00
|
|
|
{
|
2011-08-03 04:55:24 -07:00
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item, NULL);
|
2012-04-12 08:35:12 -07:00
|
|
|
if (!item->content_get_func)
|
|
|
|
{
|
|
|
|
ERR("%s does not support elm_object_item_part_content_get() API.",
|
|
|
|
elm_widget_type_get(item->widget));
|
|
|
|
return NULL;
|
|
|
|
}
|
2012-03-06 03:51:42 -08:00
|
|
|
return item->content_get_func((Elm_Object_Item *)item, part);
|
2011-08-03 02:34:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Evas_Object *
|
2012-04-12 23:28:43 -07:00
|
|
|
_elm_widget_item_part_content_unset(Elm_Widget_Item *item,
|
2011-08-03 22:06:02 -07:00
|
|
|
const char *part)
|
2011-08-03 02:34:00 -07:00
|
|
|
{
|
2011-08-03 04:55:24 -07:00
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item, NULL);
|
2012-04-12 08:35:12 -07:00
|
|
|
if (!item->content_unset_func)
|
|
|
|
{
|
|
|
|
ERR("%s does not support elm_object_item_part_content_unset() API.",
|
|
|
|
elm_widget_type_get(item->widget));
|
|
|
|
return NULL;
|
|
|
|
}
|
2012-03-06 03:51:42 -08:00
|
|
|
return item->content_unset_func((Elm_Object_Item *)item, part);
|
2011-08-03 02:34:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2012-04-12 23:28:43 -07:00
|
|
|
_elm_widget_item_part_text_set(Elm_Widget_Item *item,
|
2012-04-12 08:35:12 -07:00
|
|
|
const char *part,
|
|
|
|
const char *label)
|
2011-08-03 02:34:00 -07:00
|
|
|
{
|
2011-08-03 04:55:24 -07:00
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
2012-04-12 08:35:12 -07:00
|
|
|
if (!item->text_set_func)
|
|
|
|
{
|
|
|
|
ERR("%s does not support elm_object_item_part_text_set() API.",
|
|
|
|
elm_widget_type_get(item->widget));
|
|
|
|
return;
|
|
|
|
}
|
2012-03-06 03:51:42 -08:00
|
|
|
item->text_set_func((Elm_Object_Item *)item, part, label);
|
2011-08-03 02:34:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI const char *
|
2012-04-12 23:28:43 -07:00
|
|
|
_elm_widget_item_part_text_get(const Elm_Widget_Item *item,
|
2011-08-03 22:06:02 -07:00
|
|
|
const char *part)
|
2011-08-03 02:34:00 -07:00
|
|
|
{
|
2011-08-03 04:55:24 -07:00
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item, NULL);
|
2012-04-12 08:35:12 -07:00
|
|
|
if (!item->text_get_func)
|
|
|
|
{
|
|
|
|
ERR("%s does not support elm_object_item_part_text_get() API.",
|
|
|
|
elm_widget_type_get(item->widget));
|
|
|
|
return NULL;
|
|
|
|
}
|
2012-03-06 03:51:42 -08:00
|
|
|
return item->text_get_func((Elm_Object_Item *)item, part);
|
2011-08-04 08:15:40 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
_elm_widget_item_content_set_hook_set(Elm_Widget_Item *item,
|
2012-01-09 16:33:51 -08:00
|
|
|
Elm_Widget_Content_Set_Cb func)
|
2011-08-04 08:15:40 -07:00
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
2012-01-09 16:33:51 -08:00
|
|
|
item->content_set_func = func;
|
2011-08-04 08:15:40 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
_elm_widget_item_content_get_hook_set(Elm_Widget_Item *item,
|
2012-01-09 16:33:51 -08:00
|
|
|
Elm_Widget_Content_Get_Cb func)
|
2011-08-04 08:15:40 -07:00
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
2012-01-09 16:33:51 -08:00
|
|
|
item->content_get_func = func;
|
2011-08-04 08:15:40 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
_elm_widget_item_content_unset_hook_set(Elm_Widget_Item *item,
|
2012-01-09 16:33:51 -08:00
|
|
|
Elm_Widget_Content_Unset_Cb func)
|
2011-08-04 08:15:40 -07:00
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
2012-01-09 16:33:51 -08:00
|
|
|
item->content_unset_func = func;
|
2011-08-04 08:15:40 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
_elm_widget_item_text_set_hook_set(Elm_Widget_Item *item,
|
2012-01-09 16:33:51 -08:00
|
|
|
Elm_Widget_Text_Set_Cb func)
|
2011-08-04 08:15:40 -07:00
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
2012-01-09 16:33:51 -08:00
|
|
|
item->text_set_func = func;
|
2011-08-04 08:15:40 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
_elm_widget_item_text_get_hook_set(Elm_Widget_Item *item,
|
2012-01-09 16:33:51 -08:00
|
|
|
Elm_Widget_Text_Get_Cb func)
|
2011-08-04 08:15:40 -07:00
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
2012-01-09 16:33:51 -08:00
|
|
|
item->text_get_func = func;
|
2011-08-03 02:34:00 -07:00
|
|
|
}
|
|
|
|
|
2012-04-12 16:39:36 -07:00
|
|
|
EAPI void
|
|
|
|
_elm_widget_item_signal_emit(Elm_Widget_Item *item,
|
|
|
|
const char *emission,
|
|
|
|
const char *source)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
if (item->signal_emit_func)
|
|
|
|
item->signal_emit_func((Elm_Object_Item *)item, emission, source);
|
|
|
|
}
|
|
|
|
|
2011-09-15 19:10:07 -07:00
|
|
|
EAPI void
|
|
|
|
_elm_widget_item_signal_emit_hook_set(Elm_Widget_Item *item,
|
2012-01-09 16:33:51 -08:00
|
|
|
Elm_Widget_Signal_Emit_Cb func)
|
2011-09-15 19:10:07 -07:00
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
2012-01-09 16:33:51 -08:00
|
|
|
item->signal_emit_func = func;
|
2011-09-15 19:10:07 -07:00
|
|
|
}
|
|
|
|
|
2011-08-23 23:39:29 -07:00
|
|
|
EAPI void
|
|
|
|
_elm_widget_item_access_info_set(Elm_Widget_Item *item, const char *txt)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
if (item->access_info) eina_stringshare_del(item->access_info);
|
|
|
|
if (!txt) item->access_info = NULL;
|
|
|
|
else item->access_info = eina_stringshare_add(txt);
|
|
|
|
}
|
|
|
|
|
2010-09-13 00:56:23 -07:00
|
|
|
static void
|
|
|
|
_smart_add(Evas_Object *obj)
|
|
|
|
{
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
const Evas_Smart_Class *sc;
|
|
|
|
const Evas_Smart *smart;
|
|
|
|
|
|
|
|
EVAS_SMART_DATA_ALLOC(obj, Elm_Widget_Smart_Data);
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70627
2012-05-02 09:57:38 -07:00
|
|
|
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
smart = evas_object_smart_smart_get(obj);
|
|
|
|
sc = evas_smart_class_get(smart);
|
|
|
|
priv->api = (const Elm_Widget_Smart_Class *)sc;
|
|
|
|
priv->obj = obj;
|
|
|
|
priv->x = priv->y = priv->w = priv->h = 0;
|
|
|
|
priv->mirrored_auto_mode = EINA_TRUE; /* will follow system locale
|
|
|
|
* settings */
|
2012-02-22 20:20:30 -08:00
|
|
|
elm_widget_can_focus_set(obj, EINA_TRUE);
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
elm_widget_mirrored_set(obj, elm_config_mirrored_get());
|
2012-05-03 15:41:47 -07:00
|
|
|
|
|
|
|
/* just a helper for inheriting classes */
|
|
|
|
if (priv->resize_obj)
|
|
|
|
{
|
|
|
|
Evas_Object *r_obj = priv->resize_obj;
|
|
|
|
priv->resize_obj = NULL;
|
|
|
|
|
|
|
|
elm_widget_resize_object_set(obj, r_obj);
|
|
|
|
}
|
2010-09-13 00:56:23 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static Evas_Object *
|
2011-04-02 23:43:17 -07:00
|
|
|
_newest_focus_order_get(Evas_Object *obj,
|
|
|
|
unsigned int *newest_focus_order,
|
|
|
|
Eina_Bool can_focus_only)
|
2010-09-13 00:56:23 -07:00
|
|
|
{
|
|
|
|
const Eina_List *l;
|
|
|
|
Evas_Object *child, *ret, *best;
|
2011-03-09 23:22:22 -08:00
|
|
|
|
2010-09-13 00:56:23 -07:00
|
|
|
API_ENTRY return NULL;
|
2011-07-05 00:59:01 -07:00
|
|
|
|
2011-07-27 23:58:29 -07:00
|
|
|
if (!evas_object_visible_get(obj)
|
|
|
|
|| (elm_widget_disabled_get(obj))
|
|
|
|
|| (elm_widget_tree_unfocusable_get(obj)))
|
2011-07-05 00:59:01 -07:00
|
|
|
return NULL;
|
|
|
|
|
2010-09-13 00:56:23 -07:00
|
|
|
best = NULL;
|
|
|
|
if (*newest_focus_order < sd->focus_order)
|
|
|
|
{
|
|
|
|
*newest_focus_order = sd->focus_order;
|
|
|
|
best = obj;
|
|
|
|
}
|
|
|
|
EINA_LIST_FOREACH(sd->subobjs, l, child)
|
|
|
|
{
|
2010-11-11 20:16:24 -08:00
|
|
|
ret = _newest_focus_order_get(child, newest_focus_order, can_focus_only);
|
2010-09-13 00:56:23 -07:00
|
|
|
if (!ret) continue;
|
|
|
|
best = ret;
|
|
|
|
}
|
2011-03-11 03:44:23 -08:00
|
|
|
if (can_focus_only)
|
|
|
|
{
|
|
|
|
if ((!best) || (!elm_widget_can_focus_get(best)))
|
2011-04-01 04:20:18 -07:00
|
|
|
return NULL;
|
2011-03-11 03:44:23 -08:00
|
|
|
}
|
2010-09-13 00:56:23 -07:00
|
|
|
return best;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-04-02 23:43:17 -07:00
|
|
|
_if_focused_revert(Evas_Object *obj,
|
|
|
|
Eina_Bool can_focus_only)
|
2010-09-13 00:56:23 -07:00
|
|
|
{
|
|
|
|
Evas_Object *top;
|
|
|
|
Evas_Object *newest = NULL;
|
|
|
|
unsigned int newest_focus_order = 0;
|
2011-03-09 23:22:22 -08:00
|
|
|
|
2011-12-27 21:51:10 -08:00
|
|
|
INTERNAL_ENTRY;
|
2010-11-11 20:16:24 -08:00
|
|
|
|
2010-09-13 00:56:23 -07:00
|
|
|
if (!sd->focused) return;
|
|
|
|
if (!sd->parent_obj) return;
|
|
|
|
|
|
|
|
top = elm_widget_top_get(sd->parent_obj);
|
|
|
|
if (top)
|
|
|
|
{
|
2010-11-11 20:16:24 -08:00
|
|
|
newest = _newest_focus_order_get(top, &newest_focus_order, can_focus_only);
|
2010-09-13 00:56:23 -07:00
|
|
|
if (newest)
|
|
|
|
{
|
2011-08-03 04:46:23 -07:00
|
|
|
elm_object_focus_set(newest, EINA_FALSE);
|
|
|
|
elm_object_focus_set(newest, EINA_TRUE);
|
2010-09-13 00:56:23 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-05-02 20:02:54 -07:00
|
|
|
#define _R(x) (int)((x + 0.05) * 10.0)
|
|
|
|
|
|
|
|
static double
|
|
|
|
_direction_weight_get(const Evas_Object *obj1, const Evas_Object *obj2, double degree)
|
|
|
|
{
|
|
|
|
Evas_Coord obj_x1, obj_y1, w1, h1, obj_x2, obj_y2, w2, h2;
|
|
|
|
double x1, yy1, x2, yy2, xx1, yyy1, xx2, yyy2;
|
|
|
|
double ax, ay, cx, cy;
|
|
|
|
double weight = -1.0, g = 0.0;
|
|
|
|
|
|
|
|
if (obj1 == obj2) return 0.0;
|
|
|
|
|
|
|
|
degree -= 90.0;
|
|
|
|
while (degree >= 360.0)
|
|
|
|
degree -= 360.0;
|
|
|
|
while (degree < 0.0)
|
|
|
|
degree += 360.0;
|
|
|
|
|
|
|
|
evas_object_geometry_get(obj1, &obj_x1, &obj_y1, &w1, &h1);
|
|
|
|
cx = obj_x1 + (w1 / 2.0);
|
|
|
|
cy = obj_y1 + (h1 / 2.0);
|
|
|
|
evas_object_geometry_get(obj2, &obj_x2, &obj_y2, &w2, &h2);
|
|
|
|
|
|
|
|
if (ELM_RECTS_INTERSECT(obj_x1, obj_y1, w1, h1, obj_x2, obj_y2, w2, h2)) // For overlapping cases.
|
|
|
|
return 0.0;
|
|
|
|
|
|
|
|
/* Change all points to relative one. */
|
|
|
|
x1 = obj_x1 - cx;
|
|
|
|
xx1 = x1 + w1;
|
|
|
|
yy1 = obj_y1 - cy;
|
|
|
|
yyy1 = yy1 + h1;
|
|
|
|
x2 = obj_x2 - cx;
|
|
|
|
xx2 = x2 + w2;
|
|
|
|
yy2 = obj_y2 - cy;
|
|
|
|
yyy2 = yy2 + h2;
|
|
|
|
|
|
|
|
/* Get crossing points (ax, ay) between obj1 and a line extending to the direction of current degree. */
|
|
|
|
if (degree == 0.0)
|
|
|
|
{
|
|
|
|
ax = xx1;
|
|
|
|
ay = 0.0;
|
|
|
|
}
|
|
|
|
else if (degree == 90.0)
|
|
|
|
{
|
|
|
|
ax = 0.0;
|
|
|
|
ay = yyy1;
|
|
|
|
}
|
|
|
|
else if (degree == 180.0)
|
|
|
|
{
|
|
|
|
ax = x1;
|
|
|
|
ay = 0.0;
|
|
|
|
}
|
|
|
|
else if (degree == 270.0)
|
|
|
|
{
|
|
|
|
ax = 0.0;
|
|
|
|
ay = yy1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
g = tan(degree * (M_PI / 180.0));
|
|
|
|
if ((degree > 0.0) && (degree < 90.0))
|
|
|
|
{
|
|
|
|
ay = g * xx1;
|
|
|
|
if (ay <= yyy1) ax = xx1;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ax = yyy1 / g;
|
|
|
|
ay = yyy1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if ((degree > 90.0) && (degree < 180.0))
|
|
|
|
{
|
|
|
|
ay = g * x1;
|
|
|
|
if (ay <= yyy1) ax = x1;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ax = yyy1 / g;
|
|
|
|
ay = yyy1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if ((degree > 180.0) && (degree < 270.0))
|
|
|
|
{
|
|
|
|
ay = g * x1;
|
|
|
|
if (ay >= yy1) ax = x1;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ax = yy1 / g;
|
|
|
|
ay = yy1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ay = g * xx1;
|
|
|
|
if (ay >= yy1) ax = xx1;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ax = yy1 / g;
|
|
|
|
ay = yy1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Filter obj2, if it is not in the specific derection. */
|
|
|
|
int i = 0;
|
|
|
|
double rx[4] = {0.0, 0.0, 0.0, 0.0}, ry[4] = {0.0, 0.0, 0.0, 0.0};
|
|
|
|
double t1, t2, u1, v1, u2, v2;
|
|
|
|
|
|
|
|
if ((degree == 45.0) || (degree == 225.0) || (degree == 135.0) || (degree == 315.0))
|
|
|
|
{
|
|
|
|
u1 = 1.0;
|
|
|
|
v1 = 0.0;
|
|
|
|
u2 = 0.0;
|
|
|
|
v2 = 1.0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
double g2 = tan((degree + 45.0) * (M_PI / 180.0));
|
|
|
|
u1 = (-1.0 * g2);
|
|
|
|
u2 = (1.0 / g2);
|
|
|
|
v1 = v2 = 1.0;
|
|
|
|
}
|
|
|
|
t1 = (u1 * ax) + (v1 * ay);
|
|
|
|
t2 = (u2 * ax) + (v2 * ay);
|
|
|
|
|
|
|
|
if ((_R(t1 * ((u1 * x2) + (v1 * yy2))) > 0) && (_R(t2 * ((u2 * x2) + (v2 * yy2))) > 0))
|
|
|
|
{
|
|
|
|
rx[i] = x2;
|
|
|
|
ry[i++] = yy2;
|
|
|
|
}
|
|
|
|
if ((_R(t1 * ((u1 * x2) + (v1 * yyy2))) > 0) && (_R(t2 * ((u2 * x2) + (v2 * yyy2))) > 0))
|
|
|
|
{
|
|
|
|
rx[i] = x2;
|
|
|
|
ry[i++] = yyy2;
|
|
|
|
}
|
|
|
|
if ((_R(t1 * ((u1 * xx2) + (v1 * yy2))) > 0) && (_R(t2 * ((u2 * xx2) + (v2 * yy2))) > 0))
|
|
|
|
{
|
|
|
|
rx[i] = xx2;
|
|
|
|
ry[i++] = yy2;
|
|
|
|
}
|
|
|
|
if ((_R(t1 * ((u1 * xx2) + (v1 * yyy2))) > 0) && (_R(t2 * ((u2 * xx2) + (v2 * yyy2))) > 0))
|
|
|
|
{
|
|
|
|
rx[i] = xx2;
|
|
|
|
ry[i++] = yyy2;
|
|
|
|
}
|
|
|
|
if (i == 0)
|
|
|
|
{
|
|
|
|
if (degree == 0.0)
|
|
|
|
{
|
|
|
|
if ((_R(xx2) < 0) || (_R(yy2) > 0) || (_R(yyy2) < 0)) return 0.0;
|
|
|
|
}
|
|
|
|
else if (degree == 90.0)
|
|
|
|
{
|
|
|
|
if ((_R(yyy2) < 0) || (_R(x2) > 0) || (_R(xx2) < 0)) return 0.0;
|
|
|
|
}
|
|
|
|
else if (degree == 180.0)
|
|
|
|
{
|
|
|
|
if ((_R(x2) > 0) || (_R(yy2) > 0) || (_R(yyy2) < 0)) return 0.0;
|
|
|
|
}
|
|
|
|
else if (degree == 270.0)
|
|
|
|
{
|
|
|
|
if ((_R(yy2) > 0) || (_R(x2) > 0) || (_R(xx2) < 0)) return 0.0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if ((_R(g * x2) >= _R(yy2)) && (_R((g * x2)) <= _R(yyy2)))
|
|
|
|
{
|
|
|
|
if (!((_R(ax * x2) > 0) && (_R(ay * (g * x2)) > 0))) return 0.0;
|
|
|
|
}
|
|
|
|
else if ((_R(g * xx2) >= _R(yy2)) && (_R((g * xx2)) <= _R(yyy2)))
|
|
|
|
{
|
|
|
|
if (!((_R(ax * xx2) > 0) && (_R(ay * (g * xx2)) > 0))) return 0.0;
|
|
|
|
}
|
|
|
|
else if ((_R((1.0 / g) * yy2) >= _R(xx2)) && (_R((1.0 / g) * yy2) <= _R(xx2)))
|
|
|
|
{
|
|
|
|
if (!((_R(ax * ((1.0 / g) * yy2)) > 0) && (_R(ay * yy2) > 0))) return 0.0;
|
|
|
|
}
|
|
|
|
else if ((_R((1.0 / g) * yyy2) >= _R(xx2)) && (_R((1.0 / g) * yyy2) <= _R(xx2)))
|
|
|
|
{
|
|
|
|
if (!((_R(ax * ((1.0 / g) * yyy2)) > 0) && (_R(ay * yyy2) > 0))) return 0.0;
|
|
|
|
}
|
|
|
|
else return 0.0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Calculate the weight for obj2. */
|
|
|
|
if (degree == 0.0)
|
|
|
|
{
|
|
|
|
if (_R(xx1) > _R(x2)) weight = -1.0;
|
|
|
|
else if ((_R(yy2) >= _R(yy1)) && (_R(yyy2) <= _R(yyy1))) weight = (x2 - xx1) * (x2 - xx1);
|
|
|
|
else if (_R(yy2) > 0) weight = ((x2 - xx1) * (x2 - xx1)) + (yy2 * yy2);
|
|
|
|
else if (_R(yyy2) < 0) weight = ((x2 - xx1) * (x2 - xx1)) + (yyy2 * yyy2);
|
|
|
|
else weight = (x2 - xx1) * (x2 - xx1);
|
|
|
|
}
|
|
|
|
else if (degree == 90.0)
|
|
|
|
{
|
|
|
|
if (_R(yyy1) > _R(yy2)) weight = -1.0;
|
|
|
|
else if ((_R(x2) >= _R(x1)) && (_R(xx2) <= _R(xx1))) weight = (yy2 - yyy1) * (yy2 - yyy1);
|
|
|
|
else if (_R(x2) > 0) weight = (x2 * x2) + ((yy2 - yyy1) * (yy2 - yyy1));
|
|
|
|
else if (_R(xx2) < 0) weight = (xx2 * xx2) + ((yy2 - yyy1) * (yy2 - yyy1));
|
|
|
|
else weight = (yy2 - yyy1) * (yy2 - yyy1);
|
|
|
|
}
|
|
|
|
else if (degree == 180.0)
|
|
|
|
{
|
|
|
|
if (_R(x1) < _R(xx2)) weight = -1.0;
|
|
|
|
else if ((_R(yy2) >= _R(yy1)) && (_R(yyy2) <= _R(yyy1))) weight = (x1 - xx2) * (x1 - xx2);
|
|
|
|
else if (_R(yy2) > 0) weight = ((x1 - xx2) * (x1 - xx2)) + (yy2 * yy2);
|
|
|
|
else if (_R(yyy2) < 0) weight = ((x1 - xx2) * (x1 - xx2)) + (yyy2 * yyy2);
|
|
|
|
else weight = (x1 - xx2) * (x1 - xx2);
|
|
|
|
}
|
|
|
|
else if (degree == 270.0)
|
|
|
|
{
|
|
|
|
if (_R(yy1) < _R(yyy2)) weight = -1.0;
|
|
|
|
else if ((_R(x2) >= _R(x1)) && (_R(xx2) <= _R(xx1))) weight = (yy1 - yyy2) * (yy1 - yyy2);
|
|
|
|
else if (_R(x2) > 0) weight = (x2 * x2) + ((yy1 - yyy2) * (yy1 - yyy2));
|
|
|
|
else if (_R(xx2) < 0) weight = (xx2 * xx2) + ((yy1 - yyy2) * (yy1 - yyy2));
|
|
|
|
else weight = (yy1 - yyy2) * (yy1 - yyy2);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
int j = 0, k = 0;
|
|
|
|
double sx[4] = {0.0, 0.0, 0.0, 0.0}, sy[4] = {0.0, 0.0, 0.0, 0.0};
|
|
|
|
double t_weight[4] = {-1.0 , -1.0, -1.0, -1.0};
|
|
|
|
if ((_R(g * x2) >= _R(yy2)) && (_R(g * x2) <= _R(yyy2)))
|
|
|
|
{
|
|
|
|
sx[j] = x2;
|
|
|
|
sy[j] = g * x2;
|
|
|
|
t_weight[j++] = ((ax - x2) * (ax - x2)) + ((ay - (g * x2)) * (ay - (g * x2)));
|
|
|
|
}
|
|
|
|
if ((_R(g * xx2) >= _R(yy2)) && (_R(g * xx2) <= _R(yyy2)))
|
|
|
|
{
|
|
|
|
sx[j] = xx2;
|
|
|
|
sy[j] = g * xx2;
|
|
|
|
t_weight[j++] = ((ax - xx2) * (ax - xx2)) + ((ay - (g * xx2)) * (ay - (g * xx2)));
|
|
|
|
}
|
|
|
|
if ((_R((1.0 / g) * yy2) >= _R(x2)) && (_R((1.0 / g) * yy2) <= _R(xx2)))
|
|
|
|
{
|
|
|
|
sx[j] = (1.0 / g) * yy2;
|
|
|
|
sy[j] = yy2;
|
|
|
|
t_weight[j++] = ((ax - ((1.0 / g) * yy2)) * (ax - ((1.0 / g) * yy2))) + ((ay - yy2) * (ay - yy2));
|
|
|
|
}
|
|
|
|
if ((_R((1.0 / g) * yyy2) >= _R(x2)) && (_R((1.0 / g) * yyy2) <= _R(xx2)))
|
|
|
|
{
|
|
|
|
sx[j] = (1.0 / g) * yyy2;
|
|
|
|
sy[j] = yyy2;
|
|
|
|
t_weight[j++] = ((ax - ((1.0 / g) * yyy2)) * (ax - ((1.0 / g) * yyy2))) + ((ay - yyy2) * (ay - yyy2));
|
|
|
|
}
|
|
|
|
|
|
|
|
if((j > 2) || ((j == 2) && ((_R(sx[0]) != _R(sx[1])) || (_R(sy[0]) != _R(sy[1])))))
|
|
|
|
{
|
|
|
|
for (; k < j; k++)
|
|
|
|
{
|
|
|
|
if (_R(t_weight[k]) == 0) return -1.0;
|
|
|
|
if ((1 / weight) < (1 / t_weight[k])) weight = t_weight[k];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
for (; k < i; k++)
|
|
|
|
{
|
|
|
|
double ccx, ccy, t1_weight, x_diff, y_diff;
|
|
|
|
ccx = ((1.0 / g) * rx[k] + ry[k]) / (g + (1.0 / g));
|
|
|
|
ccy = g * ccx;
|
|
|
|
x_diff = rx[k] - ccx;
|
|
|
|
if (x_diff < 0) x_diff *= -1.0;
|
|
|
|
y_diff = ry[k] - ccy;
|
|
|
|
if (y_diff < 0) y_diff *= -1.0;
|
|
|
|
t1_weight = (((ax - ccx) * (ax - ccx)) + ((ay - ccy) * (ay - ccy))) +
|
|
|
|
((x_diff * x_diff * x_diff) + (y_diff * y_diff * y_diff));
|
|
|
|
if ((_R(t1_weight) != 0) && ((1 / weight) < (1 / t1_weight)))
|
|
|
|
weight = t1_weight;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* Return the current object's weight. */
|
|
|
|
if (weight == -1.0) return 0.0;
|
|
|
|
if (_R(weight) == 0) return -1.0;
|
|
|
|
return (1.0 / weight);
|
|
|
|
}
|
|
|
|
|
2010-09-13 00:56:23 -07:00
|
|
|
static void
|
|
|
|
_smart_del(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Evas_Object *sobj;
|
2011-10-19 07:17:14 -07:00
|
|
|
Elm_Translate_String_Data *ts;
|
2012-06-19 11:20:38 -07:00
|
|
|
Elm_Event_Cb_Data *ecb;
|
2010-09-13 00:56:23 -07:00
|
|
|
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
ELM_WIDGET_DATA_GET(obj, sd);
|
2010-11-29 05:56:30 -08:00
|
|
|
|
2010-09-13 00:56:23 -07:00
|
|
|
if (sd->hover_obj)
|
|
|
|
{
|
2012-05-03 15:41:09 -07:00
|
|
|
/* detach it from us */
|
|
|
|
evas_object_event_callback_del_full
|
|
|
|
(sd->hover_obj, EVAS_CALLBACK_DEL, _sub_obj_del, sd);
|
2011-10-25 05:30:39 -07:00
|
|
|
sd->hover_obj = NULL;
|
2010-09-13 00:56:23 -07:00
|
|
|
}
|
2012-05-03 15:41:09 -07:00
|
|
|
|
|
|
|
while (sd->subobjs)
|
2010-09-13 00:56:23 -07:00
|
|
|
{
|
2012-05-03 15:41:09 -07:00
|
|
|
sobj = eina_list_data_get(sd->subobjs);
|
|
|
|
|
|
|
|
/* let the objects clean-up themselves and get rid of this list */
|
|
|
|
if (_elm_legacy_is(sd->obj))
|
|
|
|
{
|
|
|
|
evas_object_smart_callback_call(obj, "sub-object-del", sobj);
|
|
|
|
sd->subobjs = eina_list_remove_list(sd->subobjs, sd->subobjs);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (!elm_widget_sub_object_del(obj, sobj))
|
|
|
|
{
|
|
|
|
ERR("failed to remove sub object %p from %p\n", sobj, obj);
|
|
|
|
sd->subobjs = eina_list_remove_list
|
|
|
|
(sd->subobjs, sd->subobjs);
|
|
|
|
}
|
|
|
|
}
|
2011-04-01 04:20:18 -07:00
|
|
|
evas_object_del(sobj);
|
2010-09-13 00:56:23 -07:00
|
|
|
}
|
2011-10-25 05:30:39 -07:00
|
|
|
sd->tooltips = eina_list_free(sd->tooltips); /* should be empty anyway */
|
|
|
|
sd->cursors = eina_list_free(sd->cursors); /* should be empty anyway */
|
2011-10-19 07:17:14 -07:00
|
|
|
EINA_LIST_FREE(sd->translate_strings, ts)
|
|
|
|
{
|
|
|
|
eina_stringshare_del(ts->id);
|
|
|
|
eina_stringshare_del(ts->domain);
|
|
|
|
eina_stringshare_del(ts->string);
|
|
|
|
free(ts);
|
|
|
|
}
|
2012-06-19 11:20:38 -07:00
|
|
|
|
|
|
|
EINA_LIST_FREE(sd->event_cb, ecb)
|
|
|
|
free(ecb);
|
|
|
|
|
2010-09-13 00:56:23 -07:00
|
|
|
if (sd->style) eina_stringshare_del(sd->style);
|
|
|
|
if (sd->theme) elm_theme_free(sd->theme);
|
2010-11-11 20:16:24 -08:00
|
|
|
_if_focused_revert(obj, EINA_TRUE);
|
2011-08-19 04:47:30 -07:00
|
|
|
if (sd->access_info) eina_stringshare_del(sd->access_info);
|
2010-09-13 00:56:23 -07:00
|
|
|
free(sd);
|
2011-10-25 05:30:39 -07:00
|
|
|
evas_object_smart_data_set(obj, NULL);
|
2010-09-13 00:56:23 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-04-02 23:43:17 -07:00
|
|
|
_smart_move(Evas_Object *obj,
|
|
|
|
Evas_Coord x,
|
|
|
|
Evas_Coord y)
|
2010-09-13 00:56:23 -07:00
|
|
|
{
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
ELM_WIDGET_DATA_GET(obj, sd);
|
|
|
|
|
2010-09-13 00:56:23 -07:00
|
|
|
sd->x = x;
|
|
|
|
sd->y = y;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
2010-09-13 00:56:23 -07:00
|
|
|
_smart_reconfigure(sd);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-04-02 23:43:17 -07:00
|
|
|
_smart_resize(Evas_Object *obj,
|
|
|
|
Evas_Coord w,
|
|
|
|
Evas_Coord h)
|
2010-09-13 00:56:23 -07:00
|
|
|
{
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
ELM_WIDGET_DATA_GET(obj, sd);
|
|
|
|
|
2010-09-13 00:56:23 -07:00
|
|
|
sd->w = w;
|
|
|
|
sd->h = h;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
2010-09-13 00:56:23 -07:00
|
|
|
_smart_reconfigure(sd);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_smart_show(Evas_Object *obj)
|
|
|
|
{
|
2010-10-06 20:53:53 -07:00
|
|
|
Eina_List *list;
|
2010-09-13 00:56:23 -07:00
|
|
|
Evas_Object *o;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
2010-10-06 20:53:53 -07:00
|
|
|
if ((list = evas_object_smart_members_get(obj)))
|
|
|
|
{
|
|
|
|
EINA_LIST_FREE(list, o)
|
|
|
|
{
|
|
|
|
if (evas_object_data_get(o, "_elm_leaveme")) continue;
|
|
|
|
evas_object_show(o);
|
|
|
|
}
|
|
|
|
}
|
2010-09-13 00:56:23 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_smart_hide(Evas_Object *obj)
|
|
|
|
{
|
2010-10-06 20:53:53 -07:00
|
|
|
Eina_List *list;
|
2010-09-13 00:56:23 -07:00
|
|
|
Evas_Object *o;
|
2011-05-25 17:39:12 -07:00
|
|
|
|
2011-05-24 00:49:37 -07:00
|
|
|
list = evas_object_smart_members_get(obj);
|
2010-10-14 07:10:33 -07:00
|
|
|
EINA_LIST_FREE(list, o)
|
2010-09-13 00:56:23 -07:00
|
|
|
{
|
2010-10-14 07:10:33 -07:00
|
|
|
if (evas_object_data_get(o, "_elm_leaveme")) continue;
|
|
|
|
evas_object_hide(o);
|
2010-09-13 00:56:23 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-04-02 23:43:17 -07:00
|
|
|
_smart_color_set(Evas_Object *obj,
|
|
|
|
int r,
|
|
|
|
int g,
|
|
|
|
int b,
|
|
|
|
int a)
|
2010-09-13 00:56:23 -07:00
|
|
|
{
|
2010-10-07 07:49:37 -07:00
|
|
|
Eina_List *list;
|
2010-09-13 00:56:23 -07:00
|
|
|
Evas_Object *o;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
2010-10-06 20:53:53 -07:00
|
|
|
if ((list = evas_object_smart_members_get(obj)))
|
2010-09-13 00:56:23 -07:00
|
|
|
{
|
2010-10-06 20:53:53 -07:00
|
|
|
EINA_LIST_FREE(list, o)
|
|
|
|
{
|
|
|
|
if (evas_object_data_get(o, "_elm_leaveme")) continue;
|
|
|
|
evas_object_color_set(o, r, g, b, a);
|
|
|
|
}
|
2010-09-13 00:56:23 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-04-02 23:43:17 -07:00
|
|
|
_smart_clip_set(Evas_Object *obj,
|
|
|
|
Evas_Object *clip)
|
2010-09-13 00:56:23 -07:00
|
|
|
{
|
2010-10-07 07:49:37 -07:00
|
|
|
Eina_List *list;
|
2010-09-13 00:56:23 -07:00
|
|
|
Evas_Object *o;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
2010-10-06 20:53:53 -07:00
|
|
|
if ((list = evas_object_smart_members_get(obj)))
|
2010-09-13 00:56:23 -07:00
|
|
|
{
|
2010-10-06 20:53:53 -07:00
|
|
|
EINA_LIST_FREE(list, o)
|
|
|
|
{
|
|
|
|
if (evas_object_data_get(o, "_elm_leaveme")) continue;
|
|
|
|
evas_object_clip_set(o, clip);
|
|
|
|
}
|
2010-09-13 00:56:23 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_smart_clip_unset(Evas_Object *obj)
|
|
|
|
{
|
2010-10-07 07:49:37 -07:00
|
|
|
Eina_List *list;
|
2010-09-13 00:56:23 -07:00
|
|
|
Evas_Object *o;
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
|
2010-10-06 20:53:53 -07:00
|
|
|
if ((list = evas_object_smart_members_get(obj)))
|
2010-09-13 00:56:23 -07:00
|
|
|
{
|
2010-10-06 20:53:53 -07:00
|
|
|
EINA_LIST_FREE(list, o)
|
|
|
|
{
|
|
|
|
if (evas_object_data_get(o, "_elm_leaveme")) continue;
|
|
|
|
evas_object_clip_unset(o);
|
|
|
|
}
|
2010-09-13 00:56:23 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
_smart_calculate(Evas_Object *obj __UNUSED__)
|
2010-09-13 00:56:23 -07:00
|
|
|
{
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
/* a NO-OP, on the base */
|
2010-09-13 00:56:23 -07:00
|
|
|
}
|
|
|
|
|
2012-03-28 03:03:45 -07:00
|
|
|
static void
|
|
|
|
_smart_member_add(Evas_Object *obj, Evas_Object *child)
|
|
|
|
{
|
|
|
|
int r, g, b, a;
|
|
|
|
|
|
|
|
if (evas_object_data_get(child, "_elm_leaveme")) return;
|
|
|
|
|
|
|
|
evas_object_color_get(obj, &r, &g, &b, &a);
|
|
|
|
evas_object_color_set(child, r, g, b, a);
|
|
|
|
|
|
|
|
evas_object_clip_set(child, evas_object_clip_get(obj));
|
|
|
|
|
|
|
|
if (evas_object_visible_get(obj))
|
|
|
|
evas_object_show(child);
|
|
|
|
else
|
|
|
|
evas_object_hide(child);
|
|
|
|
}
|
|
|
|
|
2012-04-03 07:29:38 -07:00
|
|
|
static void
|
|
|
|
_smart_member_del(Evas_Object *obj __UNUSED__, Evas_Object *child)
|
|
|
|
{
|
|
|
|
if (evas_object_data_get(child, "_elm_leaveme")) return;
|
|
|
|
evas_object_clip_unset(child);
|
|
|
|
}
|
|
|
|
|
2010-09-28 12:35:12 -07:00
|
|
|
/* happy debug functions */
|
2010-10-01 12:03:23 -07:00
|
|
|
#ifdef ELM_DEBUG
|
2010-09-28 12:35:12 -07:00
|
|
|
static void
|
2011-04-02 23:43:17 -07:00
|
|
|
_sub_obj_tree_dump(const Evas_Object *obj,
|
|
|
|
int lvl)
|
2010-09-28 12:35:12 -07:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2011-04-02 23:43:17 -07:00
|
|
|
for (i = 0; i < lvl * 3; i++)
|
2010-09-28 12:35:12 -07:00
|
|
|
putchar(' ');
|
|
|
|
|
2011-03-22 15:12:33 -07:00
|
|
|
if (_elm_widget_is(obj))
|
2010-09-28 12:35:12 -07:00
|
|
|
{
|
|
|
|
Eina_List *l;
|
2011-12-27 21:51:10 -08:00
|
|
|
INTERNAL_ENTRY;
|
2011-04-02 23:43:17 -07:00
|
|
|
printf("+ %s(%p)\n",
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
elm_widget_type_get(obj),
|
2011-04-02 23:43:17 -07:00
|
|
|
obj);
|
2010-09-28 12:35:12 -07:00
|
|
|
if (sd->resize_obj)
|
|
|
|
_sub_obj_tree_dump(sd->resize_obj, lvl + 1);
|
2011-03-22 15:12:33 -07:00
|
|
|
EINA_LIST_FOREACH(sd->subobjs, l, obj)
|
2010-09-28 12:35:12 -07:00
|
|
|
{
|
2011-03-22 15:12:33 -07:00
|
|
|
if (obj != sd->resize_obj)
|
|
|
|
_sub_obj_tree_dump(obj, lvl + 1);
|
2010-09-28 12:35:12 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
2011-03-22 15:12:33 -07:00
|
|
|
printf("+ %s(%p)\n", evas_object_type_get(obj), obj);
|
2010-09-28 12:35:12 -07:00
|
|
|
}
|
2010-10-04 11:37:48 -07:00
|
|
|
|
|
|
|
static void
|
2011-04-02 23:43:17 -07:00
|
|
|
_sub_obj_tree_dot_dump(const Evas_Object *obj,
|
|
|
|
FILE *output)
|
2010-10-04 11:37:48 -07:00
|
|
|
{
|
|
|
|
if (!_elm_widget_is(obj))
|
|
|
|
return;
|
2011-12-27 21:51:10 -08:00
|
|
|
INTERNAL_ENTRY;
|
2010-10-04 11:37:48 -07:00
|
|
|
|
2011-04-02 23:43:17 -07:00
|
|
|
Eina_Bool visible = evas_object_visible_get(obj);
|
2010-10-04 11:37:48 -07:00
|
|
|
Eina_Bool disabled = elm_widget_disabled_get(obj);
|
|
|
|
Eina_Bool focused = elm_widget_focus_get(obj);
|
2010-11-11 20:16:24 -08:00
|
|
|
Eina_Bool can_focus = elm_widget_can_focus_get(obj);
|
2010-10-04 11:37:48 -07:00
|
|
|
|
|
|
|
if (sd->parent_obj)
|
|
|
|
{
|
|
|
|
fprintf(output, "\"%p\" -- \"%p\" [ color=black", sd->parent_obj, obj);
|
|
|
|
|
|
|
|
if (focused)
|
|
|
|
fprintf(output, ", style=bold");
|
|
|
|
|
|
|
|
if (!visible)
|
|
|
|
fprintf(output, ", color=gray28");
|
|
|
|
|
|
|
|
fprintf(output, " ];\n");
|
|
|
|
}
|
|
|
|
|
2010-10-08 13:16:48 -07:00
|
|
|
fprintf(output, "\"%p\" [ label = \"{%p|%s|%s|visible: %d|"
|
[Elm] Creating base smart class, to be extended
properly by real widgets.
I'm also creating a *compatibility* class on top of it, which extends
the old (unique) one to its old components, so that everything goes
unnoticed for the widgets.
Next, we'll be accessing class functions for widget hooks *on the base
class*, which will be proxied back to the instance ones.
Then, one by one the widgets will be translated to a proper
hierarchical smart class parentage, making extensibility and reuse
much better.
Last, but not least, since we'll be moving these hooks to the class,
where (almost) everything is a function, let's adapt to the future --
take away the "_func" suffix from them.
NB: there is ONE hook and associated data which was kept on the base,
for now: "show_region" stuff. I did that because scrollers need that
in order to work, right now. Keep in mind, though, the scrollers will
be reworked, so that fields ought to be changed soon, too.
SVN revision: 70704
2012-05-03 15:41:04 -07:00
|
|
|
"disabled: %d|focused: %d/%d|focus order:%d}\"",
|
|
|
|
obj, obj, elm_widget_type_get(obj),
|
2010-12-16 10:38:38 -08:00
|
|
|
evas_object_name_get(obj), visible, disabled, focused, can_focus,
|
|
|
|
sd->focus_order);
|
2010-10-04 11:37:48 -07:00
|
|
|
|
|
|
|
if (focused)
|
2011-04-01 04:20:18 -07:00
|
|
|
fprintf(output, ", style=bold");
|
2010-10-04 11:37:48 -07:00
|
|
|
|
|
|
|
if (!visible)
|
2011-04-01 04:20:18 -07:00
|
|
|
fprintf(output, ", fontcolor=gray28");
|
2010-10-04 11:37:48 -07:00
|
|
|
|
2010-10-22 14:41:22 -07:00
|
|
|
if ((disabled) || (!visible))
|
2011-04-01 04:20:18 -07:00
|
|
|
fprintf(output, ", color=gray");
|
2010-10-04 11:37:48 -07:00
|
|
|
|
|
|
|
fprintf(output, " ];\n");
|
|
|
|
|
|
|
|
Eina_List *l;
|
|
|
|
Evas_Object *o;
|
|
|
|
EINA_LIST_FOREACH(sd->subobjs, l, o)
|
2011-04-02 23:43:17 -07:00
|
|
|
_sub_obj_tree_dot_dump(o, output);
|
2010-10-04 11:37:48 -07:00
|
|
|
}
|
2010-10-01 12:03:23 -07:00
|
|
|
#endif
|
2010-09-28 12:35:12 -07:00
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_widget_tree_dump(const Evas_Object *top)
|
|
|
|
{
|
2010-10-01 12:03:23 -07:00
|
|
|
#ifdef ELM_DEBUG
|
2012-02-20 04:23:46 -08:00
|
|
|
if (!_elm_widget_is(top))
|
|
|
|
return;
|
2010-09-28 12:35:12 -07:00
|
|
|
_sub_obj_tree_dump(top, 0);
|
2010-10-19 11:24:27 -07:00
|
|
|
#else
|
|
|
|
return;
|
|
|
|
(void)top;
|
2010-10-01 12:03:23 -07:00
|
|
|
#endif
|
2010-09-28 12:35:12 -07:00
|
|
|
}
|
2010-10-04 11:37:48 -07:00
|
|
|
|
|
|
|
EAPI void
|
2011-04-02 23:43:17 -07:00
|
|
|
elm_widget_tree_dot_dump(const Evas_Object *top,
|
|
|
|
FILE *output)
|
2010-10-04 11:37:48 -07:00
|
|
|
{
|
|
|
|
#ifdef ELM_DEBUG
|
2010-10-28 06:38:55 -07:00
|
|
|
if (!_elm_widget_is(top))
|
|
|
|
return;
|
2011-04-02 23:43:17 -07:00
|
|
|
fprintf(output, "graph " " { node [shape=record];\n");
|
2010-10-04 11:37:48 -07:00
|
|
|
_sub_obj_tree_dot_dump(top, output);
|
|
|
|
fprintf(output, "}\n");
|
2010-10-19 11:24:27 -07:00
|
|
|
#else
|
|
|
|
return;
|
|
|
|
(void)top;
|
|
|
|
(void)output;
|
2010-10-04 11:37:48 -07:00
|
|
|
#endif
|
2011-04-14 05:47:16 -07:00
|
|
|
}
|