2013-04-25 22:13:00 -07:00
# ifdef HAVE_CONFIG_H
# include "elementary_config.h"
# endif
2008-09-29 23:58:56 -07:00
# include <Elementary.h>
2013-04-25 22:13:00 -07:00
2008-09-29 23:58:56 -07:00
# 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
2012-11-25 22:32:53 -08:00
EAPI Eo_Op ELM_WIDGET_BASE_ID = EO_NOOP ;
# define MY_CLASS ELM_OBJ_WIDGET_CLASS
2013-11-07 03:44:22 -08:00
# define MY_CLASS_NAME "Elm_Widget"
# define MY_CLASS_NAME_LEGACY "elm_widget"
2012-11-25 22:32:53 -08:00
2013-10-13 22:40:35 -07:00
# define ELM_WIDGET_DATA_GET(o, wd) \
2014-01-06 06:58:18 -08:00
Elm_Widget_Smart_Data * wd = eo_data_scope_get ( o , MY_CLASS )
2012-12-05 02:59:36 -08:00
2012-11-25 22:32:53 -08:00
# define API_ENTRY \
ELM_WIDGET_DATA_GET ( obj , sd ) ; \
2011-12-18 23:06:22 -08:00
if ( ( ! sd ) | | ( ! _elm_widget_is ( obj ) ) )
2012-11-25 22:32:53 -08:00
# define INTERNAL_ENTRY \
ELM_WIDGET_DATA_GET ( obj , sd ) ; \
if ( ! sd ) return
2013-01-28 03:13:18 -08:00
# define ELM_WIDGET_FOCUS_GET(obj) \
2013-09-09 22:01:50 -07:00
( ( _elm_access_auto_highlight_get ( ) ) ? ( elm_widget_highlight_get ( obj ) ) : \
( elm_widget_focus_get ( obj ) ) )
2011-04-02 23:43:17 -07:00
2014-01-23 00:24:19 -08:00
const char SIG_WIDGET_FOCUSED [ ] = " focused " ;
const char SIG_WIDGET_UNFOCUSED [ ] = " unfocused " ;
2014-01-23 02:30:34 -08:00
const char SIG_WIDGET_LANG_CHANGED [ ] = " language,changed " ;
2014-02-07 21:05:06 -08:00
const char SIG_WIDGET_ACCESS_CHANGED [ ] = " access,changed " ;
2014-01-23 00:24:19 -08:00
2012-08-30 09:47:10 -07:00
typedef struct _Elm_Event_Cb_Data Elm_Event_Cb_Data ;
2013-09-17 15:46:46 -07:00
typedef struct _Elm_Label_Data Elm_Label_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
} ;
2013-09-17 15:46:46 -07:00
struct _Elm_Label_Data
{
const char * part ;
const char * text ;
} ;
2011-10-19 07:17:14 -07:00
struct _Elm_Translate_String_Data
{
2013-07-16 23:05:40 -07:00
EINA_INLIST ;
2013-04-01 04:50:25 -07:00
Eina_Stringshare * id ;
Eina_Stringshare * domain ;
Eina_Stringshare * string ;
2013-04-23 00:49:49 -07:00
Eina_Bool preset : 1 ;
2011-10-19 07:17:14 -07:00
} ;
2008-10-06 18:23:49 -07:00
/* local subsystem globals */
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 )
{
2012-11-25 22:32:53 -08:00
return eo_isa ( obj , MY_CLASS ) ;
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
}
2012-07-04 14:41:01 -07:00
static inline Eina_Bool
_elm_scrollable_is ( const Evas_Object * obj )
{
2012-09-04 19:37:47 -07:00
INTERNAL_ENTRY EINA_FALSE ;
2012-11-25 22:32:53 -08:00
return
eo_isa ( obj , ELM_SCROLLABLE_INTERFACE ) ;
2012-07-04 14:41:01 -07:00
}
2012-08-30 09:47:10 -07:00
/**
* @ internal
2013-01-26 01:55:18 -08:00
*
2012-08-30 09:47:10 -07:00
* 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 .
*/
static void
_elm_widget_mirrored_reload ( Evas_Object * obj )
{
API_ENTRY return ;
Eina_Bool mirrored = elm_config_mirrored_get ( ) ;
if ( elm_widget_mirrored_automatic_get ( obj ) & & ( sd - > is_mirrored ! = mirrored ) )
{
sd - > is_mirrored = mirrored ;
}
}
2012-11-25 22:32:53 -08:00
static void
_elm_widget_on_focus_region ( Eo * obj , void * _pd EINA_UNUSED , va_list * list )
[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-11-25 22:32:53 -08:00
va_arg ( * list , Evas_Coord * ) ;
va_arg ( * list , Evas_Coord * ) ;
va_arg ( * list , Evas_Coord * ) ;
va_arg ( * list , Evas_Coord * ) ;
Eina_Bool * ret = va_arg ( * list , Eina_Bool * ) ;
if ( ret ) * ret = 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
2012-11-25 22:32:53 -08:00
WRN ( " The %s widget does not implement the \" on_focus_region \" function. " ,
eo_class_name_get ( eo_class_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
}
2012-08-30 09:47:10 -07:00
static void
_parents_focus ( Evas_Object * obj )
{
for ( ; obj ; obj = elm_widget_parent_get ( obj ) )
{
INTERNAL_ENTRY ;
if ( sd - > focused ) return ;
sd - > focused = 1 ;
}
}
static void
_parents_unfocus ( Evas_Object * obj )
{
for ( ; obj ; obj = elm_widget_parent_get ( obj ) )
{
INTERNAL_ENTRY ;
if ( ! sd - > focused ) return ;
sd - > focused = 0 ;
}
}
static void
2014-01-06 06:30:02 -08:00
_on_sub_obj_hide ( void * data EINA_UNUSED ,
Evas * e EINA_UNUSED ,
2012-08-30 09:47:10 -07:00
Evas_Object * obj ,
2014-01-06 06:30:02 -08:00
void * event_info EINA_UNUSED )
2012-08-30 09:47:10 -07:00
{
elm_widget_focus_hide_handle ( obj ) ;
}
static void
_on_sub_obj_del ( void * data ,
2014-01-06 06:30:02 -08:00
Evas * e EINA_UNUSED ,
2012-08-30 09:47:10 -07:00
Evas_Object * obj ,
2014-01-06 06:30:02 -08:00
void * event_info EINA_UNUSED )
2012-08-30 09:47:10 -07:00
{
2013-04-24 04:41:37 -07:00
ELM_WIDGET_DATA_GET ( data , sd ) ;
2012-08-30 09:47:10 -07:00
if ( _elm_widget_is ( obj ) )
{
if ( elm_widget_focus_get ( obj ) ) _parents_unfocus ( sd - > obj ) ;
}
if ( obj = = sd - > resize_obj )
{
/* already dels sub object */
2013-10-16 08:54:54 -07:00
elm_widget_resize_object_set ( sd - > obj , NULL , EINA_TRUE ) ;
2012-08-30 09:47:10 -07:00
return ;
}
else if ( obj = = sd - > hover_obj )
{
sd - > hover_obj = NULL ;
return ;
}
else
{
if ( ! elm_widget_sub_object_del ( sd - > obj , obj ) )
ERR ( " failed to remove sub object %p from %p \n " , obj , sd - > 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
static const Evas_Smart_Cb_Description _smart_callbacks [ ] =
{
/* FIXME: complete later */
{ NULL , NULL }
} ;
2013-07-11 01:47:25 -07:00
static void
_obj_mouse_down ( void * data ,
2014-01-06 06:30:02 -08:00
Evas * e EINA_UNUSED ,
Evas_Object * obj EINA_UNUSED ,
2013-07-11 01:47:25 -07:00
void * event_info )
{
ELM_WIDGET_DATA_GET ( data , sd ) ;
Evas_Event_Mouse_Down * ev = event_info ;
if ( ! ( ev - > event_flags & EVAS_EVENT_FLAG_ON_HOLD ) )
sd - > still_in = EINA_TRUE ;
}
static void
_obj_mouse_move ( void * data ,
2014-01-06 06:30:02 -08:00
Evas * e EINA_UNUSED ,
2013-07-11 01:47:25 -07:00
Evas_Object * obj ,
void * event_info )
{
ELM_WIDGET_DATA_GET ( data , sd ) ;
Evas_Event_Mouse_Move * ev = event_info ;
if ( sd - > still_in )
{
if ( ev - > event_flags & EVAS_EVENT_FLAG_ON_HOLD )
sd - > still_in = EINA_FALSE ;
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 ) ) )
sd - > still_in = EINA_FALSE ;
}
}
}
static void
_obj_mouse_up ( void * data ,
2014-01-06 06:30:02 -08:00
Evas * e EINA_UNUSED ,
2013-07-11 01:47:25 -07:00
Evas_Object * obj ,
2014-01-06 06:30:02 -08:00
void * event_info EINA_UNUSED )
2013-07-11 01:47:25 -07:00
{
ELM_WIDGET_DATA_GET ( data , sd ) ;
if ( sd - > still_in )
elm_widget_focus_mouse_up_handle ( obj ) ;
sd - > still_in = 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
static void
2012-11-25 22:32:53 -08:00
_elm_widget_smart_add ( Eo * obj , void * _pd , va_list * list EINA_UNUSED )
[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:15 -07:00
2012-11-25 22:32:53 -08:00
Elm_Widget_Smart_Data * priv = _pd ;
[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-30 09:47:10 -07:00
priv - > obj = obj ;
priv - > mirrored_auto_mode = EINA_TRUE ; /* will follow system locale
* settings */
elm_widget_can_focus_set ( obj , EINA_TRUE ) ;
2013-12-31 03:33:51 -08:00
priv - > is_mirrored = elm_config_mirrored_get ( ) ;
2012-05-03 15:41:09 -07:00
2013-07-11 01:47:25 -07:00
evas_object_event_callback_add ( obj , EVAS_CALLBACK_MOUSE_DOWN ,
_obj_mouse_down , obj ) ;
evas_object_event_callback_add ( obj , EVAS_CALLBACK_MOUSE_MOVE ,
_obj_mouse_move , obj ) ;
evas_object_event_callback_add ( obj , EVAS_CALLBACK_MOUSE_UP ,
_obj_mouse_up , obj ) ;
2012-08-30 09:47:10 -07:00
/* just a helper for inheriting classes */
if ( priv - > resize_obj )
{
Evas_Object * r_obj = priv - > resize_obj ;
priv - > resize_obj = 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
2013-10-16 08:54:54 -07:00
elm_widget_resize_object_set ( obj , r_obj , EINA_TRUE ) ;
2012-08-30 09:47:10 -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
}
2010-09-28 20:59:28 -07:00
static void
2012-08-30 09:47:10 -07:00
_if_focused_revert ( Evas_Object * obj ,
Eina_Bool can_focus_only )
2010-09-28 20:59:28 -07:00
{
2012-08-30 09:47:10 -07:00
Evas_Object * top ;
Evas_Object * newest = NULL ;
unsigned int newest_focus_order = 0 ;
INTERNAL_ENTRY ;
if ( ! sd - > focused ) return ;
if ( ! sd - > parent_obj ) return ;
top = elm_widget_top_get ( sd - > parent_obj ) ;
if ( top )
2010-09-28 20:59:28 -07:00
{
2013-03-07 23:23:34 -08:00
newest = elm_widget_newest_focus_order_get
( top , & newest_focus_order , can_focus_only ) ;
2012-08-30 09:47:10 -07:00
if ( newest )
{
elm_object_focus_set ( newest , EINA_FALSE ) ;
elm_object_focus_set ( newest , EINA_TRUE ) ;
}
2010-09-28 20:59:28 -07:00
}
}
2008-10-07 23:38:20 -07:00
static void
2013-04-24 04:41:37 -07:00
_elm_widget_smart_del ( Eo * obj , void * _pd , va_list * list EINA_UNUSED )
2008-10-07 23:38:20 -07:00
{
2012-08-30 09:47:10 -07:00
Evas_Object * sobj ;
Elm_Translate_String_Data * ts ;
Elm_Event_Cb_Data * ecb ;
2009-10-17 23:03:03 -07:00
2012-11-25 22:32:53 -08:00
Elm_Widget_Smart_Data * sd = _pd ;
2012-08-30 09:47:10 -07:00
if ( sd - > hover_obj )
2012-05-22 00:05:07 -07:00
{
2012-08-30 09:47:10 -07:00
/* detach it from us */
evas_object_event_callback_del_full
2013-04-24 04:41:37 -07:00
( sd - > hover_obj , EVAS_CALLBACK_DEL , _on_sub_obj_del , obj ) ;
2012-08-30 09:47:10 -07:00
sd - > hover_obj = NULL ;
2012-05-22 00:05:07 -07:00
}
2012-08-30 09:47:10 -07:00
while ( sd - > subobjs )
2012-05-22 00:05:07 -07:00
{
2012-08-30 09:47:10 -07:00
sobj = eina_list_data_get ( sd - > subobjs ) ;
/* let the objects clean-up themselves and get rid of this list */
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 ) ;
}
evas_object_del ( sobj ) ;
2012-05-22 00:05:07 -07:00
}
2012-08-30 09:47:10 -07:00
sd - > tooltips = eina_list_free ( sd - > tooltips ) ; /* should be empty anyway */
sd - > cursors = eina_list_free ( sd - > cursors ) ; /* should be empty anyway */
2013-07-16 23:05:40 -07:00
while ( sd - > translate_strings )
2012-05-03 15:41:09 -07:00
{
2013-07-16 23:05:40 -07:00
ts = EINA_INLIST_CONTAINER_GET ( sd - > translate_strings ,
Elm_Translate_String_Data ) ;
2012-08-30 09:47:10 -07:00
eina_stringshare_del ( ts - > id ) ;
eina_stringshare_del ( ts - > domain ) ;
eina_stringshare_del ( ts - > string ) ;
2013-07-16 23:05:40 -07:00
sd - > translate_strings = eina_inlist_remove ( sd - > translate_strings ,
sd - > translate_strings ) ;
2012-08-30 09:47:10 -07:00
free ( ts ) ;
2012-05-03 15:41:09 -07:00
}
2008-10-07 23:38:20 -07:00
2013-03-08 20:23:42 -08:00
EINA_LIST_FREE ( sd - > event_cb , ecb )
2014-01-21 23:24:25 -08:00
free ( ecb ) ;
2012-08-30 09:47:10 -07:00
2014-01-21 17:12:44 -08:00
eina_stringshare_del ( sd - > style ) ;
2012-08-30 09:47:10 -07:00
if ( sd - > theme ) elm_theme_free ( sd - > theme ) ;
_if_focused_revert ( obj , EINA_TRUE ) ;
2014-01-21 23:24:25 -08:00
elm_widget_focus_custom_chain_unset ( obj ) ;
2014-01-21 17:12:44 -08:00
eina_stringshare_del ( sd - > access_info ) ;
2012-08-30 09:47:10 -07:00
evas_object_smart_data_set ( obj , NULL ) ;
}
static void
_smart_reconfigure ( Elm_Widget_Smart_Data * sd )
2011-03-19 08:13:14 -07:00
{
2012-08-30 09:47:10 -07:00
if ( sd - > resize_obj )
{
evas_object_move ( sd - > resize_obj , sd - > x , sd - > y ) ;
evas_object_resize ( sd - > resize_obj , sd - > w , sd - > h ) ;
}
if ( sd - > hover_obj )
{
evas_object_move ( sd - > hover_obj , sd - > x , sd - > y ) ;
evas_object_resize ( sd - > hover_obj , sd - > w , sd - > h ) ;
}
}
static void
2012-11-25 22:32:53 -08:00
_elm_widget_smart_move ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
2012-08-30 09:47:10 -07:00
{
2012-11-25 22:32:53 -08:00
Evas_Coord x = va_arg ( * list , Evas_Coord ) ;
Evas_Coord y = va_arg ( * list , Evas_Coord ) ;
Elm_Widget_Smart_Data * sd = _pd ;
2012-08-30 09:47:10 -07:00
sd - > x = x ;
sd - > y = y ;
_smart_reconfigure ( sd ) ;
}
static void
2012-11-25 22:32:53 -08:00
_elm_widget_smart_resize ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
2012-08-30 09:47:10 -07:00
{
2012-11-25 22:32:53 -08:00
Evas_Coord w = va_arg ( * list , Evas_Coord ) ;
Evas_Coord h = va_arg ( * list , Evas_Coord ) ;
Elm_Widget_Smart_Data * sd = _pd ;
2012-08-30 09:47:10 -07:00
sd - > w = w ;
sd - > h = h ;
_smart_reconfigure ( sd ) ;
}
static void
2012-11-25 22:32:53 -08:00
_elm_widget_smart_show ( Eo * obj , void * _pd EINA_UNUSED , va_list * params_list EINA_UNUSED )
2012-08-30 09:47:10 -07:00
{
2013-09-05 01:16:42 -07:00
Eina_Iterator * it ;
2012-08-30 09:47:10 -07:00
Evas_Object * o ;
2013-09-05 01:16:42 -07:00
it = evas_object_smart_iterator_new ( obj ) ;
EINA_ITERATOR_FOREACH ( it , o )
2012-08-30 09:47:10 -07:00
{
2013-09-05 01:16:42 -07:00
if ( evas_object_data_get ( o , " _elm_leaveme " ) ) continue ;
evas_object_show ( o ) ;
2012-08-30 09:47:10 -07:00
}
2013-09-05 01:16:42 -07:00
eina_iterator_free ( it ) ;
2012-08-30 09:47:10 -07:00
}
static void
2012-11-25 22:32:53 -08:00
_elm_widget_smart_hide ( Eo * obj , void * _pd EINA_UNUSED , va_list * params_list EINA_UNUSED )
2012-08-30 09:47:10 -07:00
{
2013-09-05 01:16:42 -07:00
Eina_Iterator * it ;
2012-08-30 09:47:10 -07:00
Evas_Object * o ;
2013-09-05 01:16:42 -07:00
it = evas_object_smart_iterator_new ( obj ) ;
EINA_ITERATOR_FOREACH ( it , o )
2012-08-30 09:47:10 -07:00
{
if ( evas_object_data_get ( o , " _elm_leaveme " ) ) continue ;
evas_object_hide ( o ) ;
}
2013-09-05 01:16:42 -07:00
eina_iterator_free ( it ) ;
2012-08-30 09:47:10 -07:00
}
static void
2012-11-25 22:32:53 -08:00
_elm_widget_smart_color_set ( Eo * obj , void * _pd EINA_UNUSED , va_list * params_list )
2012-08-30 09:47:10 -07:00
{
2012-11-25 22:32:53 -08:00
int r = va_arg ( * params_list , int ) ;
int g = va_arg ( * params_list , int ) ;
int b = va_arg ( * params_list , int ) ;
int a = va_arg ( * params_list , int ) ;
2013-09-05 01:16:42 -07:00
Eina_Iterator * it ;
2012-08-30 09:47:10 -07:00
Evas_Object * o ;
2013-09-05 01:16:42 -07:00
it = evas_object_smart_iterator_new ( obj ) ;
EINA_ITERATOR_FOREACH ( it , o )
2012-08-30 09:47:10 -07:00
{
2013-09-05 01:16:42 -07:00
if ( evas_object_data_get ( o , " _elm_leaveme " ) ) continue ;
evas_object_color_set ( o , r , g , b , a ) ;
2012-08-30 09:47:10 -07:00
}
2013-09-05 01:16:42 -07:00
eina_iterator_free ( it ) ;
2012-08-30 09:47:10 -07:00
}
static void
2012-11-25 22:32:53 -08:00
_elm_widget_smart_clip_set ( Eo * obj , void * _pd EINA_UNUSED , va_list * params_list )
2012-08-30 09:47:10 -07:00
{
2012-11-25 22:32:53 -08:00
Evas_Object * clip = va_arg ( * params_list , Evas_Object * ) ;
2013-09-05 01:16:42 -07:00
Eina_Iterator * it ;
2012-08-30 09:47:10 -07:00
Evas_Object * o ;
2013-09-05 01:16:42 -07:00
it = evas_object_smart_iterator_new ( obj ) ;
EINA_ITERATOR_FOREACH ( it , o )
2012-08-30 09:47:10 -07:00
{
2013-09-05 01:16:42 -07:00
if ( evas_object_data_get ( o , " _elm_leaveme " ) ) continue ;
evas_object_clip_set ( o , clip ) ;
2012-08-30 09:47:10 -07:00
}
2013-09-05 01:16:42 -07:00
eina_iterator_free ( it ) ;
2012-08-30 09:47:10 -07:00
}
static void
2012-11-25 22:32:53 -08:00
_elm_widget_smart_clip_unset ( Eo * obj , void * _pd EINA_UNUSED , va_list * params_list EINA_UNUSED )
2012-08-30 09:47:10 -07:00
{
2013-09-05 01:16:42 -07:00
Eina_Iterator * it ;
2012-08-30 09:47:10 -07:00
Evas_Object * o ;
2013-09-05 01:16:42 -07:00
it = evas_object_smart_iterator_new ( obj ) ;
EINA_ITERATOR_FOREACH ( it , o )
2012-08-30 09:47:10 -07:00
{
2013-09-05 01:16:42 -07:00
if ( evas_object_data_get ( o , " _elm_leaveme " ) ) continue ;
evas_object_clip_unset ( o ) ;
2012-08-30 09:47:10 -07:00
}
2013-09-05 01:16:42 -07:00
eina_iterator_free ( it ) ;
2012-08-30 09:47:10 -07:00
}
static void
2012-11-25 22:32:53 -08:00
_elm_widget_smart_calculate ( Eo * obj EINA_UNUSED , void * _pd EINA_UNUSED , va_list * params_list EINA_UNUSED )
2012-08-30 09:47:10 -07:00
{
/* a NO-OP, on the base */
}
static void
2012-11-25 22:32:53 -08:00
_elm_widget_smart_member_add ( Eo * obj , void * _pd EINA_UNUSED , va_list * params_list )
2012-08-30 09:47:10 -07:00
{
int r , g , b , a ;
2012-11-25 22:32:53 -08:00
Evas_Object * child = va_arg ( * params_list , Evas_Object * ) ;
2013-03-18 09:07:38 -07:00
eo_do_super ( obj , MY_CLASS , evas_obj_smart_member_add ( child ) ) ;
2012-08-30 09:47:10 -07:00
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 ) ;
}
static void
2012-11-25 22:32:53 -08:00
_elm_widget_smart_member_del ( Eo * obj EINA_UNUSED , void * _pd EINA_UNUSED , va_list * list )
2012-08-30 09:47:10 -07:00
{
2012-11-25 22:32:53 -08:00
Evas_Object * child = va_arg ( * list , Evas_Object * ) ;
if ( ! evas_object_data_get ( child , " _elm_leaveme " ) )
evas_object_clip_unset ( child ) ;
2013-03-18 09:07:38 -07:00
eo_do_super ( obj , MY_CLASS , evas_obj_smart_member_del ( child ) ) ;
2012-08-30 09:47:10 -07:00
}
// internal funcs
2012-11-20 01:59:21 -08:00
/**
* @ internal
2013-01-26 01:55:18 -08:00
*
2012-11-20 01:59:21 -08:00
* Check if the widget has its own focus next function .
*
* @ param obj The widget .
* @ return focus next function is implemented / unimplemented .
* ( @ c EINA_TRUE = implemented / @ c EINA_FALSE = unimplemented . )
*/
2012-08-30 09:47:10 -07:00
static inline Eina_Bool
_elm_widget_focus_chain_manager_is ( const Evas_Object * obj )
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) EINA_FALSE ;
2012-08-30 09:47:10 -07:00
2012-11-25 22:32:53 -08:00
Eina_Bool manager_is = EINA_FALSE ;
eo_do ( ( Eo * ) obj , elm_wdg_focus_next_manager_is ( & manager_is ) ) ;
return manager_is ;
2012-08-30 09:47:10 -07:00
}
static inline Eina_Bool
_elm_widget_focus_direction_manager_is ( const Evas_Object * obj )
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) EINA_FALSE ;
2012-08-30 09:47:10 -07:00
2012-11-25 22:32:53 -08:00
Eina_Bool manager_is = EINA_FALSE ;
eo_do ( ( Eo * ) obj , elm_wdg_focus_direction_manager_is ( & manager_is ) ) ;
return manager_is ;
2011-03-19 08:13:14 -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 ,
2012-08-30 09:47:10 -07:00
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-11-25 22:32:53 -08:00
ELM_WIDGET_DATA_GET ( sd - > parent_obj , sd2 ) ;
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 ,
2012-08-30 09:47:10 -07:00
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-11-25 22:32:53 -08:00
ELM_WIDGET_DATA_GET ( sd - > parent_obj , sd2 ) ;
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
2012-08-30 09:47:10 -07:00
_propagate_event ( void * data ,
2014-01-06 06:30:02 -08:00
Evas * e EINA_UNUSED ,
2011-04-02 23:43:17 -07:00
Evas_Object * obj ,
2012-08-30 09:47:10 -07:00
void * event_info )
2010-09-20 19:02:24 -07:00
{
2011-12-27 21:51:10 -08:00
INTERNAL_ENTRY ;
2013-02-16 19:53:02 -08:00
Evas_Callback_Type type = ( Evas_Callback_Type ) ( uintptr_t ) 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 :
2013-11-29 22:28:44 -08:00
{
Evas_Event_Key_Down * ev = event_info ;
event_flags = & ( ev - > event_flags ) ;
}
break ;
2011-04-02 23:43:17 -07:00
2011-04-01 04:20:18 -07:00
case EVAS_CALLBACK_KEY_UP :
2013-11-29 22:28:44 -08:00
{
Evas_Event_Key_Up * ev = event_info ;
event_flags = & ( ev - > event_flags ) ;
}
break ;
2011-04-02 23:43:17 -07:00
2011-04-01 04:20:18 -07:00
case EVAS_CALLBACK_MOUSE_WHEEL :
2013-11-29 22:28:44 -08:00
{
Evas_Event_Mouse_Wheel * ev = event_info ;
event_flags = & ( ev - > event_flags ) ;
}
break ;
2011-04-02 23:43:17 -07:00
2011-04-01 04:20:18 -07:00
default :
2013-11-29 22:28:44 -08: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
}
2013-07-05 22:41:00 -07:00
EAPI void
elm_widget_focus_region_show ( const Evas_Object * obj )
{
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( ( Eo * ) obj , elm_wdg_focus_region_show ( ) ) ;
}
2012-10-17 03:09:52 -07:00
/**
2013-01-26 01:55:18 -08:00
* @ internal
*
2012-10-17 03:09:52 -07:00
* If elm_widget_focus_region_get ( ) returns EINA_FALSE , this function will
* ignore region show action .
*/
2010-09-13 00:56:23 -07:00
static void
2013-07-05 22:41:00 -07:00
_elm_widget_focus_region_show ( Eo * obj , void * _pd EINA_UNUSED , va_list * list EINA_UNUSED )
2010-09-13 00:56:23 -07:00
{
2012-08-30 09:47:10 -07:00
Evas_Coord x , y , w , h , ox , oy ;
Evas_Object * o ;
2010-09-21 11:55:32 -07:00
2012-08-30 09:47:10 -07:00
o = elm_widget_parent_get ( obj ) ;
if ( ! o ) return ;
2010-10-22 11:29:51 -07:00
2012-10-17 03:09:52 -07:00
if ( ! elm_widget_focus_region_get ( obj , & x , & y , & w , & h ) )
return ;
2010-10-22 11:29:51 -07:00
evas_object_geometry_get ( obj , & ox , & oy , NULL , NULL ) ;
2012-08-30 09:47:16 -07:00
2010-10-22 11:29:51 -07:00
while ( o )
{
Evas_Coord px , py ;
2012-08-30 09:47:16 -07:00
2013-11-07 05:34:57 -08:00
if ( _elm_scrollable_is ( o ) & & ! elm_widget_disabled_get ( o ) )
2010-10-22 11:29:51 -07:00
{
2012-11-25 22:32:53 -08:00
eo_do ( o , elm_scrollable_interface_content_region_show ( x , y , w , h ) ) ;
2012-08-30 09:47:16 -07:00
2012-10-17 03:09:52 -07:00
if ( ! elm_widget_focus_region_get ( o , & x , & y , & w , & h ) )
{
o = elm_widget_parent_get ( o ) ;
continue ;
}
2010-10-22 11:29:51 -07:00
}
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 ) ;
}
}
2014-02-05 02:17:41 -08:00
EAPI Eina_Bool
elm_widget_focus_highlight_style_set ( Evas_Object * obj , const char * style )
{
ELM_WIDGET_CHECK ( obj ) EINA_FALSE ;
Eina_Bool ret = EINA_FALSE ;
eo_do ( obj , elm_wdg_focus_highlight_style_set ( style , & ret ) ) ;
return ret ;
}
static void
_elm_widget_focus_highlight_style_set ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
const char * style = va_arg ( * list , const char * ) ;
Eina_Bool * ret = va_arg ( * list , Eina_Bool * ) ;
if ( ret ) * ret = EINA_FALSE ;
Elm_Widget_Smart_Data * sd = _pd ;
if ( eina_stringshare_replace ( & sd - > focus_highlight_style , style ) )
{
if ( ret ) * ret = EINA_TRUE ;
return ;
}
}
EAPI const char *
elm_widget_focus_highlight_style_get ( const Evas_Object * obj )
{
ELM_WIDGET_CHECK ( obj ) NULL ;
const char * ret = NULL ;
eo_do ( ( Eo * ) obj , elm_wdg_focus_highlight_style_get ( & ret ) ) ;
return ret ;
}
static void
_elm_widget_focus_highlight_style_get ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
const char * * ret = va_arg ( * list , const char * * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
* ret = sd - > focus_highlight_style ;
}
2012-08-30 09:47:10 -07:00
static void
_parent_focus ( Evas_Object * obj )
{
API_ENTRY return ;
if ( sd - > focused ) return ;
Evas_Object * o = elm_widget_parent_get ( obj ) ;
sd - > focus_order_on_calc = EINA_TRUE ;
if ( o ) _parent_focus ( o ) ;
if ( ! sd - > focus_order_on_calc )
return ; /* we don't want to override it if by means of any of the
callbacks below one gets to calculate our order
first . */
focus_order + + ;
sd - > focus_order = focus_order ;
2012-11-25 22:32:53 -08:00
2012-08-30 09:47:10 -07:00
if ( sd - > top_win_focused )
{
sd - > focused = EINA_TRUE ;
2012-11-25 22:32:53 -08:00
eo_do ( obj , elm_wdg_on_focus ( NULL ) ) ;
2013-07-05 22:41:00 -07:00
elm_widget_focus_region_show ( obj ) ;
2012-08-30 09:47:10 -07:00
}
sd - > focus_order_on_calc = EINA_FALSE ;
if ( _elm_config - > access_mode = = ELM_ACCESS_MODE_ON )
_elm_access_highlight_set ( obj ) ;
}
static void
_elm_object_focus_chain_del_cb ( void * data ,
2014-01-06 06:30:02 -08:00
Evas * e EINA_UNUSED ,
2012-08-30 09:47:10 -07:00
Evas_Object * obj ,
2014-01-06 06:30:02 -08:00
void * event_info EINA_UNUSED )
2012-08-30 09:47:10 -07:00
{
2013-04-24 04:41:37 -07:00
ELM_WIDGET_DATA_GET ( data , sd ) ;
2012-08-30 09:47:10 -07:00
sd - > focus_chain = eina_list_remove ( sd - > focus_chain , obj ) ;
}
2012-07-18 14:03:28 -07:00
EAPI void
elm_widget_parent_set ( Evas_Object * obj ,
Evas_Object * parent )
{
2012-11-25 22:32:53 -08:00
eo_do ( obj , elm_wdg_parent_set ( parent ) ) ;
2012-07-18 14:03:28 -07:00
}
2012-12-06 09:49:19 -08:00
static void
_elm_widget_parent_set ( Eo * obj EINA_UNUSED , void * _pd EINA_UNUSED , va_list * list )
{
va_arg ( * list , Evas_Object * ) ;
}
2010-09-13 00:56:23 -07:00
EAPI Eina_Bool
elm_widget_api_check ( int ver )
{
if ( ver ! = ELM_INTERNAL_API_VERSION )
{
2013-12-25 20:03:55 -08:00
CRI ( " Elementary widget api versions do not match " ) ;
2010-09-13 00:56:23 -07:00
return EINA_FALSE ;
}
return EINA_TRUE ;
}
2012-07-03 05:09:34 -07:00
EAPI Eina_Bool
2012-08-30 09:47:10 -07:00
elm_widget_access ( Evas_Object * obj ,
Eina_Bool is_access )
2012-07-03 05:09:34 -07:00
{
const Eina_List * l ;
Evas_Object * child ;
Eina_Bool ret = EINA_TRUE ;
API_ENTRY return EINA_FALSE ;
2012-10-01 00:36:27 -07:00
EINA_LIST_FOREACH ( sd - > subobjs , l , child )
2012-07-03 05:09:34 -07:00
ret & = elm_widget_access ( child , is_access ) ;
2012-11-25 22:32:53 -08:00
eo_do ( obj , elm_wdg_access ( is_access ) ) ;
2014-02-07 21:05:06 -08:00
evas_object_smart_callback_call ( obj , SIG_WIDGET_ACCESS_CHANGED , NULL ) ;
2012-07-03 05:09:34 -07:00
return ret ;
}
2012-12-06 09:49:19 -08:00
static void
_elm_widget_access ( Eo * obj EINA_UNUSED , void * _pd EINA_UNUSED , va_list * list )
{
va_arg ( * list , int ) ;
}
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-09-28 07:08:00 -07:00
EINA_LIST_FOREACH ( sd - > subobjs , l , child )
if ( _elm_widget_is ( child ) ) ret & = elm_widget_theme ( child ) ;
2012-03-06 11:06:02 -08:00
if ( sd - > hover_obj ) ret & = elm_widget_theme ( sd - > hover_obj ) ;
2012-09-28 07:08:00 -07:00
EINA_LIST_FOREACH ( sd - > tooltips , l , tt )
2012-08-30 09:47:10 -07:00
elm_tooltip_theme ( tt ) ;
2012-09-28 07:08:00 -07:00
EINA_LIST_FOREACH ( sd - > cursors , l , cur )
2012-08-30 09:47:10 -07:00
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-11-25 22:32:53 -08:00
Eina_Bool ret2 ;
2014-01-21 00:44:45 -08:00
eo_do ( obj , elm_wdg_theme_apply ( & ret2 ) ) ;
2012-11-25 22:32:53 -08:00
ret & = ret2 ;
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 ,
2012-08-30 09:47:10 -07:00
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 ;
2012-10-01 00:36:27 -07:00
EINA_LIST_FOREACH ( sd - > subobjs , l , child )
2011-04-02 23:43:17 -07:00
elm_widget_theme_specific ( child , th , force ) ;
2008-11-14 22:09:04 -08:00
if ( sd - > hover_obj ) elm_widget_theme ( sd - > hover_obj ) ;
2012-10-01 00:36:27 -07:00
EINA_LIST_FOREACH ( sd - > tooltips , l , tt )
2012-08-30 09:47:10 -07:00
elm_tooltip_theme ( tt ) ;
2012-10-01 00:36:27 -07:00
EINA_LIST_FOREACH ( sd - > cursors , l , cur )
2012-08-30 09:47:10 -07:00
elm_cursor_theme ( cur ) ;
2014-01-21 00:44:45 -08:00
eo_do ( obj , elm_wdg_theme_apply ( NULL ) ) ;
2008-11-14 22:09:04 -08:00
}
2012-12-06 09:49:19 -08:00
static void
_elm_widget_theme_func ( Eo * obj , void * _pd EINA_UNUSED , va_list * list )
{
Eina_Bool * ret = va_arg ( * list , Eina_Bool * ) ;
_elm_widget_mirrored_reload ( obj ) ;
elm_widget_disabled_set ( obj , elm_widget_disabled_get ( obj ) ) ;
if ( ret ) * ret = EINA_TRUE ;
}
2011-02-03 07:52:49 -08:00
/**
2013-01-26 01:55:18 -08:00
* @ internal
*
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 )
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) EINA_FALSE ;
Eina_Bool ret = EINA_FALSE ;
eo_do ( ( Eo * ) obj , elm_wdg_mirrored_get ( & ret ) ) ;
return ret ;
}
static void
_elm_widget_mirrored_get ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
Eina_Bool * ret = va_arg ( * list , Eina_Bool * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
* ret = sd - > is_mirrored ;
2011-02-03 07:52:49 -08:00
}
/**
2013-01-26 01:55:18 -08:00
* @ internal
*
2011-02-03 07:52:49 -08:00
* 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
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_mirrored_set ( mirrored ) ) ;
}
static void
_elm_widget_mirrored_set ( Eo * obj , void * _pd , va_list * list )
{
Eina_Bool mirrored = va_arg ( * list , int ) ;
Elm_Widget_Smart_Data * sd = _pd ;
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
}
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 )
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) EINA_FALSE ;
Eina_Bool ret = EINA_FALSE ;
eo_do ( ( Eo * ) obj , elm_wdg_mirrored_automatic_get ( & ret ) ) ;
return ret ;
}
static void
_elm_widget_mirrored_automatic_get ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
Eina_Bool * ret = va_arg ( * list , Eina_Bool * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
* ret = sd - > mirrored_auto_mode ;
2011-02-09 08:13:58 -08:00
}
/**
2013-01-26 01:55:18 -08:00
* @ internal
*
2011-02-09 08:13:58 -08:00
* 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 ,
2012-08-30 09:47:10 -07:00
Eina_Bool automatic )
2011-02-09 08:13:58 -08:00
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_mirrored_automatic_set ( automatic ) ) ;
}
static void
_elm_widget_mirrored_automatic_set ( Eo * obj , void * _pd , va_list * list )
{
Eina_Bool automatic = va_arg ( * list , int ) ;
Elm_Widget_Smart_Data * sd = _pd ;
2011-02-09 08:13:58 -08:00
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-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 ,
2012-08-30 09:47:10 -07:00
void ( * func ) ( void * data ,
Evas_Object * obj ) ,
void * data )
2008-10-17 07:40:54 -07:00
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_on_show_region_hook_set ( func , 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
2012-11-25 22:32:53 -08:00
static void
_elm_widget_on_show_region_hook_set ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
region_hook_func_type func = va_arg ( * list , region_hook_func_type ) ;
void * data = va_arg ( * list , void * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
[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 ;
}
2013-12-20 02:08:38 -08:00
/*
* @ internal
*
* Add myself as a sub object of parent object
*
* @ see elm_widget_sub_object_add ( )
*/
2013-09-24 21:33:39 -07:00
EAPI Eina_Bool
elm_widget_sub_object_parent_add ( Evas_Object * sobj )
{
Eina_Bool ret = EINA_FALSE ;
Eo * parent ;
eo_do ( sobj , eo_parent_get ( & parent ) ) ;
eo_do ( parent , elm_wdg_sub_object_add ( sobj , & ret ) ) ;
return ret ;
}
2013-12-20 02:08:38 -08:00
/*
* @ internal
*
* Add sobj to obj ' s sub object .
*
* What does elementary sub object mean ? This is unique in elementary , it
* handles overall elementary policies between parent and sub objects .
* focus , access , deletion , theme , scale , mirror , scrollable child get ,
* translate , name find , display mode set , orientation set , tree dump
* AUTOMATICALLY .
*
* @ see elm_widget_sub_object_parent_add ( )
*/
[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
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) 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
EINA_SAFETY_ON_TRUE_RETURN_VAL ( obj = = sobj , EINA_FALSE ) ;
2013-04-02 19:28:53 -07:00
if ( ! sobj ) goto err ;
2012-11-25 22:32:53 -08:00
Eina_Bool ret = EINA_FALSE ;
eo_do ( obj , elm_wdg_sub_object_add ( sobj , & ret ) ) ;
2013-09-24 21:33:39 -07:00
// FIXME: better handle the error case in the eo called function than here.
2013-04-02 19:28:53 -07:00
if ( ret ) return EINA_TRUE ;
err :
ERR ( " could not add %p as sub object of %p " , obj , sobj ) ;
return EINA_FALSE ;
2008-09-29 23:58:56 -07:00
}
2013-01-26 01:55:18 -08:00
2012-12-06 09:49:19 -08:00
static void
_elm_widget_sub_object_add ( Eo * obj , void * _pd , va_list * list )
{
Evas_Object * sobj = va_arg ( * list , Evas_Object * ) ;
Eina_Bool * ret = va_arg ( * list , Eina_Bool * ) ;
if ( ret ) * ret = EINA_FALSE ;
2013-09-24 11:36:03 -07:00
/* NOTE: In the following two lines, 'sobj' is correct. Do not change it.
* Due to elementary ' s scale policy , scale and pscale can be different in
* some cases . This happens when sobj ' s previous parent and new parent have
* different scale value .
* For example , if sobj ' s previous parent ' s scale is 5 and new parent ' s scale
* is 2 while sobj ' s scale is 0. Then ' pscale ' is 5 and ' scale ' is 2. So we
* need to reset sobj ' s scale to 5.
* Note that each widget ' s scale is 0 by default .
*/
2012-12-06 09:49:19 -08:00
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_Smart_Data * sd = _pd ;
EINA_SAFETY_ON_TRUE_RETURN ( obj = = sobj ) ;
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 ;
if ( ! elm_widget_sub_object_del ( sobj , obj ) ) return ;
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 ) ;
2013-01-02 22:12:51 -08:00
if ( sdc - > parent_obj = = obj ) goto end ;
2012-12-06 09:49:19 -08:00
if ( sdc - > parent_obj )
{
if ( ! elm_widget_sub_object_del ( sdc - > parent_obj , sobj ) )
return ;
}
sdc - > parent_obj = obj ;
2013-02-14 20:45:53 -08:00
sdc - > orient_mode = sd - > orient_mode ;
2012-12-06 09:49:19 -08:00
_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 )
{
2013-04-24 04:41:37 -07:00
sdp = eo_data_scope_get ( sdp - > parent_obj , MY_CLASS ) ;
2012-12-06 09:49:19 -08:00
if ( sdp - > child_can_focus ) break ;
sdp - > child_can_focus = EINA_TRUE ;
}
}
}
else
{
void * data = evas_object_data_get ( sobj , " elm-parent " ) ;
if ( data )
{
if ( data = = obj ) goto end ;
if ( ! elm_widget_sub_object_del ( data , sobj ) ) return ;
}
}
sd - > subobjs = eina_list_append ( sd - > subobjs , sobj ) ;
evas_object_data_set ( sobj , " elm-parent " , obj ) ;
evas_object_event_callback_add
2013-04-24 04:41:37 -07:00
( sobj , EVAS_CALLBACK_DEL , _on_sub_obj_del , obj ) ;
2012-12-06 09:49:19 -08:00
if ( _elm_widget_is ( sobj ) )
{
2013-08-22 01:00:36 -07:00
ELM_WIDGET_DATA_GET ( sobj , sdc ) ;
2012-12-06 09:49:19 -08:00
evas_object_event_callback_add
2013-04-24 04:41:37 -07:00
( sobj , EVAS_CALLBACK_HIDE , _on_sub_obj_hide , NULL ) ;
2012-12-06 09:49:19 -08:00
scale = elm_widget_scale_get ( sobj ) ;
th = elm_widget_theme_get ( sobj ) ;
mirrored = elm_widget_mirrored_get ( sobj ) ;
2014-01-02 21:38:27 -08:00
if ( ! sdc - > on_create )
{
if ( ( scale ! = pscale ) | | ( th ! = pth ) | | ( pmirrored ! = mirrored ) )
elm_widget_theme ( sobj ) ;
}
2012-12-06 09:49:19 -08:00
if ( elm_widget_focus_get ( sobj ) ) _parents_focus ( obj ) ;
}
2013-05-24 02:34:37 -07:00
elm_widget_display_mode_set ( sobj ,
evas_object_size_hint_display_mode_get ( obj ) ) ;
2012-12-06 09:49:19 -08:00
end :
if ( ret ) * ret = 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
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) 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
EINA_SAFETY_ON_TRUE_RETURN_VAL ( obj = = sobj , EINA_FALSE ) ;
if ( ! sobj ) return EINA_FALSE ;
2012-11-25 22:32:53 -08:00
Eina_Bool ret = EINA_FALSE ;
eo_do ( obj , elm_wdg_sub_object_del ( sobj , & ret ) ) ;
return ret ;
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-12-06 09:49:19 -08:00
static void
_elm_widget_sub_object_del ( Eo * obj , void * _pd , va_list * list )
{
Evas_Object * sobj = va_arg ( * list , Evas_Object * ) ;
Eina_Bool * ret = va_arg ( * list , Eina_Bool * ) ;
if ( ret ) * ret = EINA_FALSE ;
Evas_Object * sobj_parent ;
if ( ! sobj ) return ;
Elm_Widget_Smart_Data * sd = _pd ;
EINA_SAFETY_ON_TRUE_RETURN ( obj = = sobj ) ;
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 ;
}
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 ) ) )
{
Evas_Object * parent = obj ;
/* update child focusable-ness on self and parents, now that a
* focusable child is gone */
while ( parent )
{
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 )
{
if ( ( subobj ! = sobj ) & & ( _is_focusable ( subobj ) ) )
{
sdp - > child_can_focus = EINA_TRUE ;
break ;
}
}
/* break again, child_can_focus went back to
* original value */
if ( sdp - > child_can_focus ) break ;
parent = sdp - > parent_obj ;
}
}
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
2013-04-24 04:41:37 -07:00
( sobj , EVAS_CALLBACK_DEL , _on_sub_obj_del , obj ) ;
2012-12-06 09:49:19 -08:00
if ( _elm_widget_is ( sobj ) )
evas_object_event_callback_del_full
2013-04-24 04:41:37 -07:00
( sobj , EVAS_CALLBACK_HIDE , _on_sub_obj_hide , NULL ) ;
2012-12-06 09:49:19 -08:00
if ( ret ) * ret = EINA_TRUE ;
}
2013-01-26 01:55:18 -08:00
/*
* @ internal
*
2013-10-18 03:52:55 -07:00
* a resize object is added to and deleted from the smart member and the sub object
* of the parent if the third argument , Eina_Bool sub_obj , is set as EINA_TRUE .
2012-05-03 15:41:09 -07:00
*/
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 ,
2013-10-16 08:54:54 -07:00
Evas_Object * sobj ,
Eina_Bool sub_obj )
2008-09-29 23:58:56 -07:00
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
2013-10-16 08:54:54 -07:00
eo_do ( obj , elm_wdg_resize_object_set ( sobj , sub_obj ) ) ;
2012-11-25 22:32:53 -08:00
}
static void
_elm_widget_resize_object_set ( Eo * obj , void * _pd , va_list * list )
{
Evas_Object * sobj = va_arg ( * list , Evas_Object * ) ;
2013-10-16 08:54:54 -07:00
Eina_Bool sub_obj = va_arg ( * list , int ) ;
2012-05-03 15:41:09 -07:00
Evas_Object * parent ;
2012-11-25 22:32:53 -08:00
Elm_Widget_Smart_Data * sd = _pd ;
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
2013-10-18 03:52:55 -07:00
if ( sd - > resize_obj & & sub_obj )
2008-10-07 23:38:20 -07:00
{
2011-04-01 04:20:18 -07:00
evas_object_clip_unset ( sd - > resize_obj ) ;
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 ) )
{
2012-08-30 09:47:10 -07:00
if ( elm_widget_focus_get ( sd - > resize_obj ) ) _parents_unfocus ( obj ) ;
2010-09-28 22:27:42 -07:00
}
2013-10-18 03:52:55 -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 ;
2013-07-11 01:47:25 -07:00
if ( ! sobj ) return ;
2011-10-19 10:07:15 -07:00
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 )
2013-10-16 08:54:54 -07:00
elm_widget_resize_object_set ( parent , NULL , sub_obj ) ;
else if ( sub_obj )
2012-05-03 15:41:09 -07:00
elm_widget_sub_object_del ( parent , sobj ) ;
}
2012-05-02 18:19:05 -07:00
}
2013-10-18 03:52:55 -07:00
if ( sub_obj )
{
elm_widget_sub_object_add ( obj , sobj ) ;
evas_object_smart_member_add ( sobj , obj ) ;
}
2012-05-03 15:41:09 -07:00
2011-10-19 10:07:15 -07:00
_smart_reconfigure ( sd ) ;
2008-10-07 23:38:20 -07:00
}
2013-01-26 01:55:18 -08:00
/*
* @ internal
*
* WARNING : the programmer is responsible , in the scenario of
2012-05-03 15:41:09 -07:00
* 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
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_hover_object_set ( sobj ) ) ;
}
static void
_elm_widget_hover_object_set ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
Evas_Object * sobj = va_arg ( * list , Evas_Object * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
2008-10-07 23:38:20 -07:00
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 ,
2013-04-24 04:41:37 -07:00
_on_sub_obj_del , obj ) ;
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 ,
2013-04-24 04:41:37 -07:00
_on_sub_obj_del , obj ) ;
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 ,
2012-08-30 09:47:10 -07:00
Eina_Bool can_focus )
2008-10-06 18:23:49 -07:00
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_can_focus_set ( can_focus ) ) ;
}
static void
_elm_widget_can_focus_set ( Eo * obj , void * _pd , va_list * list )
{
Eina_Bool can_focus = va_arg ( * list , int ) ;
Elm_Widget_Smart_Data * sd = _pd ;
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
{
2013-05-07 04:41:32 -07:00
/* update child_can_focus of parents */
Evas_Object * o = obj ;
for ( ; ; )
{
o = elm_widget_parent_get ( o ) ;
if ( ! o ) break ;
sd = eo_data_scope_get ( o , MY_CLASS ) ;
if ( ! sd | | sd - > child_can_focus ) break ;
sd - > child_can_focus = EINA_TRUE ;
}
2010-09-20 19:02:24 -07:00
evas_object_event_callback_add ( obj , EVAS_CALLBACK_KEY_DOWN ,
_propagate_event ,
2013-09-26 00:34:35 -07:00
( void * ) ( uintptr_t ) EVAS_CALLBACK_KEY_DOWN ) ;
2010-09-20 19:02:24 -07:00
evas_object_event_callback_add ( obj , EVAS_CALLBACK_KEY_UP ,
_propagate_event ,
2013-09-26 00:34:35 -07:00
( void * ) ( uintptr_t ) EVAS_CALLBACK_KEY_UP ) ;
2010-12-06 04:45:41 -08:00
evas_object_event_callback_add ( obj , EVAS_CALLBACK_MOUSE_WHEEL ,
_propagate_event ,
2013-09-26 00:34:35 -07:00
( void * ) ( uintptr_t ) 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
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) EINA_FALSE ;
Eina_Bool ret = EINA_FALSE ;
eo_do ( ( Eo * ) obj , elm_wdg_can_focus_get ( & ret ) ) ;
return ret ;
}
static void
_elm_widget_can_focus_get ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
Eina_Bool * ret = va_arg ( * list , Eina_Bool * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
* ret = sd - > can_focus ;
2010-09-24 07:47:52 -07:00
}
EAPI Eina_Bool
elm_widget_child_can_focus_get ( const Evas_Object * obj )
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) EINA_FALSE ;
Eina_Bool ret = EINA_FALSE ;
eo_do ( ( Eo * ) obj , elm_wdg_child_can_focus_get ( & ret ) ) ;
return ret ;
}
static void
_elm_widget_child_can_focus_get ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
Eina_Bool * ret = va_arg ( * list , Eina_Bool * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
* ret = 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 ,
2012-08-30 09:47:10 -07:00
Eina_Bool tree_unfocusable )
2011-07-27 23:58:29 -07:00
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_tree_unfocusable_set ( tree_unfocusable ) ) ;
}
static void
_elm_widget_tree_unfocusable_set ( Eo * obj , void * _pd , va_list * list )
{
Eina_Bool tree_unfocusable = va_arg ( * list , int ) ;
Elm_Widget_Smart_Data * sd = _pd ;
2011-07-27 23:58:29 -07:00
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 )
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) EINA_FALSE ;
Eina_Bool ret = EINA_FALSE ;
eo_do ( ( Eo * ) obj , elm_wdg_tree_unfocusable_get ( & ret ) ) ;
return ret ;
}
static void
_elm_widget_tree_unfocusable_get ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
Eina_Bool * ret = va_arg ( * list , Eina_Bool * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
* ret = sd - > tree_unfocusable ;
2011-07-27 23:58:29 -07:00
}
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 )
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) NULL ;
Eina_List * ret = NULL ;
eo_do ( ( Eo * ) obj , elm_wdg_can_focus_child_list_get ( & ret ) ) ;
return ret ;
}
static void
_elm_widget_can_focus_child_list_get ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
Eina_List * * ret = va_arg ( * list , Eina_List * * ) ;
2011-08-05 01:25:07 -07:00
const Eina_List * l ;
Eina_List * child_list = NULL ;
Evas_Object * child ;
2012-11-25 22:32:53 -08:00
Elm_Widget_Smart_Data * sd = _pd ;
2011-08-05 01:25:07 -07:00
if ( sd - > subobjs )
{
2012-10-01 00:36:27 -07:00
EINA_LIST_FOREACH ( sd - > subobjs , l , child )
2011-08-05 01:25:07 -07:00
{
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 ) ;
}
}
}
2012-11-25 22:32:53 -08:00
* ret = child_list ;
2011-08-05 01:25:07 -07:00
}
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 ,
2012-08-30 09:47:10 -07:00
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
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_highlight_ignore_set ( ignore ) ) ;
}
static void
_elm_widget_highlight_ignore_set ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
Eina_Bool ignore = va_arg ( * list , int ) ;
Elm_Widget_Smart_Data * sd = _pd ;
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
sd - > highlight_ignore = ! ! ignore ;
}
EAPI Eina_Bool
elm_widget_highlight_ignore_get ( const Evas_Object * obj )
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) EINA_FALSE ;
Eina_Bool ret = EINA_FALSE ;
eo_do ( ( Eo * ) obj , elm_wdg_highlight_ignore_get ( & ret ) ) ;
return ret ;
}
static void
_elm_widget_highlight_ignore_get ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
Eina_Bool * ret = va_arg ( * list , Eina_Bool * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
* ret = sd - > highlight_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
}
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 ,
2012-08-30 09:47:10 -07:00
Eina_Bool highlight )
2010-09-22 15:33:57 -07:00
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_highlight_in_theme_set ( highlight ) ) ;
}
static void
_elm_widget_highlight_in_theme_set ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
Eina_Bool highlight = va_arg ( * list , int ) ;
Elm_Widget_Smart_Data * sd = _pd ;
2010-09-22 15:33:57 -07:00
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 )
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) EINA_FALSE ;
Eina_Bool ret = EINA_FALSE ;
eo_do ( ( Eo * ) obj , elm_wdg_highlight_in_theme_get ( & ret ) ) ;
return ret ;
}
static void
_elm_widget_highlight_in_theme_get ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
Eina_Bool * ret = va_arg ( * list , Eina_Bool * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
* ret = sd - > highlight_in_theme ;
2010-09-22 15:33:57 -07:00
}
2014-02-07 19:27:41 -08:00
EAPI void
elm_widget_access_highlight_in_theme_set ( Evas_Object * obj ,
Eina_Bool highlight )
{
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_access_highlight_in_theme_set ( highlight ) ) ;
}
static void
_elm_widget_access_highlight_in_theme_set ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
Eina_Bool highlight = va_arg ( * list , int ) ;
Elm_Widget_Smart_Data * sd = _pd ;
sd - > access_highlight_in_theme = ! ! highlight ;
}
EAPI Eina_Bool
elm_widget_access_highlight_in_theme_get ( const Evas_Object * obj )
{
ELM_WIDGET_CHECK ( obj ) EINA_FALSE ;
Eina_Bool ret = EINA_FALSE ;
eo_do ( ( Eo * ) obj , elm_wdg_access_highlight_in_theme_get ( & ret ) ) ;
return ret ;
}
static void
_elm_widget_access_highlight_in_theme_get ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
Eina_Bool * ret = va_arg ( * list , Eina_Bool * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
* ret = sd - > access_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
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) EINA_FALSE ;
Eina_Bool ret = EINA_FALSE ;
eo_do ( ( Eo * ) obj , elm_wdg_focus_get ( & ret ) ) ;
return ret ;
}
static void
_elm_widget_focus_get ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
Eina_Bool * ret = va_arg ( * list , Eina_Bool * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
* ret = sd - > focused ;
2008-10-06 18:23:49 -07:00
}
2013-01-28 03:13:18 -08:00
EAPI Eina_Bool
elm_widget_highlight_get ( const Evas_Object * obj )
{
ELM_WIDGET_CHECK ( obj ) EINA_FALSE ;
Eina_Bool ret = EINA_FALSE ;
eo_do ( ( Eo * ) obj , elm_wdg_highlight_get ( & ret ) ) ;
return ret ;
}
static void
_elm_widget_highlight_get ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
Eina_Bool * ret = va_arg ( * list , Eina_Bool * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
* ret = sd - > highlighted ;
}
2008-10-06 18:23:49 -07:00
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
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) NULL ;
Evas_Object * ret = NULL ;
eo_do ( ( Eo * ) obj , elm_wdg_focused_object_get ( & ret ) ) ;
return ret ;
}
static void
_elm_widget_focused_object_get ( Eo * obj , void * _pd , va_list * list )
{
Evas_Object * * ret = va_arg ( * list , Evas_Object * * ) ;
* ret = NULL ;
Elm_Widget_Smart_Data * sd = _pd ;
2009-02-25 07:54:26 -08:00
const Evas_Object * subobj ;
const Eina_List * l ;
2009-10-17 23:03:03 -07:00
2012-11-25 22:32:53 -08:00
if ( ! sd - > focused ) return ;
2012-10-01 00:36:27 -07:00
EINA_LIST_FOREACH ( sd - > subobjs , l , subobj )
2009-02-25 07:54:26 -08:00
{
2012-11-25 22:32:53 -08:00
Evas_Object * fobj ;
fobj = elm_widget_focused_object_get ( subobj ) ;
if ( fobj )
{
* ret = fobj ;
return ;
}
2008-10-06 18:23:49 -07:00
}
2012-11-25 22:32:53 -08:00
* ret = ( 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
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) NULL ;
Evas_Object * ret = NULL ;
eo_do ( ( Eo * ) obj , elm_wdg_top_get ( & ret ) ) ;
return ret ;
}
static void
_elm_widget_top_get ( Eo * obj , void * _pd , va_list * list )
{
Evas_Object * * ret = va_arg ( * list , Evas_Object * * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
Evas_Object * int_ret = NULL ;
if ( sd - > parent_obj )
{
eo_do ( ( Eo * ) sd - > parent_obj , elm_wdg_top_get ( & int_ret ) ) ;
* ret = int_ret ;
return ;
}
* ret = ( 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-11-25 22:32:53 -08:00
ELM_WIDGET_DATA_GET ( obj , sd ) ;
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 )
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) NULL ;
Evas_Object * ret = NULL ;
eo_do ( ( Eo * ) obj , elm_wdg_parent2_get ( & ret ) ) ;
return ret ;
}
static void
_elm_widget_parent2_get ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
Evas_Object * * ret = va_arg ( * list , Evas_Object * * ) ;
* ret = NULL ;
Elm_Widget_Smart_Data * sd = _pd ;
* ret = sd - > parent2 ;
2011-08-02 03:34:30 -07:00
}
EAPI void
elm_widget_parent2_set ( Evas_Object * obj , Evas_Object * parent )
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_parent2_set ( parent ) ) ;
}
static void
_elm_widget_parent2_set ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
Evas_Object * parent = va_arg ( * list , Evas_Object * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
2011-08-02 03:34:30 -07:00
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 ,
2012-08-30 09:47:10 -07:00
const void * data )
2010-11-29 05:56:30 -08:00
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
EINA_SAFETY_ON_NULL_RETURN ( func ) ;
eo_do ( obj , elm_wdg_event_callback_add ( func , data ) ) ;
}
static void
_elm_widget_event_callback_add ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
Elm_Event_Cb func = va_arg ( * list , Elm_Event_Cb ) ;
2010-12-03 06:08:33 -08:00
EINA_SAFETY_ON_NULL_RETURN ( func ) ;
2012-11-25 22:32:53 -08:00
const void * data = va_arg ( * list , const void * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
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 ,
2012-08-30 09:47:10 -07:00
const void * data )
2010-11-29 05:56:30 -08:00
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) NULL ;
2010-12-03 06:08:33 -08:00
EINA_SAFETY_ON_NULL_RETURN_VAL ( func , NULL ) ;
2012-11-25 22:32:53 -08:00
void * ret = NULL ;
eo_do ( obj , elm_wdg_event_callback_del ( func , data , & ret ) ) ;
return ret ;
}
static void
_elm_widget_event_callback_del ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
Elm_Event_Cb func = va_arg ( * list , Elm_Event_Cb ) ;
const void * data = va_arg ( * list , const void * ) ;
void * * ret = va_arg ( * list , void * * ) ;
if ( ret ) * ret = NULL ;
EINA_SAFETY_ON_NULL_RETURN ( func ) ;
2010-11-29 05:56:30 -08:00
Eina_List * l ;
Elm_Event_Cb_Data * ecd ;
2012-11-25 22:32:53 -08:00
Elm_Widget_Smart_Data * sd = _pd ;
2012-10-01 00:36:27 -07:00
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 ) ;
2012-11-25 22:32:53 -08:00
if ( ret ) * ret = ( void * ) data ;
return ;
2011-04-02 23:43:17 -07:00
}
2010-11-29 05:56:30 -08:00
}
2010-09-20 19:02:24 -07:00
EAPI Eina_Bool
2012-08-30 09:47:10 -07:00
elm_widget_event_propagate ( Evas_Object * obj ,
2011-04-02 23:43:17 -07:00
Evas_Callback_Type type ,
2012-08-30 09:47:10 -07:00
void * event_info ,
Evas_Event_Flags * event_flags )
2010-09-20 19:02:24 -07:00
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) EINA_FALSE ;
Eina_Bool ret = EINA_FALSE ;
eo_do ( obj , elm_wdg_event_propagate ( type , event_info , event_flags , & ret ) ) ;
return ret ;
}
static void
_elm_widget_event_propagate ( Eo * obj , void * _pd EINA_UNUSED , va_list * list )
{
Evas_Callback_Type type = va_arg ( * list , Evas_Callback_Type ) ;
void * event_info = va_arg ( * list , void * ) ;
Evas_Event_Flags * event_flags = va_arg ( * list , Evas_Event_Flags * ) ;
Eina_Bool * ret = va_arg ( * list , Eina_Bool * ) ;
if ( ret ) * ret = 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
2010-11-29 05:56:30 -08:00
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
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( parent ) ;
2013-04-24 04:41:37 -07:00
Elm_Widget_Smart_Data * sd = eo_data_scope_get ( parent , MY_CLASS ) ;
2010-11-29 05:56:30 -08:00
2012-11-25 22:32:53 -08:00
Eina_Bool int_ret = EINA_FALSE ;
eo_do ( parent , elm_wdg_event ( obj , type , event_info , & int_ret ) ) ;
if ( int_ret )
{
if ( ret ) * ret = EINA_TRUE ;
return ;
}
2010-11-29 05:56:30 -08:00
2012-10-01 00:36:27 -07:00
EINA_LIST_FOREACH_SAFE ( sd - > event_cb , l , l_prev , ecd )
2010-11-29 05:56:30 -08:00
{
if ( ecd - > func ( ( void * ) ecd - > data , parent , obj , type , event_info ) | |
( event_flags & & ( ( * event_flags ) & EVAS_EVENT_FLAG_ON_HOLD ) ) )
2012-11-25 22:32:53 -08:00
{
if ( ret ) * ret = EINA_TRUE ;
return ;
}
2010-11-29 05:56:30 -08:00
}
2010-09-20 19:02:24 -07:00
parent = sd - > parent_obj ;
}
}
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 ,
2012-08-30 09:47:10 -07:00
Eina_List * objs )
2010-10-06 13:24:22 -07:00
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_focus_custom_chain_set ( objs ) ) ;
}
[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-11-25 22:32:53 -08:00
static void
_elm_widget_focus_custom_chain_set ( Eo * obj , void * _pd , va_list * list )
{
Eina_List * objs = va_arg ( * list , Eina_List * ) ;
[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 ;
2012-11-25 22:32:53 -08:00
Elm_Widget_Smart_Data * sd = _pd ;
2010-10-06 13:24:22 -07:00
2012-10-01 00:36:27 -07:00
EINA_LIST_FOREACH ( objs , l , o )
2010-10-06 13:24:22 -07:00
{
evas_object_event_callback_add ( o , EVAS_CALLBACK_DEL ,
2013-04-24 04:41:37 -07:00
_elm_object_focus_chain_del_cb , obj ) ;
2010-10-06 13:24:22 -07:00
}
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 )
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) NULL ;
const Eina_List * ret = NULL ;
eo_do ( ( Eo * ) obj , elm_wdg_focus_custom_chain_get ( & ret ) ) ;
return ret ;
}
static void
_elm_widget_focus_custom_chain_get ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
const Eina_List * * ret = va_arg ( * list , const Eina_List * * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
* ret = ( 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 )
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_focus_custom_chain_unset ( ) ) ;
}
static void
_elm_widget_focus_custom_chain_unset ( Eo * obj EINA_UNUSED , void * _pd , va_list * list EINA_UNUSED )
{
2010-10-19 07:17:03 -07:00
Eina_List * l , * l_next ;
Evas_Object * o ;
2012-11-25 22:32:53 -08:00
Elm_Widget_Smart_Data * sd = _pd ;
2010-10-19 07:17:03 -07:00
2012-10-01 00:36:27 -07:00
EINA_LIST_FOREACH_SAFE ( sd - > focus_chain , l , l_next , o )
2010-10-19 07:17:03 -07:00
{
evas_object_event_callback_del_full ( o , EVAS_CALLBACK_DEL ,
2013-04-24 04:41:37 -07:00
_elm_object_focus_chain_del_cb , obj ) ;
2010-10-19 07:17:03 -07:00
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
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
EINA_SAFETY_ON_NULL_RETURN ( child ) ;
eo_do ( obj , elm_wdg_focus_custom_chain_append ( child , relative_child ) ) ;
}
static void
_elm_widget_focus_custom_chain_append ( Eo * obj , void * _pd , va_list * list )
{
Evas_Object * child = va_arg ( * list , Evas_Object * ) ;
Evas_Object * relative_child = va_arg ( * list , Evas_Object * ) ;
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
2012-11-25 22:32:53 -08:00
Elm_Widget_Smart_Data * sd = _pd ;
[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
2014-01-21 23:24:25 -08:00
evas_object_event_callback_add ( child , EVAS_CALLBACK_DEL ,
_elm_object_focus_chain_del_cb , obj ) ;
2010-10-06 13:24:22 -07:00
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
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
2010-12-03 06:08:33 -08:00
EINA_SAFETY_ON_NULL_RETURN ( child ) ;
2012-11-25 22:32:53 -08:00
eo_do ( obj , elm_wdg_focus_custom_chain_prepend ( child , relative_child ) ) ;
}
static void
_elm_widget_focus_custom_chain_prepend ( Eo * obj , void * _pd , va_list * list )
{
Evas_Object * child = va_arg ( * list , Evas_Object * ) ;
Evas_Object * relative_child = va_arg ( * list , Evas_Object * ) ;
EINA_SAFETY_ON_NULL_RETURN ( child ) ;
Elm_Widget_Smart_Data * sd = _pd ;
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
2014-01-21 23:24:25 -08:00
evas_object_event_callback_add ( child , EVAS_CALLBACK_DEL ,
_elm_object_focus_chain_del_cb , obj ) ;
2010-10-06 13:24:22 -07:00
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
2012-08-30 09:47:10 -07:00
elm_widget_focus_cycle ( Evas_Object * obj ,
2011-04-02 23:43:17 -07:00
Elm_Focus_Direction dir )
2010-10-06 13:24:16 -07:00
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_focus_cycle ( dir ) ) ;
}
static void
_elm_widget_focus_cycle ( Eo * obj , void * _pd EINA_UNUSED , va_list * list )
{
Elm_Focus_Direction dir = va_arg ( * list , Elm_Focus_Direction ) ;
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 )
2013-01-28 03:13:18 -08:00
{
/* access */
2013-09-09 22:01:50 -07:00
if ( _elm_config - > access_mode )
2013-02-05 02:08:42 -08:00
{
2013-09-09 22:01:50 -07:00
/* highlight cycle does not steal a focus, only after window gets
the ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_ACTIVATE message ,
target will steal focus , or focus its own job . */
if ( ! _elm_access_auto_highlight_get ( ) )
elm_widget_focus_steal ( target ) ;
2013-02-05 02:08:42 -08:00
_elm_access_highlight_set ( target ) ;
2013-07-05 22:41:00 -07:00
elm_widget_focus_region_show ( target ) ;
2013-02-05 02:08:42 -08:00
}
2013-01-28 03:13:18 -08:00
else elm_widget_focus_steal ( target ) ;
}
2010-10-06 13:24:16 -07:00
}
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-08-30 09:47:10 -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
2012-08-30 09:47:10 -07:00
elm_widget_focus_direction_go ( Evas_Object * obj ,
double degree )
2012-05-02 20:02:54 -07:00
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) EINA_FALSE ;
Eina_Bool ret = EINA_FALSE ;
eo_do ( obj , elm_wdg_focus_direction_go ( degree , & ret ) ) ;
return ret ;
}
static void
_elm_widget_focus_direction_go ( Eo * obj , void * _pd EINA_UNUSED , va_list * list )
{
double degree = va_arg ( * list , double ) ;
Eina_Bool * ret = va_arg ( * list , Eina_Bool * ) ;
if ( ret ) * ret = EINA_FALSE ;
2012-05-02 20:02:54 -07:00
Evas_Object * target = NULL ;
Evas_Object * current_focused = NULL ;
double weight = 0.0 ;
2012-11-25 22:32:53 -08:00
if ( ! _elm_widget_is ( obj ) ) return ;
if ( ! elm_widget_focus_get ( obj ) ) return ;
2012-05-02 20:02:54 -07:00
current_focused = elm_widget_focused_object_get ( obj ) ;
2012-08-30 09:47:10 -07:00
if ( elm_widget_focus_direction_get
( obj , current_focused , degree , & target , & weight ) )
2012-05-02 20:02:54 -07:00
{
elm_widget_focus_steal ( target ) ;
2012-11-25 22:32:53 -08:00
if ( ret ) * ret = EINA_TRUE ;
return ;
2012-05-02 20:02:54 -07:00
}
}
2012-08-30 09:47:10 -07:00
static double
_direction_weight_get ( const Evas_Object * obj1 ,
const Evas_Object * obj2 ,
double degree )
2012-05-02 20:02:54 -07:00
{
2012-08-30 09:47:10 -07:00
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 ;
2012-05-02 20:02:54 -07:00
2012-08-30 09:47:10 -07:00
if ( obj1 = = obj2 ) return 0.0 ;
2012-05-02 20:02:54 -07:00
2012-08-30 09:47:10 -07:00
degree - = 90.0 ;
while ( degree > = 360.0 )
degree - = 360.0 ;
while ( degree < 0.0 )
degree + = 360.0 ;
2012-05-02 20:02:54 -07:00
2012-08-30 09:47:10 -07:00
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 ) ;
2012-05-02 20:02:54 -07:00
2012-08-30 09:47:10 -07:00
/* For overlapping cases. */
if ( ELM_RECTS_INTERSECT ( obj_x1 , obj_y1 , w1 , h1 , obj_x2 , obj_y2 , w2 , h2 ) )
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 ;
2012-05-02 20:02:54 -07:00
2012-08-30 09:47:10 -07:00
/* Get crossing points (ax, ay) between obj1 and a line extending
* to the direction of current degree . */
if ( degree = = 0.0 )
2012-05-02 20:02:54 -07:00
{
2012-08-30 09:47:10 -07:00
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 ) )
2012-05-02 20:02:54 -07:00
{
2012-08-30 09:47:10 -07:00
ay = g * xx1 ;
if ( ay < = yyy1 ) ax = xx1 ;
else
2012-05-02 20:02:54 -07:00
{
2012-08-30 09:47:10 -07:00
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 ;
2012-05-02 20:02:54 -07:00
}
}
}
2012-08-30 09:47:10 -07:00
/* 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 ) ;
# define _R(x) (int)((x + 0.05) * 10.0)
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 ;
# undef _R
return 1.0 / weight ;
}
/**
* @ 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
*/
2012-11-25 22:32:53 -08:00
2012-08-30 09:47:10 -07:00
EAPI Eina_Bool
elm_widget_focus_direction_get ( const Evas_Object * obj ,
const Evas_Object * base ,
double degree ,
Evas_Object * * direction ,
double * weight )
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) EINA_FALSE ;
Eina_Bool ret = EINA_FALSE ;
eo_do ( ( Eo * ) obj , elm_wdg_focus_direction_get ( base , degree , direction , weight , & ret ) ) ;
return ret ;
}
static void
_elm_widget_focus_direction_get ( Eo * obj , void * _pd , va_list * list )
{
const Evas_Object * base = va_arg ( * list , const Evas_Object * ) ;
double degree = va_arg ( * list , double ) ;
Evas_Object * * direction = va_arg ( * list , Evas_Object * * ) ;
double * weight = va_arg ( * list , double * ) ;
Eina_Bool * ret = va_arg ( * list , Eina_Bool * ) ;
* ret = EINA_FALSE ;
Elm_Widget_Smart_Data * sd = _pd ;
2012-08-30 09:47:10 -07:00
double c_weight ;
/* -1 means the best was already decided. Don't need any more searching. */
if ( ! direction | | ! weight | | ! base | | ( obj = = base ) )
2012-11-25 22:32:53 -08:00
return ;
2012-08-30 09:47:10 -07:00
/* Ignore if disabled */
if ( ( ! evas_object_visible_get ( obj ) )
| | ( elm_widget_disabled_get ( obj ) )
| | ( elm_widget_tree_unfocusable_get ( obj ) ) )
2012-11-25 22:32:53 -08:00
return ;
2012-08-30 09:47:10 -07:00
/* Try use hook */
if ( _elm_widget_focus_direction_manager_is ( obj ) )
2012-11-25 22:32:53 -08:00
{
Eina_Bool int_ret = EINA_FALSE ;
eo_do ( ( Eo * ) obj , elm_wdg_focus_direction ( base , degree , direction , weight , & int_ret ) ) ;
* ret = int_ret ;
return ;
}
2012-08-30 09:47:10 -07:00
if ( ! elm_widget_can_focus_get ( obj ) | | elm_widget_focus_get ( obj ) )
2012-11-25 22:32:53 -08:00
return ;
2012-08-30 09:47:10 -07:00
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 ) ) ) )
{
2013-11-04 04:14:45 -08:00
if ( * direction & &
( ( int ) ( * weight * 1000000 ) = = ( int ) ( c_weight * 1000000 ) ) )
2012-08-30 09:47:10 -07:00
{
2013-01-27 04:14:23 -08:00
ELM_WIDGET_DATA_GET ( * direction , sd1 ) ;
2012-08-30 09:47:10 -07:00
if ( sd1 )
{
if ( sd - > focus_order < = sd1 - > focus_order )
2012-11-25 22:32:53 -08:00
return ;
2012-08-30 09:47:10 -07:00
}
}
* direction = ( Evas_Object * ) obj ;
* weight = c_weight ;
2012-11-25 22:32:53 -08:00
* ret = EINA_TRUE ;
2012-08-30 09:47:10 -07:00
}
}
/**
* @ 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 .
*
* @ ingroup Widget
*/
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 * l ) ,
double degree ,
Evas_Object * * direction ,
double * weight )
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) EINA_FALSE ;
Eina_Bool ret = EINA_FALSE ;
eo_do ( ( Eo * ) obj , elm_wdg_focus_list_direction_get ( base , items , list_data_get , degree , direction , weight , & ret ) ) ;
return ret ;
}
static void
_elm_widget_focus_list_direction_get ( Eo * obj EINA_UNUSED , void * _pd EINA_UNUSED , va_list * list )
{
const Evas_Object * base = va_arg ( * list , const Evas_Object * ) ;
const Eina_List * items = va_arg ( * list , const Eina_List * ) ;
list_data_get_func_type list_data_get = va_arg ( * list , list_data_get_func_type ) ;
double degree = va_arg ( * list , double ) ;
Evas_Object * * direction = va_arg ( * list , Evas_Object * * ) ;
double * weight = va_arg ( * list , double * ) ;
Eina_Bool * ret = va_arg ( * list , Eina_Bool * ) ;
* ret = EINA_FALSE ;
2012-08-30 09:47:10 -07:00
if ( ! direction | | ! weight | | ! base | | ! items )
2012-11-25 22:32:53 -08:00
return ;
2012-05-02 20:02:54 -07:00
const Eina_List * l = items ;
Evas_Object * current_best = * direction ;
for ( ; l ; l = eina_list_next ( l ) )
{
Evas_Object * cur = list_data_get ( l ) ;
2014-01-14 05:47:54 -08:00
if ( cur )
elm_widget_focus_direction_get ( cur , base , degree , direction , weight ) ;
2012-05-02 20:02:54 -07:00
}
if ( current_best ! = * direction )
2012-11-25 22:32:53 -08:00
* ret = EINA_TRUE ;
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
2013-03-22 17:36:21 -07:00
* @ param dir Direction of focus chain
2010-10-19 07:17:03 -07:00
* @ 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
2012-08-30 09:47:10 -07:00
elm_widget_focus_next_get ( const Evas_Object * obj ,
2011-04-02 23:43:17 -07:00
Elm_Focus_Direction dir ,
2012-08-30 09:47:10 -07:00
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 ;
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) EINA_FALSE ;
Eina_Bool ret = EINA_FALSE ;
eo_do ( ( Eo * ) obj , elm_wdg_focus_next_get ( dir , next , & ret ) ) ;
return ret ;
}
static void
_elm_widget_focus_next_get ( Eo * obj , void * _pd EINA_UNUSED , va_list * list )
{
2013-09-09 22:22:21 -07:00
Elm_Access_Info * ac ;
2012-11-25 22:32:53 -08:00
Elm_Focus_Direction dir = va_arg ( * list , Elm_Focus_Direction ) ;
Evas_Object * * next = va_arg ( * list , Evas_Object * * ) ;
Eina_Bool * ret = va_arg ( * list , Eina_Bool * ) ;
2013-03-22 17:36:21 -07:00
Elm_Widget_Smart_Data * sd = _pd ;
2012-11-25 22:32:53 -08:00
* ret = EINA_FALSE ;
if ( ! next )
return ;
* next = NULL ;
2010-09-24 07:47:59 -07:00
2010-10-01 12:02:55 -07:00
/* Ignore if disabled */
2013-09-09 22:22:21 -07:00
if ( _elm_config - > access_mode & & _elm_access_auto_highlight_get ( ) )
{
if ( ! evas_object_visible_get ( obj )
| | ( elm_widget_tree_unfocusable_get ( obj ) ) )
return ;
}
else
{
if ( ( ! evas_object_visible_get ( obj ) )
| | ( elm_widget_disabled_get ( obj ) )
| | ( elm_widget_tree_unfocusable_get ( obj ) ) )
return ;
}
2012-08-30 09:47:10 -07:00
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 ) )
2012-11-25 22:32:53 -08:00
{
Eina_Bool int_ret = EINA_FALSE ;
eo_do ( ( Eo * ) obj , elm_wdg_focus_next ( dir , next , & int_ret ) ) ;
2013-03-22 17:36:21 -07:00
if ( ! int_ret & & elm_widget_focus_get ( obj ) )
{
Evas_Object * o = NULL ;
if ( dir = = ELM_FOCUS_PREVIOUS )
o = sd - > focus_previous ;
else if ( dir = = ELM_FOCUS_NEXT )
o = sd - > focus_next ;
else if ( dir = = ELM_FOCUS_UP )
o = sd - > focus_up ;
else if ( dir = = ELM_FOCUS_DOWN )
o = sd - > focus_down ;
else if ( dir = = ELM_FOCUS_RIGHT )
o = sd - > focus_right ;
else if ( dir = = ELM_FOCUS_LEFT )
o = sd - > focus_left ;
if ( o )
{
* next = o ;
* ret = EINA_TRUE ;
return ;
}
}
2012-11-25 22:32:53 -08:00
* ret = int_ret ;
return ;
}
2010-10-01 12:02:55 -07:00
2013-09-09 22:22:21 -07:00
/* access object does not check sd->can_focus, because an object could
have highlight even though the object is not focusable . */
if ( _elm_config - > access_mode & & _elm_access_auto_highlight_get ( ) )
2013-02-15 02:39:00 -08:00
{
2013-09-09 22:22:21 -07:00
ac = _elm_access_info_get ( obj ) ;
2013-02-15 02:39:00 -08:00
if ( ! ac ) return ;
2013-09-09 22:22:21 -07:00
/* check whether the hover object is visible or not */
if ( ! evas_object_visible_get ( ac - > hoverobj ) )
return ;
2013-02-15 02:39:00 -08:00
}
2013-09-09 22:22:21 -07:00
else if ( ! elm_widget_can_focus_get ( obj ) )
return ;
2013-02-15 02:39:00 -08:00
2013-03-22 17:36:21 -07:00
if ( elm_widget_focus_get ( obj ) )
{
if ( dir = = ELM_FOCUS_PREVIOUS )
* next = sd - > focus_previous ;
else if ( dir = = ELM_FOCUS_NEXT )
* next = sd - > focus_next ;
else if ( dir = = ELM_FOCUS_UP )
* next = sd - > focus_up ;
else if ( dir = = ELM_FOCUS_DOWN )
* next = sd - > focus_down ;
else if ( dir = = ELM_FOCUS_RIGHT )
* next = sd - > focus_right ;
else if ( dir = = ELM_FOCUS_LEFT )
* next = sd - > focus_left ;
if ( * next )
{
* ret = EINA_TRUE ;
return ;
}
}
2010-10-06 13:24:09 -07:00
/* Return */
2010-10-06 13:24:19 -07:00
* next = ( Evas_Object * ) obj ;
2013-01-28 03:13:18 -08:00
* ret = ! 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 items list with ordered objects
* @ param list_data_get function to get the object from one item of list
2013-04-03 05:26:04 -07:00
* @ param dir Direction of focus chain
2010-10-19 07:17:03 -07:00
* @ 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
2012-08-30 09:47:10 -07:00
elm_widget_focus_list_next_get ( const Evas_Object * obj ,
const Eina_List * items ,
void * ( * list_data_get ) ( const Eina_List * list ) ,
2011-04-02 23:43:17 -07:00
Elm_Focus_Direction dir ,
2012-08-30 09:47:10 -07:00
Evas_Object * * next )
2010-09-24 07:47:59 -07:00
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) EINA_FALSE ;
Eina_Bool ret = EINA_FALSE ;
eo_do ( ( Eo * ) obj , elm_wdg_focus_list_next_get ( items , list_data_get , dir , next , & ret ) ) ;
return ret ;
}
static void
_elm_widget_focus_list_next_get ( Eo * obj , void * _pd EINA_UNUSED , va_list * list )
{
const Eina_List * items = va_arg ( * list , const Eina_List * ) ;
list_data_get_func_type list_data_get = va_arg ( * list , list_data_get_func_type ) ;
Elm_Focus_Direction dir = va_arg ( * list , Elm_Focus_Direction ) ;
Evas_Object * * next = va_arg ( * list , Evas_Object * * ) ;
Eina_Bool * ret = va_arg ( * list , Eina_Bool * ) ;
if ( ret ) * ret = EINA_FALSE ;
2012-08-30 09:47:10 -07:00
Eina_List * ( * list_next ) ( const Eina_List * list ) = NULL ;
2013-03-22 17:36:21 -07:00
Evas_Object * focused_object = NULL ;
2010-10-06 13:24:09 -07:00
if ( ! next )
2012-11-25 22:32:53 -08:00
return ;
2010-10-06 13:24:09 -07:00
* next = NULL ;
2010-09-24 07:47:59 -07:00
2010-10-21 11:58:43 -07:00
if ( ! _elm_widget_is ( obj ) )
2012-11-25 22:32:53 -08:00
return ;
2010-10-21 11:58:40 -07:00
2010-09-24 07:47:59 -07:00
if ( ! items )
2012-11-25 22:32:53 -08:00
return ;
2010-09-24 07:47:59 -07:00
2013-03-22 17:36:21 -07:00
/* When Up, Down, Right, or Left, try direction_get first. */
focused_object = elm_widget_focused_object_get ( obj ) ;
if ( focused_object )
{
if ( ( dir = = ELM_FOCUS_UP )
| | ( dir = = ELM_FOCUS_DOWN )
| | ( dir = = ELM_FOCUS_RIGHT )
| | ( dir = = ELM_FOCUS_LEFT ) )
{
* next = elm_widget_focus_next_object_get ( focused_object , dir ) ;
if ( * next )
{
if ( ret ) * ret = EINA_TRUE ;
return ;
}
else
{
Evas_Object * n ;
double degree ;
double weight ;
if ( dir = = ELM_FOCUS_UP ) degree = 0.0 ;
else if ( dir = = ELM_FOCUS_DOWN ) degree = 180.0 ;
else if ( dir = = ELM_FOCUS_RIGHT ) degree = 90.0 ;
else if ( dir = = ELM_FOCUS_LEFT ) degree = 270.0 ;
if ( elm_widget_focus_list_direction_get ( obj , focused_object ,
items , list_data_get ,
degree , & n , & weight ) )
{
* next = n ;
if ( ret ) * ret = EINA_TRUE ;
return ;
}
}
}
}
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 ;
}
2013-03-22 17:36:21 -07:00
else if ( ( dir = = ELM_FOCUS_NEXT )
| | ( dir = = ELM_FOCUS_UP )
| | ( dir = = ELM_FOCUS_DOWN )
| | ( dir = = ELM_FOCUS_RIGHT )
| | ( dir = = ELM_FOCUS_LEFT ) )
2011-08-06 00:39:31 -07:00
list_next = eina_list_next ;
2010-09-24 07:47:59 -07:00
else
2012-11-25 22:32:53 -08:00
return ;
2010-10-06 13:24:09 -07:00
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 */
2013-01-28 03:13:18 -08:00
if ( ELM_WIDGET_FOCUS_GET ( obj ) )
2012-11-08 01:10:13 -08:00
{
for ( ; l ; l = list_next ( l ) )
{
Evas_Object * cur = list_data_get ( l ) ;
2013-01-28 03:13:18 -08:00
if ( ELM_WIDGET_FOCUS_GET ( cur ) ) break ;
2012-11-08 01:10:13 -08:00
}
/* Focused object, but no focused sub item */
if ( ! l ) l = items ;
}
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
2013-05-07 03:39:58 -07:00
/* Iterate sub items */
/* Go to the end of list */
2011-08-06 00:39:31 -07:00
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
2014-01-14 05:47:54 -08:00
if ( ! cur ) continue ;
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 ;
2012-11-25 22:32:53 -08:00
if ( ret ) * ret = EINA_TRUE ;
return ;
2011-08-05 01:25:07 -07:00
}
2013-03-22 17:36:21 -07:00
else if ( ( dir = = ELM_FOCUS_UP )
| | ( dir = = ELM_FOCUS_DOWN )
| | ( dir = = ELM_FOCUS_RIGHT )
| | ( dir = = ELM_FOCUS_LEFT ) )
{
if ( tmp & & elm_widget_focus_get ( cur ) )
{
* next = tmp ;
return ;
}
}
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 ;
2012-11-25 22:32:53 -08:00
return ;
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 ;
2012-11-25 22:32:53 -08:00
return ;
2010-09-24 07:47:59 -07:00
}
2013-03-22 17:36:21 -07:00
/**
* @ internal
*
* Get next object which was set with specific focus direction .
*
* Get next object which was set by elm_widget_focus_next_object_set
* with specific focus directioin .
*
* @ param obj The widget
* @ param dir Direction of focus
* @ return Widget which was registered with sepecific focus direction .
*
* @ ingroup Widget
*/
EAPI Evas_Object *
elm_widget_focus_next_object_get ( const Evas_Object * obj , Elm_Focus_Direction dir )
{
ELM_WIDGET_CHECK ( obj ) NULL ;
Evas_Object * ret = NULL ;
eo_do ( ( Eo * ) obj , elm_wdg_focus_next_object_get ( dir , & ret ) ) ;
return ret ;
}
static void
_elm_widget_focus_next_object_get ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
Elm_Focus_Direction dir = va_arg ( * list , Elm_Focus_Direction ) ;
Evas_Object * * ret = va_arg ( * list , Evas_Object * * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
if ( dir = = ELM_FOCUS_PREVIOUS )
* ret = sd - > focus_previous ;
else if ( dir = = ELM_FOCUS_NEXT )
* ret = sd - > focus_next ;
else if ( dir = = ELM_FOCUS_UP )
* ret = sd - > focus_up ;
else if ( dir = = ELM_FOCUS_DOWN )
* ret = sd - > focus_down ;
else if ( dir = = ELM_FOCUS_RIGHT )
* ret = sd - > focus_right ;
else if ( dir = = ELM_FOCUS_LEFT )
* ret = sd - > focus_left ;
}
/**
* @ internal
*
* Set next object with specific focus direction .
*
* When a widget is set with specific focus direction , this widget will be
* the first candidate when finding the next focus object .
* Focus next object can be registered with six directions that are previous ,
* next , up , down , right , and left .
*
* @ param obj The widget
* @ param next Next focus object
* @ param dir Direction of focus
*
* @ ingroup Widget
*/
EAPI void
elm_widget_focus_next_object_set ( Evas_Object * obj , Evas_Object * next , Elm_Focus_Direction dir )
{
ELM_WIDGET_CHECK ( obj ) ;
if ( ! next ) return ;
eo_do ( ( Eo * ) obj , elm_wdg_focus_next_object_set ( next , dir ) ) ;
}
static void
_elm_widget_focus_next_object_set ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
Evas_Object * next = va_arg ( * list , Evas_Object * ) ;
Elm_Focus_Direction dir = va_arg ( * list , Elm_Focus_Direction ) ;
Elm_Widget_Smart_Data * sd = _pd ;
if ( dir = = ELM_FOCUS_PREVIOUS )
sd - > focus_previous = next ;
else if ( dir = = ELM_FOCUS_NEXT )
sd - > focus_next = next ;
else if ( dir = = ELM_FOCUS_UP )
sd - > focus_up = next ;
else if ( dir = = ELM_FOCUS_DOWN )
sd - > focus_down = next ;
else if ( dir = = ELM_FOCUS_RIGHT )
sd - > focus_right = next ;
else if ( dir = = ELM_FOCUS_LEFT )
sd - > focus_left = next ;
}
2013-01-28 03:13:18 -08:00
EAPI void
elm_widget_parent_highlight_set ( Evas_Object * obj ,
Eina_Bool highlighted )
{
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_parent_highlight_set ( highlighted ) ) ;
}
static void
_elm_widget_parent_highlight_set ( Eo * obj , void * _pd , va_list * list )
{
Eina_Bool highlighted = va_arg ( * list , int ) ;
Elm_Widget_Smart_Data * sd = _pd ;
highlighted = ! ! highlighted ;
Evas_Object * o = elm_widget_parent_get ( obj ) ;
if ( o ) elm_widget_parent_highlight_set ( o , highlighted ) ;
sd - > highlighted = highlighted ;
}
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 ,
2012-08-30 09:47:10 -07:00
const char * emission ,
const char * source )
2010-06-15 07:11:13 -07:00
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_signal_emit ( emission , source ) ) ;
}
[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-11-25 22:32:53 -08:00
static void
_elm_widget_signal_emit ( Eo * obj , void * _pd EINA_UNUSED , va_list * list )
{
const char * emission = va_arg ( * list , const char * ) ;
const char * source = va_arg ( * list , const char * ) ;
2012-08-30 09:46:59 -07:00
if ( evas_object_smart_type_check ( obj , " elm_layout " ) )
2012-05-03 15:41:26 -07:00
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-06-25 15:38:32 -07:00
EAPI void
2012-08-30 09:47:10 -07:00
elm_widget_signal_callback_add ( Evas_Object * obj ,
const char * emission ,
const char * source ,
2011-04-02 23:43:17 -07:00
Edje_Signal_Cb func ,
2012-08-30 09:47:10 -07:00
void * data )
2010-06-25 15:38:32 -07:00
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
EINA_SAFETY_ON_NULL_RETURN ( func ) ;
eo_do ( obj , elm_wdg_signal_callback_add ( emission , source , func , 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
2012-11-25 22:32:53 -08:00
static void
_elm_widget_signal_callback_add ( Eo * obj , void * _pd EINA_UNUSED , va_list * list )
{
const char * emission = va_arg ( * list , const char * ) ;
const char * source = va_arg ( * list , const char * ) ;
Edje_Signal_Cb func = va_arg ( * list , Edje_Signal_Cb ) ;
2010-12-03 06:08:33 -08:00
EINA_SAFETY_ON_NULL_RETURN ( func ) ;
2012-11-25 22:32:53 -08:00
void * data = va_arg ( * list , void * ) ;
2010-10-29 11:21:58 -07:00
2012-08-30 09:46:59 -07:00
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-30 09:47:10 -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
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) NULL ;
void * ret = NULL ;
eo_do ( obj , elm_wdg_signal_callback_del ( emission , source , func , & ret ) ) ;
return ret ;
}
2012-05-25 12:53:59 -07:00
2012-11-25 22:32:53 -08:00
static void
_elm_widget_signal_callback_del ( Eo * obj , void * _pd EINA_UNUSED , va_list * list )
{
const char * emission = va_arg ( * list , const char * ) ;
const char * source = va_arg ( * list , const char * ) ;
Edje_Signal_Cb func = va_arg ( * list , Edje_Signal_Cb ) ;
void * * ret = va_arg ( * list , void * * ) ;
if ( ret ) * ret = NULL ;
void * data = NULL ;
2012-05-03 15:41:26 -07:00
2012-08-30 09:46:59 -07:00
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
2012-11-25 22:32:53 -08:00
if ( ret ) * ret = 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 ,
2013-12-31 01:14:41 -08:00
Eina_Bool focus )
2008-10-06 18:23:49 -07:00
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
2013-12-31 01:14:41 -08:00
eo_do ( obj , elm_wdg_focus_set ( focus ) ) ;
2012-11-25 22:32:53 -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
2012-11-25 22:32:53 -08:00
static void
_elm_widget_focus_set ( Eo * obj , void * _pd , va_list * list )
{
2013-12-31 01:14:41 -08:00
Eina_Bool focus = va_arg ( * list , int ) ;
2012-11-25 22:32:53 -08:00
Elm_Widget_Smart_Data * sd = _pd ;
2012-08-30 09:46:59 -07:00
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-11-25 22:32:53 -08:00
eo_do ( obj , elm_wdg_on_focus ( NULL ) ) ;
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
2013-12-31 01:14:41 -08:00
if ( focus )
2008-10-06 18:23:49 -07:00
{
2012-08-30 09:46:59 -07:00
if ( ( _is_focusable ( sd - > resize_obj ) ) & &
( ! elm_widget_disabled_get ( sd - > resize_obj ) ) )
2011-04-01 04:20:18 -07:00
{
2013-12-31 01:14:41 -08:00
elm_widget_focus_set ( sd - > resize_obj , focus ) ;
2011-04-01 04:20:18 -07:00
}
else
{
const Eina_List * l ;
Evas_Object * child ;
2012-08-30 09:46:59 -07:00
2012-10-01 00:36:27 -07:00
EINA_LIST_FOREACH ( sd - > subobjs , l , child )
2011-04-01 04:20:18 -07:00
{
if ( ( _is_focusable ( child ) ) & &
( ! elm_widget_disabled_get ( child ) ) )
{
2013-12-31 01:14:41 -08:00
elm_widget_focus_set ( child , focus ) ;
2011-04-01 04:20:18 -07:00
break ;
}
}
2012-08-30 09:46:59 -07:00
}
}
else
{
const Eina_List * l ;
Evas_Object * child ;
2012-10-01 00:36:27 -07:00
EINA_LIST_REVERSE_FOREACH ( sd - > subobjs , l , child )
2012-08-30 09:46:59 -07:00
{
if ( ( _is_focusable ( child ) ) & &
( ! elm_widget_disabled_get ( child ) ) )
2011-04-01 04:20:18 -07:00
{
2013-12-31 01:14:41 -08:00
elm_widget_focus_set ( child , focus ) ;
2012-08-30 09:46:59 -07:00
break ;
}
}
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
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) NULL ;
Evas_Object * ret = NULL ;
eo_do ( ( Eo * ) obj , elm_wdg_parent_get ( & ret ) ) ;
return ret ;
}
static void
_elm_widget_parent_get ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
Evas_Object * * ret = va_arg ( * list , Evas_Object * * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
* ret = sd - > parent_obj ;
2008-10-06 18:23:49 -07:00
}
EAPI void
elm_widget_focused_object_clear ( Evas_Object * obj )
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_focused_object_clear ( ) ) ;
}
[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-11-25 22:32:53 -08:00
static void
_elm_widget_focused_object_clear ( Eo * obj , void * _pd , va_list * list EINA_UNUSED )
{
Elm_Widget_Smart_Data * sd = _pd ;
2012-08-30 09:47:10 -07:00
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 ) )
2012-11-25 22:32:53 -08:00
eo_do ( sd - > resize_obj , elm_wdg_focused_object_clear ( ) ) ;
2008-12-30 08:19:46 -08:00
else
{
2011-04-01 04:20:18 -07:00
const Eina_List * l ;
Evas_Object * child ;
2012-10-01 00:36:27 -07:00
EINA_LIST_FOREACH ( sd - > subobjs , l , child )
2011-04-01 04:20:18 -07:00
{
if ( elm_widget_focus_get ( child ) )
{
2012-11-25 22:32:53 -08:00
eo_do ( child , elm_wdg_focused_object_clear ( ) ) ;
2011-04-01 04:20:18 -07:00
break ;
}
}
2008-10-06 18:23:49 -07:00
}
2010-09-27 21:28:14 -07:00
sd - > focused = EINA_FALSE ;
2012-11-25 22:32:53 -08:00
eo_do ( obj , elm_wdg_on_focus ( NULL ) ) ;
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 )
2012-11-25 22:32:53 -08:00
{
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_focus_steal ( ) ) ;
}
static void
_elm_widget_focus_steal ( Eo * obj , void * _pd , va_list * list EINA_UNUSED )
2008-10-06 18:23:49 -07:00
{
2011-08-02 03:34:30 -07:00
Evas_Object * parent , * parent2 , * o ;
2012-11-25 22:32:53 -08:00
Elm_Widget_Smart_Data * sd = _pd ;
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 ;
2013-05-08 05:08:44 -07:00
parent = obj ;
2012-08-30 09:47:10 -07:00
for ( ; ; )
2008-10-06 18:23:49 -07:00
{
2013-05-08 05:08:44 -07:00
o = elm_widget_parent_get ( parent ) ;
if ( ! o ) break ;
2013-04-24 04:41:37 -07:00
sd = eo_data_scope_get ( o , MY_CLASS ) ;
2011-07-27 23:58:29 -07:00
if ( sd - > disabled | | sd - > tree_unfocusable ) return ;
2013-05-08 05:08:44 -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 ) ) )
2012-11-25 22:32:53 -08:00
eo_do ( parent , elm_wdg_focused_object_clear ( ) ) ;
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 ;
2013-04-24 04:41:37 -07:00
sd = eo_data_scope_get ( parent , MY_CLASS ) ;
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 ) ) )
2012-11-25 22:32:53 -08:00
eo_do ( sd - > resize_obj , elm_wdg_focused_object_clear ( ) ) ;
2011-08-02 03:34:30 -07:00
else
2011-04-01 04:20:18 -07:00
{
2011-08-02 03:34:30 -07:00
const Eina_List * l ;
Evas_Object * child ;
2012-10-01 00:36:27 -07:00
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 ) )
{
2012-11-25 22:32:53 -08:00
eo_do ( child , elm_wdg_focused_object_clear ( ) ) ;
2011-08-02 03:34:30 -07:00
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 )
2012-11-25 22:32:53 -08:00
{
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_focus_restore ( ) ) ;
}
static void
_elm_widget_focus_restore ( Eo * obj , void * _pd EINA_UNUSED , va_list * list EINA_UNUSED )
2011-08-09 01:36:02 -07:00
{
Evas_Object * newest = NULL ;
unsigned int newest_focus_order = 0 ;
2013-03-07 23:23:34 -08:00
newest = elm_widget_newest_focus_order_get ( obj , & newest_focus_order , EINA_TRUE ) ;
2011-08-09 01:36:02 -07:00
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
2012-08-30 09:47:10 -07:00
_elm_widget_top_win_focused_set ( Evas_Object * obj ,
Eina_Bool top_win_focused )
2011-09-06 23:15:55 -07:00
{
const Eina_List * l ;
Evas_Object * child ;
API_ENTRY return ;
if ( sd - > top_win_focused = = top_win_focused ) return ;
2012-10-01 00:36:27 -07:00
EINA_LIST_FOREACH ( sd - > subobjs , l , child )
2013-02-16 05:39:59 -08:00
_elm_widget_top_win_focused_set ( child , top_win_focused ) ;
2011-09-06 23:15:55 -07:00
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
2011-04-02 23:43:17 -07:00
elm_widget_disabled_set ( Evas_Object * obj ,
2012-08-30 09:47:10 -07:00
Eina_Bool disabled )
2008-10-06 18:23:49 -07:00
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_disabled_set ( disabled ) ) ;
}
2009-10-17 23:03:03 -07:00
2012-11-25 22:32:53 -08:00
static void
_elm_widget_disabled_set ( Eo * obj , void * _pd , va_list * list )
{
Eina_Bool disabled = va_arg ( * list , int ) ;
Elm_Widget_Smart_Data * sd = _pd ;
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-11-25 22:32:53 -08:00
eo_do ( obj , elm_wdg_disable ( NULL ) ) ;
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
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) EINA_FALSE ;
Eina_Bool ret = EINA_FALSE ;
eo_do ( ( Eo * ) obj , elm_wdg_disabled_get ( & ret ) ) ;
return ret ;
}
static void
_elm_widget_disabled_get ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
Eina_Bool * ret = va_arg ( * list , Eina_Bool * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
* ret = sd - > disabled ;
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_show_region_set ( Evas_Object * obj ,
2012-08-30 09:47:10 -07:00
Evas_Coord x ,
Evas_Coord y ,
Evas_Coord w ,
Evas_Coord h ,
Eina_Bool forceshow )
2008-10-17 07:40:54 -07:00
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_show_region_set ( x , y , w , h , forceshow ) ) ;
}
static void
_elm_widget_show_region_set ( Eo * obj , void * _pd , va_list * list )
{
Evas_Coord x = va_arg ( * list , Evas_Coord ) ;
Evas_Coord y = va_arg ( * list , Evas_Coord ) ;
Evas_Coord w = va_arg ( * list , Evas_Coord ) ;
Evas_Coord h = va_arg ( * list , Evas_Coord ) ;
Eina_Bool forceshow = va_arg ( * list , int ) ;
2010-12-16 01:53:25 -08:00
Evas_Object * parent_obj , * child_obj ;
2013-04-23 01:01:25 -07:00
Evas_Coord px , py , cx , cy , nx , ny ;
2010-12-16 01:53:25 -08:00
2012-11-25 22:32:53 -08:00
Elm_Widget_Smart_Data * sd = _pd ;
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 )
2013-04-23 01:01:25 -07:00
{
sd - > on_show_region
( sd - > on_show_region_data , obj ) ;
2013-04-23 03:23:16 -07:00
if ( _elm_scrollable_is ( obj ) )
{
eo_do ( obj , elm_scrollable_interface_content_pos_get ( & nx , & ny ) ) ;
x - = nx ;
y - = ny ;
}
2013-04-23 01:01:25 -07:00
}
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 ;
2013-04-24 04:41:37 -07:00
sd = eo_data_scope_get ( parent_obj , MY_CLASS ) ;
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 ,
2012-08-30 09:47:10 -07:00
Evas_Coord * x ,
Evas_Coord * y ,
Evas_Coord * w ,
Evas_Coord * h )
2008-10-17 07:40:54 -07:00
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( ( Eo * ) obj , elm_wdg_show_region_get ( x , y , w , h ) ) ;
}
static void
_elm_widget_show_region_get ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
Evas_Coord * x = va_arg ( * list , Evas_Coord * ) ;
Evas_Coord * y = va_arg ( * list , Evas_Coord * ) ;
Evas_Coord * w = va_arg ( * list , Evas_Coord * ) ;
Evas_Coord * h = va_arg ( * list , Evas_Coord * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
2008-10-17 07:40:54 -07:00
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 .
*
2012-10-17 03:09:52 -07:00
* @ return show region or not
* ( @ c EINA_TRUE = show region / @ c EINA_FALSE = do not show region ) . Default is @ c EINA_FALSE .
*
2010-10-22 11:29:51 -07:00
* 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 .
*
* @ 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
*/
2012-10-17 03:09:52 -07:00
EAPI Eina_Bool
2011-04-02 23:43:17 -07:00
elm_widget_focus_region_get ( const Evas_Object * obj ,
2012-08-30 09:47:10 -07:00
Evas_Coord * x ,
Evas_Coord * y ,
Evas_Coord * w ,
Evas_Coord * h )
2010-10-22 11:29:51 -07:00
{
2013-01-25 22:53:10 -08:00
ELM_WIDGET_CHECK ( obj ) EINA_FALSE ;
Eina_Bool ret = EINA_FALSE ;
eo_do ( ( Eo * ) obj , elm_wdg_focus_region_get ( x , y , w , h , & ret ) ) ;
if ( ! ret )
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 ;
}
2013-01-25 22:53:10 -08:00
return EINA_TRUE ;
2012-11-25 22:32:53 -08:00
}
static void
_elm_widget_focus_region_get ( Eo * obj , void * _pd EINA_UNUSED , va_list * list )
{
Evas_Coord * x = va_arg ( * list , Evas_Coord * ) ;
Evas_Coord * y = va_arg ( * list , Evas_Coord * ) ;
Evas_Coord * w = va_arg ( * list , Evas_Coord * ) ;
Evas_Coord * h = va_arg ( * list , Evas_Coord * ) ;
Eina_Bool * ret = va_arg ( * list , Eina_Bool * ) ;
2012-08-30 09:47:16 -07:00
2012-11-25 22:32:53 -08:00
Eina_Bool int_ret = EINA_FALSE ;
eo_do ( ( Eo * ) obj , elm_wdg_on_focus_region ( x , y , w , h , & int_ret ) ) ;
* ret = int_ret ;
2010-10-22 11:29:51 -07:00
}
2013-06-18 00:28:06 -07:00
EAPI void
elm_widget_parents_bounce_get ( Evas_Object * obj ,
Eina_Bool * horiz , Eina_Bool * vert )
{
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( ( Eo * ) obj , elm_wdg_parents_bounce_get ( horiz , vert ) ) ;
}
static void
_elm_widget_parents_bounce_get ( Eo * obj , void * _pd EINA_UNUSED , va_list * list )
{
Eina_Bool * horiz = va_arg ( * list , Eina_Bool * ) ;
Eina_Bool * vert = va_arg ( * list , Eina_Bool * ) ;
Evas_Object * parent_obj = obj ;
Eina_Bool h , v ;
* horiz = EINA_FALSE ;
* vert = EINA_FALSE ;
do
{
parent_obj = elm_widget_parent_get ( parent_obj ) ;
if ( ( ! parent_obj ) | | ( ! _elm_widget_is ( parent_obj ) ) ) break ;
if ( _elm_scrollable_is ( parent_obj ) )
{
eo_do ( parent_obj , elm_scrollable_interface_bounce_allow_get ( & h , & v ) ) ;
if ( h ) * horiz = EINA_TRUE ;
if ( v ) * vert = EINA_TRUE ;
}
}
while ( parent_obj ) ;
}
2012-08-30 09:45:34 -07:00
EAPI Eina_List *
elm_widget_scrollable_children_get ( Evas_Object * obj )
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) NULL ;
Eina_List * ret = NULL ;
eo_do ( obj , elm_wdg_scrollable_children_get ( & ret ) ) ;
return ret ;
}
static void
_elm_widget_scrollable_children_get ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
Eina_List * * ret = va_arg ( * list , Eina_List * * ) ;
* ret = NULL ;
Eina_List * l ;
2012-08-30 09:45:34 -07:00
Evas_Object * child ;
2012-11-25 22:32:53 -08:00
Elm_Widget_Smart_Data * sd = _pd ;
2012-08-30 09:45:34 -07:00
2012-10-01 00:36:27 -07:00
EINA_LIST_FOREACH ( sd - > subobjs , l , child )
2012-08-30 09:45:34 -07:00
{
if ( _elm_scrollable_is ( child ) )
2012-11-25 22:32:53 -08:00
* ret = eina_list_append ( * ret , child ) ;
2012-08-30 09:45:34 -07:00
}
}
2008-11-18 02:11:57 -08:00
EAPI void
elm_widget_scroll_hold_push ( Evas_Object * obj )
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_scroll_hold_push ( ) ) ;
}
static void
_elm_widget_scroll_hold_push ( Eo * obj , void * _pd , va_list * list EINA_UNUSED )
{
Elm_Widget_Smart_Data * sd = _pd ;
2008-11-18 02:11:57 -08:00
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 ) )
2012-11-25 22:32:53 -08:00
eo_do ( obj , elm_scrollable_interface_hold_set ( EINA_TRUE ) ) ;
2012-08-30 09:45:34 -07:00
else
{
Eina_List * scr_children , * l ;
Evas_Object * child ;
scr_children = elm_widget_scrollable_children_get ( obj ) ;
2012-10-01 00:36:27 -07:00
EINA_LIST_FOREACH ( scr_children , l , child )
2012-08-30 09:45:34 -07:00
{
2012-11-25 22:32:53 -08:00
eo_do ( child , elm_scrollable_interface_hold_set ( EINA_TRUE ) ) ;
2012-08-30 09:45:34 -07:00
}
eina_list_free ( scr_children ) ;
}
2012-07-04 14:41:01 -07:00
}
2012-11-25 22:32:53 -08:00
if ( sd - > parent_obj ) eo_do ( sd - > parent_obj , elm_wdg_scroll_hold_push ( ) ) ;
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 )
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_scroll_hold_pop ( ) ) ;
}
static void
_elm_widget_scroll_hold_pop ( Eo * obj , void * _pd , va_list * list EINA_UNUSED )
{
Elm_Widget_Smart_Data * sd = _pd ;
2008-11-18 02:11:57 -08:00
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 ) )
2012-11-25 22:32:53 -08:00
eo_do ( obj , elm_scrollable_interface_hold_set ( EINA_FALSE ) ) ;
2012-08-30 09:45:34 -07:00
else
{
Eina_List * scr_children , * l ;
Evas_Object * child ;
scr_children = elm_widget_scrollable_children_get ( obj ) ;
2012-10-01 00:36:27 -07:00
EINA_LIST_FOREACH ( scr_children , l , child )
2012-08-30 09:45:34 -07:00
{
2012-11-25 22:32:53 -08:00
eo_do ( child , elm_scrollable_interface_hold_set ( EINA_FALSE ) ) ;
2012-08-30 09:45:34 -07:00
}
eina_list_free ( scr_children ) ;
}
2012-07-04 14:41:01 -07:00
}
2012-11-25 22:32:53 -08:00
if ( sd - > parent_obj ) eo_do ( sd - > parent_obj , elm_wdg_scroll_hold_pop ( ) ) ;
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
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) 0 ;
int ret = 0 ;
eo_do ( ( Eo * ) obj , elm_wdg_scroll_hold_get ( & ret ) ) ;
return ret ;
}
static void
_elm_widget_scroll_hold_get ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
int * ret = va_arg ( * list , int * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
* ret = sd - > scroll_hold ;
2008-11-18 02:11:57 -08:00
}
2009-03-20 08:08:33 -07:00
EAPI void
elm_widget_scroll_freeze_push ( Evas_Object * obj )
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_scroll_freeze_push ( ) ) ;
}
static void
_elm_widget_scroll_freeze_push ( Eo * obj , void * _pd , va_list * list EINA_UNUSED )
{
Elm_Widget_Smart_Data * sd = _pd ;
2009-03-20 08:08:33 -07:00
sd - > scroll_freeze + + ;
if ( sd - > scroll_freeze = = 1 )
2012-07-04 14:41:01 -07:00
{
if ( _elm_scrollable_is ( obj ) )
2012-11-25 22:32:53 -08:00
eo_do ( obj , elm_scrollable_interface_freeze_set ( EINA_TRUE ) ) ;
2012-08-30 09:45:34 -07:00
else
{
Eina_List * scr_children , * l ;
Evas_Object * child ;
scr_children = elm_widget_scrollable_children_get ( obj ) ;
2012-10-01 00:36:27 -07:00
EINA_LIST_FOREACH ( scr_children , l , child )
2012-08-30 09:45:34 -07:00
{
2012-11-25 22:32:53 -08:00
eo_do ( child , elm_scrollable_interface_freeze_set ( EINA_TRUE ) ) ;
2012-08-30 09:45:34 -07:00
}
eina_list_free ( scr_children ) ;
}
2012-07-04 14:41:01 -07:00
}
2012-11-25 22:32:53 -08:00
if ( sd - > parent_obj ) eo_do ( sd - > parent_obj , elm_wdg_scroll_freeze_push ( ) ) ;
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 )
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_scroll_freeze_pop ( ) ) ;
}
static void
_elm_widget_scroll_freeze_pop ( Eo * obj , void * _pd , va_list * list EINA_UNUSED )
{
Elm_Widget_Smart_Data * sd = _pd ;
2009-03-20 08:08:33 -07:00
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 ) )
2012-11-25 22:32:53 -08:00
eo_do ( obj , elm_scrollable_interface_freeze_set ( EINA_FALSE ) ) ;
2012-08-30 09:45:34 -07:00
else
{
Eina_List * scr_children , * l ;
Evas_Object * child ;
scr_children = elm_widget_scrollable_children_get ( obj ) ;
2012-10-01 00:36:27 -07:00
EINA_LIST_FOREACH ( scr_children , l , child )
2012-08-30 09:45:34 -07:00
{
2012-11-25 22:32:53 -08:00
eo_do ( child , elm_scrollable_interface_freeze_set ( EINA_FALSE ) ) ;
2012-08-30 09:45:34 -07:00
}
eina_list_free ( scr_children ) ;
}
2012-07-04 14:41:01 -07:00
}
2012-11-25 22:32:53 -08:00
if ( sd - > parent_obj ) eo_do ( sd - > parent_obj , elm_wdg_scroll_freeze_pop ( ) ) ;
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
}
2012-11-25 22:32:53 -08:00
EAPI int
elm_widget_scroll_freeze_get ( const Evas_Object * obj )
{
ELM_WIDGET_CHECK ( obj ) 0 ;
int ret = 0 ;
eo_do ( ( Eo * ) obj , elm_wdg_scroll_freeze_get ( & ret ) ) ;
return ret ;
}
static void
_elm_widget_scroll_freeze_get ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
2009-03-20 08:08:33 -07:00
{
2012-11-25 22:32:53 -08:00
int * ret = va_arg ( * list , int * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
* ret = sd - > scroll_freeze ;
2009-03-20 08:08:33 -07:00
}
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 ,
2012-08-30 09:47:10 -07:00
double scale )
2009-02-02 21:09:03 -08:00
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_scale_set ( scale ) ) ;
}
static void
_elm_widget_scale_set ( Eo * obj , void * _pd , va_list * list )
{
double scale = va_arg ( * list , double ) ;
Elm_Widget_Smart_Data * sd = _pd ;
2009-02-02 21:09:03 -08:00
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
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) 1.0 ;
double ret = 1.0 ;
eo_do ( ( Eo * ) obj , elm_wdg_scale_get ( & ret ) ) ;
return ret ;
}
static void
_elm_widget_scale_get ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
double * ret = va_arg ( * list , double * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
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 )
2012-11-25 22:32:53 -08:00
{
* ret = elm_widget_scale_get ( sd - > parent_obj ) ;
return ;
}
2011-04-01 04:20:18 -07:00
else
2012-11-25 22:32:53 -08:00
{
* ret = 1.0 ;
return ;
}
2009-06-12 15:55:06 -07:00
}
2012-11-25 22:32:53 -08:00
* ret = sd - > scale ;
2009-02-02 21:09:03 -08:00
}
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 ,
2012-08-30 09:47:10 -07:00
Elm_Theme * th )
2010-05-11 18:03:46 -07:00
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_theme_set ( th ) ) ;
}
static void
_elm_widget_theme_set ( Eo * obj , void * _pd , va_list * list )
{
Elm_Theme * th = va_arg ( * list , Elm_Theme * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
2013-08-22 01:00:36 -07:00
Eina_Bool apply = EINA_FALSE ;
2010-05-11 18:03:46 -07:00
if ( sd - > theme ! = th )
{
2013-08-22 01:00:36 -07:00
if ( elm_widget_theme_get ( obj ) ! = th ) apply = EINA_TRUE ;
2010-05-11 18:03:46 -07:00
if ( sd - > theme ) elm_theme_free ( sd - > theme ) ;
sd - > theme = th ;
if ( th ) th - > ref + + ;
2013-08-22 01:00:36 -07:00
if ( apply ) elm_widget_theme ( obj ) ;
2010-05-11 18:03:46 -07:00
}
}
2011-06-28 23:40:59 -07:00
EAPI void
2013-02-13 03:02:36 -08:00
elm_widget_part_text_set ( Evas_Object * obj ,
2012-08-30 09:47:10 -07:00
const char * part ,
const char * label )
2011-06-28 23:40:59 -07:00
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
2013-02-13 03:02:36 -08:00
eo_do ( obj , elm_wdg_part_text_set ( part , label ) ) ;
2012-11-25 22:32:53 -08:00
}
2011-06-28 23:40:59 -07:00
2012-11-25 22:32:53 -08:00
static void
2013-02-13 03:02:36 -08:00
_elm_widget_part_text_set ( Eo * obj , void * _pd EINA_UNUSED , va_list * list )
2012-11-25 22:32:53 -08:00
{
const char * part = va_arg ( * list , const char * ) ;
const char * label = va_arg ( * list , const char * ) ;
2012-08-30 09:46:59 -07:00
if ( evas_object_smart_type_check ( obj , " elm_layout " ) )
2012-05-03 15:41:26 -07:00
elm_layout_text_set ( obj , part , label ) ;
2011-06-28 23:40:59 -07:00
}
EAPI const char *
2013-02-13 03:02:36 -08:00
elm_widget_part_text_get ( const Evas_Object * obj ,
2012-08-30 09:47:10 -07:00
const char * part )
2011-06-28 23:40:59 -07:00
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) NULL ;
const char * ret = NULL ;
2013-02-13 03:02:36 -08:00
eo_do ( ( Eo * ) obj , elm_wdg_part_text_get ( part , & ret ) ) ;
2012-11-25 22:32:53 -08:00
return ret ;
}
2011-06-28 23:40:59 -07:00
2012-11-25 22:32:53 -08:00
static void
2013-02-13 03:02:36 -08:00
_elm_widget_part_text_get ( Eo * obj , void * _pd EINA_UNUSED , va_list * list )
2012-11-25 22:32:53 -08:00
{
const char * part = va_arg ( * list , const char * ) ;
const char * * ret = va_arg ( * list , const char * * ) ;
2012-08-30 09:46:59 -07:00
if ( evas_object_smart_type_check ( obj , " elm_layout " ) )
2012-11-25 22:32:53 -08:00
* ret = elm_layout_text_get ( obj , part ) ;
2011-06-28 23:40:59 -07:00
}
2011-10-19 07:17:14 -07:00
EAPI void
2013-02-12 03:43:39 -08:00
elm_widget_domain_translatable_part_text_set ( Evas_Object * obj ,
2012-08-30 09:47:10 -07:00
const char * part ,
const char * domain ,
const char * label )
2011-10-19 07:17:14 -07:00
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
2013-02-12 03:43:39 -08:00
eo_do ( obj , elm_wdg_domain_translatable_part_text_set ( part , domain , label ) ) ;
2012-11-25 22:32:53 -08:00
}
2013-04-23 00:49:49 -07:00
static Elm_Translate_String_Data *
2013-07-16 23:05:40 -07:00
_translate_string_data_get ( Eina_Inlist * translate_strings , const char * part )
2012-11-25 22:32:53 -08:00
{
2013-04-23 00:49:49 -07:00
Elm_Translate_String_Data * ts ;
Eina_Stringshare * str ;
2013-07-16 23:05:40 -07:00
if ( ! translate_strings ) return NULL ;
2011-10-19 07:17:14 -07:00
str = eina_stringshare_add ( part ) ;
2013-07-16 23:05:40 -07:00
EINA_INLIST_FOREACH ( translate_strings , ts )
2013-02-12 05:00:37 -08:00
{
if ( ts - > id = = str ) break ;
}
2013-07-23 21:02:39 -07:00
2013-04-23 00:49:49 -07:00
eina_stringshare_del ( str ) ;
2011-10-19 07:17:14 -07:00
2013-04-23 00:49:49 -07:00
return ts ;
}
2011-10-19 07:17:14 -07:00
2013-04-23 00:49:49 -07:00
static Elm_Translate_String_Data *
2013-07-16 23:05:40 -07:00
_part_text_translatable_set ( Eina_Inlist * * translate_strings , const char * part , Eina_Bool translatable , Eina_Bool preset )
2013-04-23 00:49:49 -07:00
{
2013-07-16 23:05:40 -07:00
Eina_Inlist * t ;
2013-04-23 00:49:49 -07:00
Elm_Translate_String_Data * ts ;
t = * translate_strings ;
ts = _translate_string_data_get ( t , part ) ;
if ( translatable )
2011-10-19 07:17:14 -07:00
{
2013-04-23 00:49:49 -07:00
if ( ! ts )
2011-10-19 07:17:14 -07:00
{
2013-04-23 00:49:49 -07:00
ts = ELM_NEW ( Elm_Translate_String_Data ) ;
if ( ! ts ) return NULL ;
ts - > id = eina_stringshare_add ( part ) ;
2013-07-16 23:05:40 -07:00
t = eina_inlist_append ( t , ( Eina_Inlist * ) ts ) ;
2011-10-19 07:17:14 -07:00
}
2013-04-23 00:49:49 -07:00
if ( preset ) ts - > preset = EINA_TRUE ;
}
//Delete this exist one if this part has been not preset.
//see elm_widget_part_text_translatable_set()
else if ( ( preset ) | | ( ! ts - > preset ) )
{
if ( ts )
2011-10-19 07:17:14 -07:00
{
2013-07-16 23:05:40 -07:00
t = eina_inlist_remove ( t , EINA_INLIST_GET ( ts ) ) ;
2011-10-19 07:17:14 -07:00
eina_stringshare_del ( ts - > id ) ;
eina_stringshare_del ( ts - > domain ) ;
eina_stringshare_del ( ts - > string ) ;
2014-01-21 18:08:47 -08:00
ELM_SAFE_FREE ( ts , free ) ;
2011-10-19 07:17:14 -07:00
}
}
2013-02-12 05:00:37 -08:00
* translate_strings = t ;
2013-04-23 00:49:49 -07:00
return ts ;
2013-02-12 05:00:37 -08:00
}
static void
_elm_widget_domain_translatable_part_text_set ( Eo * obj , void * _pd , va_list * list )
{
const char * part = va_arg ( * list , const char * ) ;
const char * domain = va_arg ( * list , const char * ) ;
const char * label = va_arg ( * list , const char * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
2013-04-23 00:49:49 -07:00
Elm_Translate_String_Data * ts ;
2013-02-12 05:00:37 -08:00
2013-04-23 00:49:49 -07:00
if ( ! label )
{
_part_text_translatable_set ( & sd - > translate_strings , part , EINA_FALSE ,
EINA_FALSE ) ;
}
else
{
ts = _part_text_translatable_set ( & sd - > translate_strings , part ,
EINA_TRUE , EINA_FALSE ) ;
if ( ! ts ) return ;
if ( ! ts - > string ) ts - > string = eina_stringshare_add ( label ) ;
else eina_stringshare_replace ( & ts - > string , label ) ;
if ( ! ts - > domain ) ts - > domain = eina_stringshare_add ( domain ) ;
else eina_stringshare_replace ( & ts - > domain , domain ) ;
2011-10-19 07:17:14 -07:00
# ifdef HAVE_GETTEXT
2013-04-23 00:49:49 -07:00
if ( label [ 0 ] ) label = dgettext ( domain , label ) ;
2011-10-19 07:17:14 -07:00
# endif
2013-04-23 00:49:49 -07:00
}
sd - > on_translate = EINA_TRUE ;
eo_do ( obj , elm_wdg_part_text_set ( part , label ) ) ;
sd - > on_translate = EINA_FALSE ;
2011-10-19 07:17:14 -07:00
}
EAPI const char *
2013-02-12 03:43:39 -08:00
elm_widget_translatable_part_text_get ( const Evas_Object * obj ,
2012-08-30 09:47:10 -07:00
const char * part )
2011-10-19 07:17:14 -07:00
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) NULL ;
const char * ret = NULL ;
2013-02-12 03:43:39 -08:00
eo_do ( ( Eo * ) obj , elm_wdg_translatable_part_text_get ( part , & ret ) ) ;
2012-11-25 22:32:53 -08:00
return ret ;
}
2013-04-23 00:49:49 -07:00
static void
_elm_widget_translatable_part_text_get ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
2012-11-25 22:32:53 -08:00
{
2013-04-23 00:49:49 -07:00
const char * part = va_arg ( * list , const char * ) ;
const char * * ret = va_arg ( * list , const char * * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
2011-10-19 07:17:14 -07:00
Elm_Translate_String_Data * ts ;
2013-04-23 00:49:49 -07:00
ts = _translate_string_data_get ( sd - > translate_strings , part ) ;
if ( ts ) * ret = ts - > string ;
else * ret = NULL ;
}
2013-02-12 05:00:37 -08:00
2013-04-23 00:49:49 -07:00
EAPI void
elm_widget_domain_part_text_translatable_set ( Evas_Object * obj , const char * part , const char * domain , Eina_Bool translatable )
{
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj ,
elm_wdg_domain_part_text_translatable_set ( part , domain , translatable ) ) ;
2013-02-12 05:00:37 -08:00
}
static void
2013-04-23 00:49:49 -07:00
_elm_widget_domain_part_text_translatable_set ( Eo * obj , void * _pd , va_list * list )
2013-02-12 05:00:37 -08:00
{
const char * part = va_arg ( * list , const char * ) ;
2013-04-23 00:49:49 -07:00
const char * domain = va_arg ( * list , const char * ) ;
Eina_Bool translatable = va_arg ( * list , int ) ;
2013-02-12 05:00:37 -08:00
Elm_Widget_Smart_Data * sd = _pd ;
2013-04-23 00:49:49 -07:00
Elm_Translate_String_Data * ts ;
const char * text ;
ts = _part_text_translatable_set ( & sd - > translate_strings , part ,
translatable , EINA_TRUE ) ;
if ( ! ts ) return ;
if ( ! ts - > domain ) ts - > domain = eina_stringshare_add ( domain ) ;
else eina_stringshare_replace ( & ts - > domain , domain ) ;
eo_do ( obj , elm_wdg_part_text_get ( part , & text ) ) ;
if ( ! text | | ! text [ 0 ] ) return ;
if ( ! ts - > string ) ts - > string = eina_stringshare_add ( text ) ;
//Try to translate text since we don't know the text is already translated.
# ifdef HAVE_GETTEXT
text = dgettext ( domain , text ) ;
# endif
sd - > on_translate = EINA_TRUE ;
eo_do ( obj , elm_wdg_part_text_set ( part , text ) ) ;
sd - > on_translate = EINA_FALSE ;
2011-10-19 07:17:14 -07:00
}
EAPI void
elm_widget_translate ( Evas_Object * obj )
2013-02-08 01:24:05 -08:00
{
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_translate ( NULL ) ) ;
}
2013-04-23 00:49:49 -07:00
static const char *
2013-07-16 23:05:40 -07:00
_part_text_translate ( Eina_Inlist * translate_strings ,
2013-04-23 00:49:49 -07:00
const char * part ,
const char * text )
{
Elm_Translate_String_Data * ts ;
ts = _translate_string_data_get ( translate_strings , part ) ;
if ( ! ts ) return text ;
if ( ! ts - > string ) ts - > string = eina_stringshare_add ( text ) ;
else eina_stringshare_replace ( & ts - > string , text ) ;
# ifdef HAVE_GETTEXT
if ( text & & text [ 0 ] )
text = dgettext ( ts - > domain , text ) ;
# endif
return text ;
}
EAPI const char *
elm_widget_part_text_translate ( Evas_Object * obj , const char * part , const char * text )
{
ELM_WIDGET_CHECK ( obj ) NULL ;
const char * ret ;
eo_do ( obj , elm_wdg_part_text_translate ( part , text , & ret ) ) ;
return ret ;
}
static void
_elm_widget_part_text_translate ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
const char * part = va_arg ( * list , const char * ) ;
const char * text = va_arg ( * list , const char * ) ;
const char * * ret = va_arg ( * list , const char * * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
if ( ! sd - > translate_strings | | sd - > on_translate )
{
* ret = text ;
return ;
}
* ret = _part_text_translate ( sd - > translate_strings , part , text ) ;
}
2013-02-08 01:24:05 -08:00
static void
_elm_widget_translate ( Eo * obj EINA_UNUSED , void * _pd EINA_UNUSED , va_list * list EINA_UNUSED )
2011-10-19 07:17:14 -07:00
{
const Eina_List * l ;
Evas_Object * child ;
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-10-01 00:36:27 -07:00
EINA_LIST_FOREACH ( sd - > subobjs , l , child )
2012-08-30 09:47:10 -07:00
elm_widget_translate ( child ) ;
2011-10-19 07:17:14 -07:00
if ( sd - > hover_obj ) elm_widget_translate ( sd - > hover_obj ) ;
2013-04-23 00:49:49 -07:00
2011-10-19 07:17:14 -07:00
# ifdef HAVE_GETTEXT
2013-04-23 00:49:49 -07:00
Elm_Translate_String_Data * ts ;
2013-07-16 23:05:40 -07:00
EINA_INLIST_FOREACH ( sd - > translate_strings , ts )
2011-10-19 07:17:14 -07:00
{
2013-04-23 00:49:49 -07:00
if ( ! ts - > string ) continue ;
2011-10-19 07:17:14 -07:00
const char * s = dgettext ( ts - > domain , ts - > string ) ;
2013-04-23 00:49:49 -07:00
sd - > on_translate = EINA_TRUE ;
eo_do ( obj , elm_wdg_part_text_set ( ts - > id , s ) ) ;
sd - > on_translate = EINA_FALSE ;
2011-10-19 07:17:14 -07:00
}
# endif
2014-01-23 02:30:34 -08:00
evas_object_smart_callback_call ( obj , SIG_WIDGET_LANG_CHANGED , NULL ) ;
2011-10-19 07:17:14 -07:00
}
2011-07-27 02:49:14 -07:00
EAPI void
2012-08-30 09:47:10 -07:00
elm_widget_content_part_set ( Evas_Object * obj ,
const char * part ,
Evas_Object * content )
2011-07-27 02:49:14 -07:00
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_obj_container_content_set ( part , content , NULL ) ) ;
2011-07-27 02:49:14 -07:00
}
EAPI Evas_Object *
2012-08-30 09:47:10 -07:00
elm_widget_content_part_get ( const Evas_Object * obj ,
const char * part )
2011-07-27 02:49:14 -07:00
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) NULL ;
Evas_Object * ret = NULL ;
eo_do ( ( Eo * ) obj , elm_obj_container_content_get ( part , & ret ) ) ;
return ret ;
2011-07-27 02:49:14 -07:00
}
EAPI Evas_Object *
2012-08-30 09:47:10 -07:00
elm_widget_content_part_unset ( Evas_Object * obj ,
const char * part )
2011-07-27 02:49:14 -07:00
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) NULL ;
Evas_Object * ret = NULL ;
eo_do ( obj , elm_obj_container_content_unset ( part , & ret ) ) ;
return ret ;
2011-07-27 02:49:14 -07:00
}
2011-08-19 04:47:30 -07:00
EAPI void
2012-08-30 09:47:10 -07:00
elm_widget_access_info_set ( Evas_Object * obj ,
const char * txt )
2011-08-19 04:47:30 -07:00
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_access_info_set ( txt ) ) ;
}
static void
_elm_widget_access_info_set ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
const char * txt = va_arg ( * list , const char * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
2014-01-21 17:12:44 -08:00
eina_stringshare_del ( sd - > access_info ) ;
2011-08-19 04:47:30 -07:00
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
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) NULL ;
const char * ret = NULL ;
eo_do ( ( Eo * ) obj , elm_wdg_access_info_get ( & ret ) ) ;
return ret ;
}
static void
_elm_widget_access_info_get ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
const char * * ret = va_arg ( * list , const char * * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
* ret = sd - > access_info ;
2011-08-19 04:47:30 -07:00
}
2010-05-11 18:03:46 -07:00
EAPI Elm_Theme *
elm_widget_theme_get ( const Evas_Object * obj )
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) NULL ;
Elm_Theme * ret = NULL ;
eo_do ( ( Eo * ) obj , elm_wdg_theme_get ( & ret ) ) ;
return ret ;
}
static void
_elm_widget_theme_get ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
Elm_Theme * * ret = va_arg ( * list , Elm_Theme * * ) ;
* ret = NULL ;
Elm_Widget_Smart_Data * sd = _pd ;
2010-05-11 18:03:46 -07:00
if ( ! sd - > theme )
{
if ( sd - > parent_obj )
2012-11-25 22:32:53 -08:00
{
* ret = elm_widget_theme_get ( sd - > parent_obj ) ;
return ;
}
2010-05-11 18:03:46 -07:00
else
2012-11-25 22:32:53 -08:00
return ;
2010-05-11 18:03:46 -07:00
}
2012-11-25 22:32:53 -08:00
* ret = sd - > theme ;
2010-05-11 18:03:46 -07:00
}
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 ,
2012-08-30 09:47:10 -07:00
const char * style )
2009-04-22 21:03:27 -07:00
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) EINA_FALSE ;
Eina_Bool ret = EINA_FALSE ;
eo_do ( obj , elm_wdg_style_set ( style , & ret ) ) ;
return ret ;
}
2011-03-09 23:22:22 -08:00
2012-11-25 22:32:53 -08:00
static void
_elm_widget_style_set ( Eo * obj , void * _pd , va_list * list )
{
const char * style = va_arg ( * list , const char * ) ;
Eina_Bool * ret = va_arg ( * list , Eina_Bool * ) ;
if ( ret ) * ret = EINA_FALSE ;
Eina_Bool int_ret = EINA_FALSE ;
Elm_Widget_Smart_Data * sd = _pd ;
2010-03-13 13:01:26 -08:00
if ( eina_stringshare_replace ( & sd - > style , style ) )
2012-11-25 22:32:53 -08:00
{
int_ret = elm_widget_theme ( obj ) ;
if ( ret ) * ret = int_ret ;
return ;
}
2012-03-06 10:39:53 -08:00
2012-11-25 22:32:53 -08:00
if ( ret ) * ret = EINA_TRUE ;
2009-04-22 21:03:27 -07:00
}
EAPI const char *
elm_widget_style_get ( const Evas_Object * obj )
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) NULL ;
const char * ret = " default " ;
eo_do ( ( Eo * ) obj , elm_wdg_style_get ( & ret ) ) ;
return ret ;
}
static void
_elm_widget_style_get ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
const char * * ret = va_arg ( * list , const char * * ) ;
* ret = " default " ;
Elm_Widget_Smart_Data * sd = _pd ;
if ( sd - > style ) * ret = sd - > style ;
2009-04-22 21:03:27 -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
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_tooltip_add ( tt ) ) ;
}
static void
_elm_widget_tooltip_add ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
Elm_Tooltip * tt = va_arg ( * list , Elm_Tooltip * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
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
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_tooltip_del ( tt ) ) ;
}
static void
_elm_widget_tooltip_del ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
Elm_Tooltip * tt = va_arg ( * list , Elm_Tooltip * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
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_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 ,
2012-08-30 09:47:10 -07:00
Elm_Cursor * cur )
2010-09-25 15:01:19 -07:00
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_cursor_add ( cur ) ) ;
}
static void
_elm_widget_cursor_add ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
Elm_Cursor * cur = va_arg ( * list , Elm_Cursor * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
2010-09-25 15:01:19 -07:00
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 ,
2012-08-30 09:47:10 -07:00
Elm_Cursor * cur )
2010-09-25 15:01:19 -07:00
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_cursor_del ( cur ) ) ;
}
static void
_elm_widget_cursor_del ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
Elm_Cursor * cur = va_arg ( * list , Elm_Cursor * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
2010-09-25 15:01:19 -07:00
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 ,
2012-08-30 09:47:10 -07:00
Eina_Bool lock )
2010-05-07 06:21:45 -07:00
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_drag_lock_x_set ( lock ) ) ;
}
static void
_elm_widget_drag_lock_x_set ( Eo * obj , void * _pd , va_list * list )
{
Eina_Bool lock = va_arg ( * list , int ) ;
Elm_Widget_Smart_Data * sd = _pd ;
2010-05-07 06:21:45 -07:00
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 ,
2012-08-30 09:47:10 -07:00
Eina_Bool lock )
2010-05-07 06:21:45 -07:00
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_drag_lock_y_set ( lock ) ) ;
}
static void
_elm_widget_drag_lock_y_set ( Eo * obj , void * _pd , va_list * list )
{
Eina_Bool lock = va_arg ( * list , int ) ;
Elm_Widget_Smart_Data * sd = _pd ;
2010-05-07 06:21:45 -07:00
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
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) EINA_FALSE ;
Eina_Bool ret = EINA_FALSE ;
eo_do ( ( Eo * ) obj , elm_wdg_drag_lock_x_get ( & ret ) ) ;
return ret ;
}
static void
_elm_widget_drag_lock_x_get ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
Eina_Bool * ret = va_arg ( * list , Eina_Bool * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
* ret = sd - > drag_x_locked ;
2010-05-07 06:21:45 -07:00
}
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
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) EINA_FALSE ;
Eina_Bool ret = EINA_FALSE ;
eo_do ( ( Eo * ) obj , elm_wdg_drag_lock_y_get ( & ret ) ) ;
return ret ;
}
static void
_elm_widget_drag_lock_y_get ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
Eina_Bool * ret = va_arg ( * list , Eina_Bool * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
* ret = sd - > drag_y_locked ;
2010-05-07 06:21:45 -07:00
}
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
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) 0 ;
int ret = 0 ;
eo_do ( ( Eo * ) obj , elm_wdg_drag_child_locked_x_get ( & ret ) ) ;
return ret ;
}
static void
_elm_widget_drag_child_locked_x_get ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
int * ret = va_arg ( * list , int * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
* ret = sd - > child_drag_x_locked ;
2010-05-07 06:21:45 -07:00
}
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
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) 0 ;
int ret = 0 ;
eo_do ( ( Eo * ) obj , elm_wdg_drag_child_locked_y_get ( & ret ) ) ;
return ret ;
}
static void
_elm_widget_drag_child_locked_y_get ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
int * ret = va_arg ( * list , int * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
* ret = sd - > child_drag_y_locked ;
2010-05-07 06:21:45 -07:00
}
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 ,
2012-08-30 09:47:10 -07:00
const char * wname ,
const char * welement ,
const char * wstyle )
2010-09-13 00:56:23 -07:00
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) EINA_FALSE ;
Eina_Bool ret = EINA_FALSE ;
eo_do ( obj , elm_wdg_theme_object_set ( edj , wname , welement , wstyle , & ret ) ) ;
return ret ;
}
static void
_elm_widget_theme_object_set ( Eo * obj , void * _pd EINA_UNUSED , va_list * list )
{
Evas_Object * edj = va_arg ( * list , Evas_Object * ) ;
const char * wname = va_arg ( * list , const char * ) ;
const char * welement = va_arg ( * list , const char * ) ;
const char * wstyle = va_arg ( * list , const char * ) ;
Eina_Bool * ret = va_arg ( * list , Eina_Bool * ) ;
2013-02-15 03:06:19 -08:00
Elm_Widget_Smart_Data * sd = _pd ;
2012-11-25 22:32:53 -08:00
2013-02-25 20:46:27 -08:00
if ( ! _elm_theme_object_set ( obj , edj , wname , welement , wstyle ) )
{
if ( ret ) * ret = EINA_FALSE ;
2013-03-02 20:04:23 -08:00
return ;
2013-02-25 20:46:27 -08:00
}
if ( sd - > orient_mode ! = - 1 )
2013-02-15 03:06:19 -08:00
{
2013-02-19 00:22:15 -08:00
char buf [ 128 ] ;
2013-02-25 20:26:22 -08:00
snprintf ( buf , sizeof ( buf ) , " elm,state,orient,%d " , sd - > orient_mode ) ;
2013-02-26 00:42:34 -08:00
eo_do ( obj , elm_wdg_signal_emit ( buf , " elm " ) ) ;
2013-02-15 03:06:19 -08:00
}
2013-02-16 03:11:25 -08:00
2013-03-02 20:01:22 -08:00
if ( ret ) * ret = EINA_TRUE ;
2010-09-13 00:56:23 -07:00
}
2010-05-07 06:21:45 -07:00
2013-01-28 22:37:01 -08:00
static void
_dbg_info_get ( Eo * eo_obj , void * _pd EINA_UNUSED , va_list * list )
{
Eo_Dbg_Info * root = ( Eo_Dbg_Info * ) va_arg ( * list , Eo_Dbg_Info * ) ;
2013-03-18 09:07:38 -07:00
eo_do_super ( eo_obj , MY_CLASS , eo_dbg_info_get ( root ) ) ;
2013-01-28 22:37:01 -08:00
Eo_Dbg_Info * group = EO_DBG_INFO_LIST_APPEND ( root , MY_CLASS_NAME ) ;
2013-01-29 08:36:13 -08:00
EO_DBG_INFO_APPEND ( group , " Wid-Type " , EINA_VALUE_TYPE_STRING , elm_widget_type_get ( eo_obj ) ) ;
EO_DBG_INFO_APPEND ( group , " Style " , EINA_VALUE_TYPE_STRING , elm_widget_style_get ( eo_obj ) ) ;
EO_DBG_INFO_APPEND ( group , " Layer " , EINA_VALUE_TYPE_INT ,
2013-01-28 22:37:01 -08:00
( int ) evas_object_layer_get ( eo_obj ) ) ;
2013-01-29 08:36:13 -08:00
EO_DBG_INFO_APPEND ( group , " Scale " , EINA_VALUE_TYPE_DOUBLE ,
2013-01-28 22:37:01 -08:00
evas_object_scale_get ( eo_obj ) ) ;
2013-01-29 08:36:13 -08:00
EO_DBG_INFO_APPEND ( group , " Has focus " , EINA_VALUE_TYPE_CHAR ,
2013-01-28 22:37:01 -08:00
elm_object_focus_get ( eo_obj ) ) ;
2013-01-29 08:36:13 -08:00
EO_DBG_INFO_APPEND ( group , " Disabled " , EINA_VALUE_TYPE_CHAR ,
2013-01-28 22:37:01 -08:00
elm_widget_disabled_get ( eo_obj ) ) ;
2013-01-29 08:36:13 -08:00
EO_DBG_INFO_APPEND ( group , " Mirrored " , EINA_VALUE_TYPE_CHAR ,
2013-01-28 22:37:01 -08:00
elm_widget_mirrored_get ( eo_obj ) ) ;
2013-01-29 08:36:13 -08:00
EO_DBG_INFO_APPEND ( group , " Automatic mirroring " , EINA_VALUE_TYPE_CHAR ,
2013-01-28 22:37:01 -08:00
elm_widget_mirrored_automatic_get ( eo_obj ) ) ;
}
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 ) )
2012-08-30 09:47:10 -07:00
return EINA_TRUE ;
2011-08-28 07:12:38 -07:00
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 ;
}
2012-08-30 09:46:59 -07:00
EAPI const char *
elm_widget_type_get ( const Evas_Object * obj )
{
API_ENTRY return NULL ;
2012-11-25 22:32:53 -08:00
return eo_class_name_get ( eo_class_get ( obj ) ) ;
2012-08-30 09:46:59 -07:00
}
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 ,
2012-08-30 09:47:10 -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 ;
2012-08-30 09:46:59 -07:00
2010-09-13 00:56:23 -07:00
provided = elm_widget_type_get ( obj ) ;
2012-05-03 15:41:26 -07:00
/* TODO: eventually migrate to check_ptr version */
2012-08-30 09:46:59 -07:00
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
}
2012-08-30 09:47:10 -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 *
2012-08-30 09:47:10 -07: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 ;
2012-10-01 00:36:27 -07:00
EINA_LIST_FOREACH ( sd - > subobjs , l , child )
2011-12-27 21:51:10 -08:00
{
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 *
2012-08-30 09:47:10 -07:00
elm_widget_name_find ( const Evas_Object * obj ,
const char * name ,
int recurse )
2011-12-27 21:51:10 -08:00
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) NULL ;
Evas_Object * ret = NULL ;
eo_do ( ( Eo * ) obj , elm_wdg_name_find ( name , recurse , & ret ) ) ;
return ret ;
}
static void
_elm_widget_name_find ( Eo * obj , void * _pd EINA_UNUSED , va_list * list )
{
const char * name = va_arg ( * list , const char * ) ;
int recurse = va_arg ( * list , int ) ;
Evas_Object * * ret = va_arg ( * list , Evas_Object * * ) ;
* ret = NULL ;
if ( ! name ) return ;
* ret = _widget_name_find ( obj , name , recurse ) ;
2011-12-27 21:51:10 -08:00
}
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 ;
2013-03-08 20:23:42 -08:00
EINA_LIST_FREE ( list , s )
2012-08-30 09:47:10 -07:00
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-11-25 22:32:53 -08:00
{
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_focus_hide_handle ( ) ) ;
}
static void
_elm_widget_focus_hide_handle ( Eo * obj , void * _pd EINA_UNUSED , va_list * list EINA_UNUSED )
2011-04-14 05:47:16 -07:00
{
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 ) ;
2012-11-25 22:32:53 -08:00
eo_do ( o , elm_wdg_focus_mouse_up_handle ( ) ) ;
}
static void
_elm_widget_focus_mouse_up_handle ( Eo * obj , void * _pd EINA_UNUSED , va_list * list EINA_UNUSED )
{
if ( ! obj ) return ;
if ( ! _is_focusable ( obj ) ) return ;
elm_widget_focus_steal ( obj ) ;
2011-04-14 05:47:16 -07:00
}
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
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_focus_tree_unfocusable_handle ( ) ) ;
}
2012-02-21 04:36:54 -08:00
2012-11-25 22:32:53 -08:00
static void
_elm_widget_focus_tree_unfocusable_handle ( Eo * obj , void * _pd EINA_UNUSED , va_list * list EINA_UNUSED )
{
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 )
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_focus_disabled_handle ( ) ) ;
}
2011-07-27 23:58:29 -07:00
2012-11-25 22:32:53 -08:00
static void
_elm_widget_focus_disabled_handle ( Eo * obj , void * _pd EINA_UNUSED , va_list * list EINA_UNUSED )
{
2011-07-27 23:58:29 -07:00
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 )
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) 0 ;
unsigned int ret = 0 ;
eo_do ( ( Eo * ) obj , elm_wdg_focus_order_get ( & ret ) ) ;
return ret ;
}
static void
_elm_widget_focus_order_get ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
{
unsigned int * ret = va_arg ( * list , unsigned int * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
* ret = sd - > focus_order ;
2012-02-21 02:54:46 -08:00
}
2013-03-07 23:23:34 -08:00
EAPI Evas_Object *
2013-03-11 06:20:20 -07:00
elm_widget_newest_focus_order_get ( const Evas_Object * obj ,
2013-03-07 23:23:34 -08:00
unsigned int * newest_focus_order ,
Eina_Bool can_focus_only )
{
ELM_WIDGET_CHECK ( obj ) NULL ;
Evas_Object * ret = NULL ;
eo_do ( ( Eo * ) obj , elm_wdg_newest_focus_order_get ( newest_focus_order , can_focus_only , & ret ) ) ;
return ret ;
}
static void
_elm_widget_newest_focus_order_get ( Eo * obj , void * _pd , va_list * list )
{
unsigned int * newest_focus_order = va_arg ( * list , unsigned int * ) ;
Eina_Bool can_focus_only = va_arg ( * list , int ) ;
Evas_Object * * ret = va_arg ( * list , Evas_Object * * ) ;
Elm_Widget_Smart_Data * sd = _pd ;
* ret = NULL ;
const Eina_List * l ;
Evas_Object * child , * cur , * best ;
if ( ! evas_object_visible_get ( obj )
| | ( elm_widget_disabled_get ( obj ) )
| | ( elm_widget_tree_unfocusable_get ( obj ) ) )
return ;
best = NULL ;
if ( * newest_focus_order < sd - > focus_order )
{
2014-01-03 03:02:30 -08:00
if ( ! can_focus_only | | elm_widget_can_focus_get ( obj ) )
{
* newest_focus_order = sd - > focus_order ;
best = obj ;
}
2013-03-07 23:23:34 -08:00
}
EINA_LIST_FOREACH ( sd - > subobjs , l , child )
{
cur = elm_widget_newest_focus_order_get
( child , newest_focus_order , can_focus_only ) ;
if ( ! cur ) continue ;
best = cur ;
}
* ret = best ;
return ;
}
2014-02-09 02:53:54 -08:00
EAPI void
elm_widget_focus_highlight_geometry_get ( const Evas_Object * obj , Evas_Coord * x , Evas_Coord * y , Evas_Coord * w , Evas_Coord * h )
{
ELM_WIDGET_CHECK ( obj ) ;
eo_do ( obj , elm_wdg_focus_highlight_geometry_get ( x , y , w , h ) ) ;
}
static void
_elm_widget_focus_highlight_geometry_get ( Eo * obj , void * _pd , va_list * list )
{
Evas_Coord * x = va_arg ( * list , Evas_Coord * ) ;
Evas_Coord * y = va_arg ( * list , Evas_Coord * ) ;
Evas_Coord * w = va_arg ( * list , Evas_Coord * ) ;
Evas_Coord * h = va_arg ( * list , Evas_Coord * ) ;
Evas_Coord tx = 0 , ty = 0 , tw = 0 , th = 0 ;
const char * target_hl_part = NULL ;
Evas_Object * edje_obj = NULL ;
Elm_Widget_Smart_Data * sd = _pd ;
evas_object_geometry_get ( obj , x , y , w , h ) ;
if ( sd - > resize_obj & & eo_isa ( sd - > resize_obj , EDJE_OBJ_CLASS ) )
{
edje_obj = sd - > resize_obj ;
if ( ! ( target_hl_part = edje_object_data_get ( edje_obj , " focus_part " ) ) )
return ;
}
else if ( sd - > resize_obj & & eo_isa ( sd - > resize_obj , ELM_OBJ_LAYOUT_CLASS ) )
{
edje_obj = elm_layout_edje_get ( sd - > resize_obj ) ;
if ( ! ( target_hl_part = elm_layout_data_get ( sd - > resize_obj , " focus_part " ) ) )
return ;
}
else return ;
edje_object_part_geometry_get ( edje_obj , target_hl_part ,
& tx , & ty , & tw , & th ) ;
* x + = tx ;
* y + = ty ;
if ( tw ! = * w ) * w = tw ;
if ( th ! = * h ) * h = th ;
}
2012-09-16 20:01:46 -07:00
EAPI void
elm_widget_activate ( Evas_Object * obj , Elm_Activate act )
2012-09-03 01:49:45 -07:00
{
2012-09-16 20:01:46 -07:00
Evas_Object * parent ;
Eina_Bool ret ;
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
2012-09-03 01:49:45 -07:00
2012-09-16 20:01:46 -07:00
ret = EINA_FALSE ;
2012-11-25 22:32:53 -08:00
eo_do ( obj , elm_wdg_activate ( act , & ret ) ) ;
2012-09-03 01:49:45 -07:00
2012-09-16 20:01:46 -07:00
if ( ret ) return ;
parent = elm_widget_parent_get ( obj ) ;
if ( parent )
elm_widget_activate ( parent , act ) ;
return ;
2012-09-03 01:49:45 -07:00
}
2012-10-14 07:48:02 -07:00
/**
* @ internal
*
* Sets the widget and child widget ' s Evas_Display_Mode .
*
* @ param obj The widget .
* @ param dispmode Evas_Display_Mode to set widget ' s mode .
*
* Widgets are resized by several reasons .
2012-10-14 18:22:12 -07:00
* Evas_Display_Mode can help for widgets to get one more reason of resize .
* For example , elm conform widget resizes it ' s contents when keypad state changed .
2012-10-14 07:48:02 -07:00
* After keypad showing , conform widget can change child ' s Evas_Display_Mode .
* @ ingroup Widget
*/
EAPI void
elm_widget_display_mode_set ( Evas_Object * obj , Evas_Display_Mode dispmode )
{
2012-11-25 22:32:53 -08:00
ELM_WIDGET_CHECK ( obj ) ;
2013-02-13 21:38:26 -08:00
eo_do ( ( Eo * ) obj , elm_wdg_display_mode_set ( dispmode ) ) ;
2012-11-25 22:32:53 -08:00
}
static void
_elm_widget_display_mode_set ( Eo * obj , void * _pd , va_list * list )
{
Evas_Display_Mode dispmode = va_arg ( * list , Evas_Display_Mode ) ;
2013-05-24 02:34:37 -07:00
Evas_Display_Mode prev_dispmode ;
2012-10-14 07:48:02 -07:00
Evas_Object * child ;
Eina_List * l ;
2012-11-25 22:32:53 -08:00
Elm_Widget_Smart_Data * sd = _pd ;
2012-10-14 07:48:02 -07:00
2013-05-24 02:34:37 -07:00
prev_dispmode = evas_object_size_hint_display_mode_get ( obj ) ;
if ( ( prev_dispmode = = dispmode ) | |
( prev_dispmode = = EVAS_DISPLAY_MODE_DONT_CHANGE ) ) return ;
2012-10-14 07:48:02 -07:00
evas_object_size_hint_display_mode_set ( obj , dispmode ) ;
EINA_LIST_FOREACH ( sd - > subobjs , l , child )
2013-05-10 09:58:34 -07:00
elm_widget_display_mode_set ( child , dispmode ) ;
2012-10-14 07:48:02 -07:00
}
2013-02-13 21:38:26 -08:00
EAPI void
elm_widget_orientation_mode_disabled_set ( Evas_Object * obj , Eina_Bool disabled )
{
ELM_WIDGET_CHECK ( obj ) ;
2013-02-14 21:27:09 -08:00
ELM_WIDGET_DATA_GET ( obj , sd ) ;
if ( disabled & & ( sd - > orient_mode = = - 1 ) ) return ;
if ( ! disabled & & ( sd - > orient_mode ! = - 1 ) ) return ;
2013-02-13 21:38:26 -08:00
eo_do ( ( Eo * ) obj , elm_wdg_orientation_mode_disabled_set ( disabled ) ) ;
}
static void
2013-09-16 03:40:30 -07:00
_elm_widget_orientation_mode_disabled_set ( Eo * obj , void * _pd , va_list * list )
2013-02-13 21:38:26 -08:00
{
Eina_Bool disabled = va_arg ( * list , int ) ;
2013-02-14 20:45:53 -08:00
int orient_mode = - 1 ;
2013-02-13 21:38:26 -08:00
Elm_Widget_Smart_Data * sd = _pd ;
2013-02-14 20:45:53 -08:00
if ( ! disabled )
{
2013-02-16 03:11:25 -08:00
//Get current orient mode from it's parent otherwise, 0.
2013-02-14 20:45:53 -08:00
sd - > orient_mode = 0 ;
ELM_WIDGET_DATA_GET ( sd - > parent_obj , sd_parent ) ;
if ( ! sd_parent ) orient_mode = 0 ;
else orient_mode = sd_parent - > orient_mode ;
}
2013-12-30 00:55:52 -08:00
eo_do ( obj , elm_wdg_orientation_set ( orient_mode ) ) ;
2013-02-13 21:38:26 -08:00
}
EAPI Eina_Bool
elm_widget_orientation_mode_disabled_get ( const Evas_Object * obj )
{
ELM_WIDGET_CHECK ( obj ) EINA_FALSE ;
Eina_Bool ret ;
eo_do ( ( Eo * ) obj , elm_wdg_orientation_mode_disabled_get ( & ret ) ) ;
return ret ;
}
static void
2014-01-06 06:30:02 -08:00
_elm_widget_orientation_mode_disabled_get ( Eo * obj EINA_UNUSED , void * _pd , va_list * list )
2013-02-13 21:38:26 -08:00
{
2013-02-14 20:45:53 -08:00
Eina_Bool * ret = va_arg ( * list , Eina_Bool * ) ;
2013-02-13 21:38:26 -08:00
Elm_Widget_Smart_Data * sd = _pd ;
2013-02-14 20:45:53 -08:00
if ( sd - > orient_mode = = - 1 ) * ret = EINA_TRUE ;
else * ret = EINA_FALSE ;
2013-02-13 21:38:26 -08:00
}
EAPI void
elm_widget_orientation_set ( Evas_Object * obj , int rotation )
{
ELM_WIDGET_CHECK ( obj ) ;
2013-02-14 21:27:09 -08:00
ELM_WIDGET_DATA_GET ( obj , sd ) ;
if ( ( sd - > orient_mode = = rotation ) | | ( sd - > orient_mode = = - 1 ) ) return ;
2013-12-30 00:55:52 -08:00
eo_do ( ( Eo * ) obj , elm_wdg_orientation_set ( rotation ) ) ;
2013-02-13 21:38:26 -08:00
}
static void
2013-09-16 03:40:30 -07:00
_elm_widget_orientation_set ( Eo * obj , void * _pd , va_list * list )
2013-02-13 21:38:26 -08:00
{
Evas_Object * child ;
Eina_List * l ;
2013-02-14 20:45:53 -08:00
int orient_mode = va_arg ( * list , int ) ;
2013-02-13 21:38:26 -08:00
Elm_Widget_Smart_Data * sd = _pd ;
2013-02-14 20:45:53 -08:00
sd - > orient_mode = orient_mode ;
2013-02-13 21:38:26 -08:00
EINA_LIST_FOREACH ( sd - > subobjs , l , child )
2013-02-14 20:45:53 -08:00
elm_widget_orientation_set ( child , orient_mode ) ;
2013-02-16 03:11:25 -08:00
2013-02-25 20:46:27 -08:00
if ( orient_mode ! = - 1 )
2013-02-25 20:26:22 -08:00
{
char buf [ 128 ] ;
snprintf ( buf , sizeof ( buf ) , " elm,state,orient,%d " , orient_mode ) ;
2013-02-26 00:42:34 -08:00
eo_do ( obj , elm_wdg_signal_emit ( buf , " elm " ) ) ;
2013-02-25 20:26:22 -08:00
}
2013-02-13 21:38:26 -08:00
}
2013-09-12 07:24:02 -07:00
static void
_track_obj_del ( void * data , Evas * e , Evas_Object * obj , void * event_info ) ;
static void
_track_obj_update ( Evas_Object * track , Evas_Object * obj )
{
//Geometry
Evas_Coord x , y , w , h ;
evas_object_geometry_get ( obj , & x , & y , & w , & h ) ;
evas_object_move ( track , x , y ) ;
evas_object_resize ( track , w , h ) ;
//Visibility
if ( evas_object_visible_get ( obj ) ) evas_object_show ( track ) ;
else evas_object_hide ( track ) ;
}
static void
_track_obj_view_update ( void * data , Evas * e EINA_UNUSED , Evas_Object * obj ,
void * event_info EINA_UNUSED )
{
Evas_Object * track = data ;
_track_obj_update ( track , obj ) ;
}
static void
_track_obj_view_del ( void * data , Evas * e EINA_UNUSED ,
Evas_Object * obj EINA_UNUSED , void * event_info EINA_UNUSED )
{
Elm_Widget_Item * item = data ;
while ( evas_object_ref_get ( item - > track_obj ) > 0 )
evas_object_unref ( item - > track_obj ) ;
evas_object_event_callback_del ( item - > track_obj , EVAS_CALLBACK_DEL ,
_track_obj_del ) ;
evas_object_del ( item - > track_obj ) ;
item - > track_obj = NULL ;
}
static void
_track_obj_del ( void * data , Evas * e EINA_UNUSED ,
Evas_Object * obj EINA_UNUSED , void * event_info EINA_UNUSED )
{
Elm_Widget_Item * item = data ;
item - > track_obj = NULL ;
if ( ! item - > view ) return ;
evas_object_event_callback_del ( item - > view , EVAS_CALLBACK_RESIZE ,
_track_obj_view_update ) ;
evas_object_event_callback_del ( item - > view , EVAS_CALLBACK_MOVE ,
_track_obj_view_update ) ;
evas_object_event_callback_del ( item - > view , EVAS_CALLBACK_SHOW ,
_track_obj_view_update ) ;
evas_object_event_callback_del ( item - > view , EVAS_CALLBACK_HIDE ,
_track_obj_view_update ) ;
evas_object_event_callback_del ( item - > view , EVAS_CALLBACK_DEL ,
_track_obj_view_del ) ;
}
2013-09-25 00:41:12 -07:00
static void
2014-01-06 06:30:02 -08:00
_elm_widget_item_signal_cb ( void * data , Evas_Object * obj EINA_UNUSED , const char * emission ,
2013-09-25 00:41:12 -07:00
const char * source )
{
Elm_Widget_Item_Signal_Data * wisd = data ;
wisd - > func ( wisd - > data , wisd - > item , emission , source ) ;
}
static void *
_elm_widget_item_signal_callback_list_get ( Elm_Widget_Item * item , Eina_List * position )
{
Elm_Widget_Item_Signal_Data * wisd = eina_list_data_get ( position ) ;
void * data ;
item - > signals = eina_list_remove_list ( item - > signals , position ) ;
data = wisd - > data ;
if ( _elm_widget_is ( item - > view ) )
elm_object_signal_callback_del ( item - > view ,
wisd - > emission , wisd - > source ,
_elm_widget_item_signal_cb ) ;
else if ( ! strcmp ( eo_class_name_get ( eo_class_get ( item - > view ) ) ,
" edje " ) )
edje_object_signal_callback_del_full ( item - > view ,
wisd - > emission , wisd - > source ,
_elm_widget_item_signal_cb , wisd ) ;
eina_stringshare_del ( wisd - > emission ) ;
eina_stringshare_del ( wisd - > source ) ;
free ( wisd ) ;
return data ;
}
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 ,
2012-08-30 09:47:10 -07:00
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 )
{
2013-02-12 02:38:33 -08:00
Elm_Translate_String_Data * ts ;
2012-04-03 00:30:11 -07:00
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( 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 ) ;
2014-01-21 17:38:55 -08:00
evas_object_del ( item - > view ) ;
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
2014-01-21 17:12:44 -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
2013-09-25 00:41:12 -07:00
while ( item - > signals )
_elm_widget_item_signal_callback_list_get ( item , item - > signals ) ;
2013-03-06 04:33:13 -08:00
2013-07-16 23:05:40 -07:00
while ( item - > translate_strings )
2013-02-12 02:38:33 -08:00
{
2013-07-16 23:05:40 -07:00
ts = EINA_INLIST_CONTAINER_GET ( item - > translate_strings ,
Elm_Translate_String_Data ) ;
2013-02-12 02:38:33 -08:00
eina_stringshare_del ( ts - > id ) ;
eina_stringshare_del ( ts - > domain ) ;
eina_stringshare_del ( ts - > string ) ;
2013-07-16 23:05:40 -07:00
item - > translate_strings = eina_inlist_remove ( item - > translate_strings ,
item - > translate_strings ) ;
2013-02-12 02:38:33 -08:00
free ( ts ) ;
}
2013-09-17 15:46:46 -07:00
eina_hash_free ( item - > labels ) ;
2013-02-12 02:38:33 -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
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 ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item ) ;
item - > on_deletion = EINA_TRUE ;
2010-09-09 18:54:05 -07:00
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-08-30 09:47:10 -07: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 ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item ) ;
2012-01-09 16:33:51 -08:00
item - > del_pre_func = func ;
2012-01-09 16:02:58 -08:00
}
2013-12-27 03:00:03 -08:00
/**
* @ internal
*
* Set the function to set the style of item
*
* @ param item a valid # Elm_Widget_Item to be notified
* @ see elm_widget_item_style_set_hook_set ( ) convenience macro .
* @ ingroup Widget
*/
EAPI void
_elm_widget_item_style_set_hook_set ( Elm_Widget_Item * item ,
Elm_Widget_Style_Set_Cb func )
{
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item ) ;
2013-12-27 03:00:03 -08:00
item - > style_set_func = func ;
}
2012-01-09 16:02:58 -08:00
2013-12-27 03:00:03 -08:00
/**
* @ internal
*
* Set the function to get the style of item
*
* @ param item a valid # Elm_Widget_Item to be notified
* @ see elm_widget_item_style_get_hook_set ( ) convenience macro .
* @ ingroup Widget
*/
EAPI void
_elm_widget_item_style_get_hook_set ( Elm_Widget_Item * item ,
Elm_Widget_Style_Get_Cb func )
{
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item ) ;
2013-12-27 03:00:03 -08:00
item - > style_get_func = func ;
}
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-08-30 09:47:10 -07:00
Evas_Smart_Cb func )
2010-09-09 18:54:05 -07:00
{
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item ) ;
2010-09-09 18:54:05 -07:00
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 ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item , NULL ) ;
2012-07-01 18:38:21 -07:00
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 ,
2012-08-30 09:47:10 -07:00
const void * data )
2010-09-09 18:54:05 -07:00
{
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item ) ;
2010-09-09 18:54:05 -07:00
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
2012-08-30 09:47:10 -07:00
_elm_widget_item_disabled_set ( Elm_Widget_Item * item ,
Eina_Bool disabled )
2011-11-16 17:58:03 -08:00
{
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item ) ;
2011-11-16 17:58:03 -08:00
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 ;
}
2013-12-27 03:00:03 -08:00
EAPI void
_elm_widget_item_style_set ( Elm_Widget_Item * item , const char * style )
{
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item ) ;
2013-12-27 03:00:03 -08:00
item - > style_set_func ( item , style ) ;
}
EAPI const char *
_elm_widget_item_style_get ( Elm_Widget_Item * item )
{
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item , NULL ) ;
return item - > style_get_func ( item ) ;
}
2011-11-16 17:58:03 -08:00
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 ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item ) ;
2011-11-16 17:58:03 -08:00
item - > disable_func = func ;
}
2013-02-12 02:38:33 -08:00
EAPI void
_elm_widget_item_domain_translatable_part_text_set ( Elm_Widget_Item * item ,
const char * part ,
const char * domain ,
const char * label )
{
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item ) ;
2013-04-23 00:49:49 -07:00
Elm_Translate_String_Data * ts ;
2013-02-12 02:38:33 -08:00
2013-04-23 00:49:49 -07:00
if ( ! label )
{
_part_text_translatable_set ( & item - > translate_strings , part , EINA_FALSE ,
EINA_FALSE ) ;
}
else
{
ts = _part_text_translatable_set ( & item - > translate_strings , part ,
EINA_TRUE , EINA_FALSE ) ;
if ( ! ts ) return ;
if ( ! ts - > string ) ts - > string = eina_stringshare_add ( label ) ;
else eina_stringshare_replace ( & ts - > string , label ) ;
if ( ! ts - > domain ) ts - > domain = eina_stringshare_add ( domain ) ;
else eina_stringshare_replace ( & ts - > domain , domain ) ;
2013-02-12 02:38:33 -08:00
# ifdef HAVE_GETTEXT
2013-04-23 00:49:49 -07:00
if ( label [ 0 ] ) label = dgettext ( domain , label ) ;
2013-02-12 02:38:33 -08:00
# endif
2013-04-23 00:49:49 -07:00
}
item - > on_translate = EINA_TRUE ;
2013-02-12 02:38:33 -08:00
_elm_widget_item_part_text_set ( item , part , label ) ;
2013-04-23 00:49:49 -07:00
item - > on_translate = EINA_FALSE ;
2013-02-12 02:38:33 -08:00
}
EAPI const char *
_elm_widget_item_translatable_part_text_get ( const Elm_Widget_Item * item ,
const char * part )
{
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item , NULL ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item , NULL ) ;
2013-04-23 00:49:49 -07:00
Elm_Translate_String_Data * ts ;
ts = _translate_string_data_get ( item - > translate_strings , part ) ;
if ( ts ) return ts - > string ;
return NULL ;
2013-02-12 02:38:33 -08:00
}
2013-04-23 01:11:28 -07:00
EAPI void
_elm_widget_item_domain_part_text_translatable_set ( Elm_Widget_Item * item ,
const char * part ,
const char * domain ,
Eina_Bool translatable )
{
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item ) ;
2013-04-23 01:11:28 -07:00
Elm_Translate_String_Data * ts ;
const char * text ;
ts = _part_text_translatable_set ( & item - > translate_strings , part ,
translatable , EINA_TRUE ) ;
if ( ! ts ) return ;
if ( ! ts - > domain ) ts - > domain = eina_stringshare_add ( domain ) ;
else eina_stringshare_replace ( & ts - > domain , domain ) ;
text = _elm_widget_item_part_text_get ( item , part ) ;
if ( ! text | | ! text [ 0 ] ) return ;
if ( ! ts - > string ) ts - > string = eina_stringshare_add ( text ) ;
//Try to translate text since we don't know the text is already translated.
# ifdef HAVE_GETTEXT
text = dgettext ( domain , text ) ;
# endif
item - > on_translate = EINA_TRUE ;
_elm_widget_item_part_text_set ( item , part , text ) ;
item - > on_translate = EINA_FALSE ;
}
2013-09-12 22:19:41 -07:00
EAPI void
_elm_widget_item_track_cancel ( Elm_Widget_Item * item )
{
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item ) ;
2013-09-12 22:19:41 -07:00
if ( ! item - > track_obj ) return ;
while ( evas_object_ref_get ( item - > track_obj ) > 0 )
evas_object_unref ( item - > track_obj ) ;
evas_object_del ( item - > track_obj ) ;
}
2013-09-12 07:24:02 -07:00
EAPI Evas_Object *
elm_widget_item_track ( Elm_Widget_Item * item )
{
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item , NULL ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item , NULL ) ;
2013-09-12 07:24:02 -07:00
if ( item - > track_obj )
{
evas_object_ref ( item - > track_obj ) ;
return item - > track_obj ;
}
2013-11-17 20:15:56 -08:00
if ( ! item - > view )
{
WRN ( " view obj of the item(%p) is invalid. Please make sure the view obj is created! " , item ) ;
return NULL ;
}
2013-09-12 07:24:02 -07:00
Evas_Object * track =
evas_object_rectangle_add ( evas_object_evas_get ( item - > widget ) ) ;
evas_object_color_set ( track , 0 , 0 , 0 , 0 ) ;
evas_object_pass_events_set ( track , EINA_TRUE ) ;
_track_obj_update ( track , item - > view ) ;
evas_object_event_callback_add ( track , EVAS_CALLBACK_DEL , _track_obj_del ,
item ) ;
evas_object_event_callback_add ( item - > view , EVAS_CALLBACK_RESIZE ,
_track_obj_view_update , track ) ;
evas_object_event_callback_add ( item - > view , EVAS_CALLBACK_MOVE ,
_track_obj_view_update , track ) ;
evas_object_event_callback_add ( item - > view , EVAS_CALLBACK_SHOW ,
_track_obj_view_update , track ) ;
evas_object_event_callback_add ( item - > view , EVAS_CALLBACK_HIDE ,
_track_obj_view_update , track ) ;
evas_object_event_callback_add ( item - > view , EVAS_CALLBACK_DEL ,
_track_obj_view_del , item ) ;
evas_object_ref ( track ) ;
item - > track_obj = track ;
return track ;
}
void
elm_widget_item_untrack ( Elm_Widget_Item * item )
{
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item ) ;
2013-09-12 07:24:02 -07:00
if ( ! item - > track_obj ) return ;
evas_object_unref ( item - > track_obj ) ;
if ( evas_object_ref_get ( item - > track_obj ) = = 0 )
evas_object_del ( item - > track_obj ) ;
}
int
elm_widget_item_track_get ( const Elm_Widget_Item * item )
{
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item , 0 ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item , 0 ) ;
2013-09-12 07:24:02 -07:00
if ( ! item - > track_obj ) return 0 ;
return evas_object_ref_get ( item - > track_obj ) ;
}
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 *
2012-08-30 09:47:10 -07:00
_elm_widget_item_tooltip_label_create ( void * data ,
2014-01-06 06:30:02 -08:00
Evas_Object * obj EINA_UNUSED ,
2011-07-26 02:38:23 -07:00
Evas_Object * tooltip ,
2014-01-06 06:30:02 -08:00
void * item EINA_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 *
2012-08-30 09:47:10 -07:00
_elm_widget_item_tooltip_trans_label_create ( void * data ,
2014-01-06 06:30:02 -08:00
Evas_Object * obj EINA_UNUSED ,
2011-10-19 07:17:14 -07:00
Evas_Object * tooltip ,
2014-01-06 06:30:02 -08:00
void * item EINA_UNUSED )
2011-10-19 07:17:14 -07:00
{
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
2012-08-30 09:47:10 -07:00
_elm_widget_item_tooltip_label_del_cb ( void * data ,
2014-01-06 06:30:02 -08:00
Evas_Object * obj EINA_UNUSED ,
void * event_info EINA_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 ,
2012-08-30 09:47:10 -07:00
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 ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( 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 ,
2012-08-30 09:47:10 -07:00
const char * text )
2011-10-19 07:17:14 -07:00
{
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item ) ;
2011-10-19 07:17:14 -07:00
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 *
2012-08-30 09:47:10 -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
2012-08-30 09:47:10 -07:00
_elm_widget_item_tooltip_del_cb ( void * data ,
2011-04-02 23:43:17 -07:00
Evas_Object * obj ,
2014-01-06 06:30:02 -08:00
void * event_info EINA_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
2012-08-30 09:47:10 -07:00
_elm_widget_item_tooltip_content_cb_set ( Elm_Widget_Item * item ,
2011-04-02 23:43:17 -07:00
Elm_Tooltip_Item_Content_Cb func ,
2012-08-30 09:47:10 -07:00
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 ) ;
2014-02-07 01:09:46 -08:00
//ELM_WIDGET_ITEM_RETURN_IF_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 ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( 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
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 ,
2012-08-30 09:47:10 -07:00
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 ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( 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
elm_object_tooltip_style_set ( item - > view , style ) ;
}
2011-07-26 02:38:23 -07:00
EAPI Eina_Bool
2012-08-30 09:47:10 -07: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 ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( 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 ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( 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 ) ;
2014-02-07 01:09:46 -08: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
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 ,
2012-08-30 09:47:10 -07:00
const char * cursor )
2010-09-17 11:24:10 -07:00
{
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( 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 ) ;
}
2012-08-30 09:47:10 -07:00
EAPI void
_elm_widget_item_cursor_unset ( Elm_Widget_Item * item )
2010-09-13 00:56:23 -07:00
{
2012-08-30 09:47:10 -07:00
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item ) ;
2012-08-30 09:47:10 -07:00
elm_object_cursor_unset ( item - > view ) ;
2010-09-13 00:56:23 -07:00
}
2012-08-30 09:47:10 -07:00
/**
* @ internal
*
* 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 , . . . )
*
* @ ingroup Widget
*/
EAPI void
_elm_widget_item_cursor_style_set ( Elm_Widget_Item * item ,
const char * style )
2010-09-13 00:56:23 -07:00
{
2012-08-30 09:47:10 -07:00
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item ) ;
2012-08-30 09:47:10 -07:00
elm_object_cursor_style_set ( item - > view , style ) ;
}
[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-30 09:47:10 -07:00
/**
* @ internal
*
* 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 .
*
* @ ingroup Widget
*/
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 ) ;
}
[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-30 09:47:10 -07:00
/**
* @ internal
*
* 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 .
*
* @ ingroup Widget
*/
EAPI void
_elm_widget_item_cursor_engine_only_set ( Elm_Widget_Item * item ,
Eina_Bool engine_only )
{
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item ) ;
2013-05-01 00:39:51 -07:00
elm_object_cursor_theme_search_enabled_set ( item - > view , ! engine_only ) ;
2010-09-13 00:56:23 -07:00
}
2012-08-30 09:47:10 -07:00
/**
* @ internal
*
* 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 .
*
* @ ingroup Widget
*/
EAPI Eina_Bool
_elm_widget_item_cursor_engine_only_get ( const Elm_Widget_Item * item )
2010-09-13 00:56:23 -07:00
{
2012-08-30 09:47:10 -07:00
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item , EINA_FALSE ) ;
2013-05-01 00:39:51 -07:00
return ! elm_object_cursor_theme_search_enabled_get ( item - > view ) ;
2012-08-30 09:47:10 -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-30 09:47:10 -07:00
EAPI void
_elm_widget_item_part_content_set ( Elm_Widget_Item * item ,
const char * part ,
Evas_Object * content )
{
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item ) ;
2012-08-30 09:47:10 -07:00
if ( ! item - > content_set_func )
2010-10-06 20:53:53 -07:00
{
2012-08-30 09:47:10 -07:00
ERR ( " %s does not support elm_object_item_part_content_set() API. " ,
elm_widget_type_get ( item - > widget ) ) ;
return ;
2010-10-06 20:53:53 -07:00
}
2012-08-30 09:47:10 -07:00
item - > content_set_func ( ( Elm_Object_Item * ) item , part , content ) ;
2010-09-13 00:56:23 -07:00
}
2012-08-30 09:47:10 -07:00
EAPI Evas_Object *
_elm_widget_item_part_content_get ( const Elm_Widget_Item * item ,
const char * part )
2010-09-13 00:56:23 -07:00
{
2012-08-30 09:47:10 -07:00
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item , NULL ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item , NULL ) ;
2012-08-30 09:47:10 -07:00
if ( ! item - > content_get_func )
2010-09-13 00:56:23 -07:00
{
2012-08-30 09:47:10 -07:00
ERR ( " %s does not support elm_object_item_part_content_get() API. " ,
elm_widget_type_get ( item - > widget ) ) ;
return NULL ;
2010-09-13 00:56:23 -07:00
}
2012-08-30 09:47:10 -07:00
return item - > content_get_func ( ( Elm_Object_Item * ) item , part ) ;
2010-09-13 00:56:23 -07:00
}
2012-08-30 09:47:10 -07:00
EAPI Evas_Object *
_elm_widget_item_part_content_unset ( Elm_Widget_Item * item ,
const char * part )
2010-09-13 00:56:23 -07:00
{
2012-08-30 09:47:10 -07:00
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item , NULL ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item , NULL ) ;
2012-08-30 09:47:10 -07:00
if ( ! item - > content_unset_func )
2010-09-13 00:56:23 -07:00
{
2012-08-30 09:47:10 -07:00
ERR ( " %s does not support elm_object_item_part_content_unset() API. " ,
elm_widget_type_get ( item - > widget ) ) ;
return NULL ;
2010-09-13 00:56:23 -07:00
}
2012-08-30 09:47:10 -07:00
return item - > content_unset_func ( ( Elm_Object_Item * ) item , part ) ;
2010-09-13 00:56:23 -07:00
}
2012-08-30 09:47:10 -07:00
EAPI void
_elm_widget_item_part_text_set ( Elm_Widget_Item * item ,
const char * part ,
const char * label )
2010-09-13 00:56:23 -07:00
{
2012-08-30 09:47:10 -07:00
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item ) ;
2012-08-30 09:47:10 -07:00
if ( ! item - > text_set_func )
2010-09-13 00:56:23 -07:00
{
2012-08-30 09:47:10 -07:00
ERR ( " %s does not support elm_object_item_part_text_set() API. " ,
elm_widget_type_get ( item - > widget ) ) ;
return ;
2010-09-13 00:56:23 -07:00
}
2012-08-30 09:47:10 -07:00
item - > text_set_func ( ( Elm_Object_Item * ) item , part , label ) ;
2010-09-13 00:56:23 -07:00
}
2012-08-30 09:47:10 -07:00
EAPI const char *
_elm_widget_item_part_text_get ( const Elm_Widget_Item * item ,
const char * part )
2010-09-13 00:56:23 -07:00
{
2012-08-30 09:47:10 -07:00
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item , NULL ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item , NULL ) ;
2012-08-30 09:47:10 -07:00
if ( ! item - > text_get_func )
2010-09-13 00:56:23 -07:00
{
2012-08-30 09:47:10 -07:00
ERR ( " %s does not support elm_object_item_part_text_get() API. " ,
elm_widget_type_get ( item - > widget ) ) ;
return NULL ;
2010-09-13 00:56:23 -07:00
}
2012-08-30 09:47:10 -07:00
return item - > text_get_func ( ( Elm_Object_Item * ) item , part ) ;
2010-09-13 00:56:23 -07:00
}
2013-09-17 15:46:46 -07:00
static void
_elm_widget_item_part_text_custom_free ( void * data )
{
Elm_Label_Data * label ;
label = data ;
eina_stringshare_del ( label - > part ) ;
eina_stringshare_del ( label - > text ) ;
free ( label ) ;
}
EAPI void
_elm_widget_item_part_text_custom_set ( Elm_Widget_Item * item ,
const char * part ,
const char * text )
{
Elm_Label_Data * label ;
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item ) ;
2013-09-17 15:46:46 -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 ;
}
if ( ! item - > labels )
item - > labels =
eina_hash_stringshared_new ( _elm_widget_item_part_text_custom_free ) ;
label = eina_hash_find ( item - > labels , part ) ;
if ( ! label )
{
label = malloc ( sizeof ( Elm_Label_Data ) ) ;
label - > part = eina_stringshare_add ( part ) ;
label - > text = eina_stringshare_add ( text ) ;
eina_hash_add ( item - > labels , part , label ) ;
}
else
eina_stringshare_replace ( & label - > text , text ) ;
}
EAPI const char *
_elm_widget_item_part_text_custom_get ( Elm_Widget_Item * item ,
const char * part )
{
Elm_Label_Data * label ;
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item , NULL ) ;
label = eina_hash_find ( item - > labels , part ) ;
return label ? label - > text : NULL ;
}
static Eina_Bool
_elm_widget_item_part_text_custom_foreach ( const Eina_Hash * labels EINA_UNUSED ,
const void * key EINA_UNUSED ,
void * data ,
void * func_data )
{
Elm_Label_Data * label ;
Elm_Widget_Item * item ;
label = data ;
item = func_data ;
item - > text_set_func ( ( Elm_Object_Item * ) item , label - > part , label - > text ) ;
return EINA_TRUE ;
}
EAPI void
_elm_widget_item_part_text_custom_update ( Elm_Widget_Item * item )
{
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item ) ;
2013-09-18 07:18:37 -07:00
if ( item - > labels )
eina_hash_foreach ( item - > labels ,
_elm_widget_item_part_text_custom_foreach , item ) ;
2013-09-17 15:46:46 -07:00
}
2012-08-30 09:47:10 -07:00
EAPI void
_elm_widget_item_content_set_hook_set ( Elm_Widget_Item * item ,
Elm_Widget_Content_Set_Cb func )
2010-09-13 00:56:23 -07:00
{
2012-08-30 09:47:10 -07:00
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item ) ;
2012-08-30 09:47:10 -07:00
item - > content_set_func = func ;
2010-09-13 00:56:23 -07:00
}
2012-08-30 09:47:10 -07:00
EAPI void
_elm_widget_item_content_get_hook_set ( Elm_Widget_Item * item ,
Elm_Widget_Content_Get_Cb func )
2012-03-28 03:03:45 -07:00
{
2012-08-30 09:47:10 -07:00
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item ) ;
2012-08-30 09:47:10 -07:00
item - > content_get_func = func ;
}
2012-03-28 03:03:45 -07:00
2012-08-30 09:47:10 -07:00
EAPI void
_elm_widget_item_content_unset_hook_set ( Elm_Widget_Item * item ,
Elm_Widget_Content_Unset_Cb func )
{
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item ) ;
2012-08-30 09:47:10 -07:00
item - > content_unset_func = func ;
}
2012-03-28 03:03:45 -07:00
2012-08-30 09:47:10 -07:00
EAPI void
_elm_widget_item_text_set_hook_set ( Elm_Widget_Item * item ,
Elm_Widget_Text_Set_Cb func )
{
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item ) ;
2012-08-30 09:47:10 -07:00
item - > text_set_func = func ;
}
2012-03-28 03:03:45 -07:00
2012-08-30 09:47:10 -07:00
EAPI void
_elm_widget_item_text_get_hook_set ( Elm_Widget_Item * item ,
Elm_Widget_Text_Get_Cb func )
{
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item ) ;
2012-08-30 09:47:10 -07:00
item - > text_get_func = func ;
}
2012-03-28 03:03:45 -07:00
2012-08-30 09:47:10 -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 ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item ) ;
2012-08-30 09:47:10 -07:00
if ( item - > signal_emit_func )
item - > signal_emit_func ( ( Elm_Object_Item * ) item , emission , source ) ;
2012-03-28 03:03:45 -07:00
}
2012-08-30 09:47:10 -07:00
EAPI void
_elm_widget_item_signal_emit_hook_set ( Elm_Widget_Item * item ,
Elm_Widget_Signal_Emit_Cb func )
2012-04-03 07:29:38 -07:00
{
2012-08-30 09:47:10 -07:00
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item ) ;
2012-08-30 09:47:10 -07:00
item - > signal_emit_func = func ;
}
2013-03-06 04:33:13 -08:00
EAPI void
_elm_widget_item_signal_callback_add ( Elm_Widget_Item * item ,
const char * emission ,
const char * source ,
Elm_Widget_Item_Signal_Cb func ,
void * data )
{
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item ) ;
2013-03-06 04:33:13 -08:00
EINA_SAFETY_ON_NULL_RETURN ( func ) ;
Elm_Widget_Item_Signal_Data * wisd ;
wisd = malloc ( sizeof ( Elm_Widget_Item_Signal_Data ) ) ;
if ( ! wisd ) return ;
wisd - > item = item ;
wisd - > func = func ;
wisd - > data = data ;
wisd - > emission = eina_stringshare_add ( emission ) ;
wisd - > source = eina_stringshare_add ( source ) ;
if ( _elm_widget_is ( item - > view ) )
elm_object_signal_callback_add ( item - > view , emission , source , _elm_widget_item_signal_cb , wisd ) ;
else if ( ! strcmp ( eo_class_name_get ( eo_class_get ( item - > view ) ) , " edje " ) )
edje_object_signal_callback_add ( item - > view , emission , source , _elm_widget_item_signal_cb , wisd ) ;
else
{
WRN ( " The %s widget item doesn't support signal callback add! " ,
eo_class_name_get ( eo_class_get ( item - > widget ) ) ) ;
free ( wisd ) ;
return ;
}
item - > signals = eina_list_append ( item - > signals , wisd ) ;
}
EAPI void *
_elm_widget_item_signal_callback_del ( Elm_Widget_Item * item ,
const char * emission ,
const char * source ,
Elm_Widget_Item_Signal_Cb func )
{
Elm_Widget_Item_Signal_Data * wisd ;
Eina_List * l ;
2013-09-30 03:21:31 -07:00
2013-09-25 00:41:12 -07:00
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item , NULL ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item , NULL ) ;
2013-09-25 00:41:12 -07:00
EINA_SAFETY_ON_NULL_RETURN_VAL ( func , NULL ) ;
2013-03-06 04:33:13 -08:00
EINA_LIST_FOREACH ( item - > signals , l , wisd )
{
2013-09-25 00:41:12 -07:00
if ( ( wisd - > func = = func ) & &
! strcmp ( wisd - > emission , emission ) & &
2013-03-06 04:33:13 -08:00
! strcmp ( wisd - > source , source ) )
2013-09-25 00:41:12 -07:00
return _elm_widget_item_signal_callback_list_get ( item , l ) ;
2013-03-06 04:33:13 -08:00
}
2013-09-25 00:41:12 -07:00
return NULL ;
2013-03-06 04:33:13 -08:00
}
2012-08-30 09:47:10 -07:00
EAPI void
_elm_widget_item_access_info_set ( Elm_Widget_Item * item ,
const char * txt )
{
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item ) ;
2014-01-21 17:12:44 -08:00
eina_stringshare_del ( item - > access_info ) ;
2012-08-30 09:47:10 -07:00
if ( ! txt ) item - > access_info = NULL ;
else item - > access_info = eina_stringshare_add ( txt ) ;
2012-04-03 07:29:38 -07:00
}
2013-02-12 07:14:38 -08:00
EAPI void
_elm_widget_item_translate ( Elm_Widget_Item * item )
{
ELM_WIDGET_ITEM_CHECK_OR_RETURN ( item ) ;
2014-02-07 01:09:46 -08:00
ELM_WIDGET_ITEM_RETURN_IF_ONDEL ( item ) ;
2013-02-12 07:14:38 -08:00
# ifdef HAVE_GETTEXT
Elm_Translate_String_Data * ts ;
2013-07-16 23:05:40 -07:00
EINA_INLIST_FOREACH ( item - > translate_strings , ts )
2013-02-12 07:14:38 -08:00
{
2013-04-23 01:11:28 -07:00
if ( ! ts - > string ) continue ;
2013-02-12 07:14:38 -08:00
const char * s = dgettext ( ts - > domain , ts - > string ) ;
2013-04-23 01:11:28 -07:00
item - > on_translate = EINA_TRUE ;
2013-02-12 14:04:30 -08:00
_elm_widget_item_part_text_set ( item , ts - > id , s ) ;
2013-04-23 01:11:28 -07:00
item - > on_translate = EINA_FALSE ;
2013-02-12 07:14:38 -08:00
}
# endif
}
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 ,
2012-08-30 09:47:10 -07:00
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 ;
2013-06-04 22:40:03 -07:00
DBG ( " + %s(%p) \n " ,
elm_widget_type_get ( obj ) ,
obj ) ;
2012-10-01 00:36:27 -07:00
EINA_LIST_FOREACH ( sd - > subobjs , l , obj )
2013-02-16 05:39:59 -08:00
_sub_obj_tree_dump ( obj , lvl + 1 ) ;
2010-09-28 12:35:12 -07:00
}
else
2013-06-04 22:40:03 -07:00
DBG ( " + %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 ,
2012-08-30 09:47:10 -07:00
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 ;
2012-10-01 00:36:27 -07:00
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
}
2012-08-30 09:47:10 -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
( void ) top ;
2013-01-09 01:02:22 -08:00
return ;
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 ,
2012-08-30 09:47:10 -07:00
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
( void ) top ;
( void ) output ;
2013-01-09 01:02:22 -08:00
return ;
2010-10-04 11:37:48 -07:00
# endif
2011-04-14 05:47:16 -07:00
}
2012-11-25 22:32:53 -08:00
2014-02-07 18:25:44 -08:00
static Eina_Bool
_atspi_obj_create ( void * data )
{
Elm_Atspi_Object * parent = NULL ;
Elm_Atspi_Object * obj = _elm_atspi_factory_construct ( data ) ;
if ( obj )
{
eo_do ( obj , elm_atspi_obj_parent_get ( & parent ) ) ;
eo_do ( parent , eo_event_callback_call ( EV_ATSPI_OBJ_CHILD_ADD , obj , NULL ) ) ;
}
return EINA_FALSE ;
}
2012-11-25 22:32:53 -08:00
static void
_constructor ( Eo * obj , void * class_data EINA_UNUSED , va_list * list EINA_UNUSED )
{
2013-09-24 21:33:39 -07:00
Eo * parent ;
2013-08-22 01:00:36 -07:00
ELM_WIDGET_DATA_GET ( obj , sd ) ;
sd - > on_create = EINA_TRUE ;
2013-03-18 09:07:38 -07:00
eo_do_super ( obj , MY_CLASS , eo_constructor ( ) ) ;
2013-09-24 21:33:39 -07:00
eo_do ( obj ,
2013-11-07 03:44:22 -08:00
evas_obj_type_set ( MY_CLASS_NAME_LEGACY ) ,
2013-09-24 21:33:39 -07:00
eo_parent_get ( & parent ) ) ;
eo_do ( obj , elm_wdg_parent_set ( parent ) ) ;
2013-08-22 01:00:36 -07:00
sd - > on_create = EINA_FALSE ;
2014-02-07 18:25:44 -08:00
if ( _elm_config - > access_mode = = ELM_ACCESS_MODE_ON )
ecore_idle_enterer_add ( _atspi_obj_create , obj ) ;
2012-11-25 22:32:53 -08:00
}
static void
_elm_widget_on_focus ( Eo * obj EINA_UNUSED , void * _pd EINA_UNUSED , va_list * list )
{
Eina_Bool * ret = va_arg ( * list , Eina_Bool * ) ;
2013-06-09 00:54:00 -07:00
if ( ret ) * ret = EINA_FALSE ;
2013-06-06 09:13:37 -07:00
2013-08-06 02:14:44 -07:00
ELM_WIDGET_DATA_GET ( obj , sd ) ;
2013-06-06 09:13:37 -07:00
if ( elm_widget_can_focus_get ( obj ) )
{
if ( elm_widget_focus_get ( obj ) )
2013-08-06 02:14:44 -07:00
{
if ( ! sd - > resize_obj )
evas_object_focus_set ( obj , EINA_TRUE ) ;
2014-01-23 00:24:19 -08:00
evas_object_smart_callback_call ( obj , SIG_WIDGET_FOCUSED , NULL ) ;
2013-08-06 02:14:44 -07:00
}
2013-06-06 09:13:37 -07:00
else
2013-08-06 02:14:44 -07:00
{
if ( ! sd - > resize_obj )
evas_object_focus_set ( obj , EINA_FALSE ) ;
2014-01-23 00:24:19 -08:00
evas_object_smart_callback_call ( obj , SIG_WIDGET_UNFOCUSED , NULL ) ;
2013-08-06 02:14:44 -07:00
}
2013-06-06 09:13:37 -07:00
}
2013-06-09 00:54:00 -07:00
else
return ;
2013-06-06 09:13:37 -07:00
if ( ret ) * ret = EINA_TRUE ;
2012-11-25 22:32:53 -08:00
}
static void
_elm_widget_disable ( Eo * obj EINA_UNUSED , void * _pd EINA_UNUSED , va_list * list )
{
Eina_Bool * ret = va_arg ( * list , Eina_Bool * ) ;
if ( ret ) * ret = EINA_FALSE ;
}
static void
_elm_widget_event ( Eo * obj EINA_UNUSED , void * _pd EINA_UNUSED , va_list * list )
{
va_arg ( * list , Evas_Object * ) ;
va_arg ( * list , Evas_Callback_Type ) ;
va_arg ( * list , void * ) ;
Eina_Bool * ret = va_arg ( * list , Eina_Bool * ) ;
if ( ret ) * ret = EINA_FALSE ;
}
static void
_elm_widget_focus_next_manager_is_unimplemented ( Eo * obj EINA_UNUSED , void * _pd EINA_UNUSED , va_list * list )
{
Eina_Bool * ret = va_arg ( * list , Eina_Bool * ) ;
* ret = EINA_FALSE ;
WRN ( " The %s widget does not implement the \" focus_next/focus_next_manager_is \" functions. " ,
eo_class_name_get ( eo_class_get ( obj ) ) ) ;
}
static void
_elm_widget_focus_direction_manager_is_unimplemented ( Eo * obj EINA_UNUSED , void * _pd EINA_UNUSED , va_list * list )
{
Eina_Bool * ret = va_arg ( * list , Eina_Bool * ) ;
* ret = EINA_FALSE ;
WRN ( " The %s widget does not implement the \" focus_direction/focus_direction_manager_is \" functions. " ,
eo_class_name_get ( eo_class_get ( obj ) ) ) ;
}
static void
_elm_widget_activate ( Eo * obj EINA_UNUSED , void * _pd EINA_UNUSED , va_list * list )
{
va_arg ( * list , Elm_Activate ) ;
Eina_Bool * ret = va_arg ( * list , Eina_Bool * ) ;
* ret = EINA_TRUE ;
WRN ( " The %s widget does not implement the \" activate \" functions. " ,
eo_class_name_get ( eo_class_get ( obj ) ) ) ;
}
static void
_class_constructor ( Eo_Class * klass )
{
const Eo_Op_Func_Description func_desc [ ] = {
EO_OP_FUNC ( EO_BASE_ID ( EO_BASE_SUB_ID_CONSTRUCTOR ) , _constructor ) ,
2013-01-28 22:37:01 -08:00
EO_OP_FUNC ( EO_BASE_ID ( EO_BASE_SUB_ID_DBG_INFO_GET ) , _dbg_info_get ) ,
2012-11-25 22:32:53 -08:00
EO_OP_FUNC ( EVAS_OBJ_SMART_ID ( EVAS_OBJ_SMART_SUB_ID_MEMBER_ADD ) , _elm_widget_smart_member_add ) ,
EO_OP_FUNC ( EVAS_OBJ_SMART_ID ( EVAS_OBJ_SMART_SUB_ID_MEMBER_DEL ) , _elm_widget_smart_member_del ) ,
EO_OP_FUNC ( EVAS_OBJ_SMART_ID ( EVAS_OBJ_SMART_SUB_ID_ADD ) , _elm_widget_smart_add ) ,
EO_OP_FUNC ( EVAS_OBJ_SMART_ID ( EVAS_OBJ_SMART_SUB_ID_DEL ) , _elm_widget_smart_del ) ,
EO_OP_FUNC ( EVAS_OBJ_SMART_ID ( EVAS_OBJ_SMART_SUB_ID_RESIZE ) , _elm_widget_smart_resize ) ,
EO_OP_FUNC ( EVAS_OBJ_SMART_ID ( EVAS_OBJ_SMART_SUB_ID_MOVE ) , _elm_widget_smart_move ) ,
EO_OP_FUNC ( EVAS_OBJ_SMART_ID ( EVAS_OBJ_SMART_SUB_ID_SHOW ) , _elm_widget_smart_show ) ,
EO_OP_FUNC ( EVAS_OBJ_SMART_ID ( EVAS_OBJ_SMART_SUB_ID_HIDE ) , _elm_widget_smart_hide ) ,
EO_OP_FUNC ( EVAS_OBJ_SMART_ID ( EVAS_OBJ_SMART_SUB_ID_COLOR_SET ) , _elm_widget_smart_color_set ) ,
EO_OP_FUNC ( EVAS_OBJ_SMART_ID ( EVAS_OBJ_SMART_SUB_ID_CLIP_SET ) , _elm_widget_smart_clip_set ) ,
EO_OP_FUNC ( EVAS_OBJ_SMART_ID ( EVAS_OBJ_SMART_SUB_ID_CLIP_UNSET ) , _elm_widget_smart_clip_unset ) ,
EO_OP_FUNC ( EVAS_OBJ_SMART_ID ( EVAS_OBJ_SMART_SUB_ID_CALCULATE ) , _elm_widget_smart_calculate ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_ON_FOCUS ) , _elm_widget_on_focus ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_DISABLE ) , _elm_widget_disable ) ,
2014-01-21 00:44:45 -08:00
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_THEME_APPLY ) , _elm_widget_theme_func ) ,
2012-11-25 22:32:53 -08:00
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_TRANSLATE ) , _elm_widget_translate ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_EVENT ) , _elm_widget_event ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_ON_FOCUS_REGION ) , _elm_widget_on_focus_region ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_FOCUS_NEXT_MANAGER_IS ) , _elm_widget_focus_next_manager_is_unimplemented ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_FOCUS_DIRECTION_MANAGER_IS ) , _elm_widget_focus_direction_manager_is_unimplemented ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_SUB_OBJECT_ADD ) , _elm_widget_sub_object_add ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_SUB_OBJECT_DEL ) , _elm_widget_sub_object_del ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_ACCESS ) , _elm_widget_access ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_PARENT_SET ) , _elm_widget_parent_set ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_PARENT_GET ) , _elm_widget_parent_get ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_PARENT2_SET ) , _elm_widget_parent2_set ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_PARENT2_GET ) , _elm_widget_parent2_get ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_ACTIVATE ) , _elm_widget_activate ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_MIRRORED_GET ) , _elm_widget_mirrored_get ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_MIRRORED_SET ) , _elm_widget_mirrored_set ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_MIRRORED_AUTOMATIC_GET ) , _elm_widget_mirrored_automatic_get ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_MIRRORED_AUTOMATIC_SET ) , _elm_widget_mirrored_automatic_set ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_HIGHLIGHT_IGNORE_SET ) , _elm_widget_highlight_ignore_set ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_HIGHLIGHT_IGNORE_GET ) , _elm_widget_highlight_ignore_get ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_HIGHLIGHT_IN_THEME_SET ) , _elm_widget_highlight_in_theme_set ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_HIGHLIGHT_IN_THEME_GET ) , _elm_widget_highlight_in_theme_get ) ,
2014-02-07 19:27:41 -08:00
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_ACCESS_HIGHLIGHT_IN_THEME_SET ) , _elm_widget_access_highlight_in_theme_set ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_ACCESS_HIGHLIGHT_IN_THEME_GET ) , _elm_widget_access_highlight_in_theme_get ) ,
2012-11-25 22:32:53 -08:00
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_SCROLL_HOLD_PUSH ) , _elm_widget_scroll_hold_push ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_SCROLL_HOLD_POP ) , _elm_widget_scroll_hold_pop ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_SCROLL_HOLD_GET ) , _elm_widget_scroll_hold_get ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_SCROLL_FREEZE_PUSH ) , _elm_widget_scroll_freeze_push ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_SCROLL_FREEZE_POP ) , _elm_widget_scroll_freeze_pop ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_SCROLL_FREEZE_GET ) , _elm_widget_scroll_freeze_get ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_ON_SHOW_REGION_HOOK_SET ) , _elm_widget_on_show_region_hook_set ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_RESIZE_OBJECT_SET ) , _elm_widget_resize_object_set ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_HOVER_OBJECT_SET ) , _elm_widget_hover_object_set ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_CAN_FOCUS_SET ) , _elm_widget_can_focus_set ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_CAN_FOCUS_GET ) , _elm_widget_can_focus_get ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_CHILD_CAN_FOCUS_GET ) , _elm_widget_child_can_focus_get ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_FOCUS_GET ) , _elm_widget_focus_get ) ,
2013-01-28 03:13:18 -08:00
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_HIGHLIGHT_GET ) , _elm_widget_highlight_get ) ,
2012-11-25 22:32:53 -08:00
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_FOCUSED_OBJECT_GET ) , _elm_widget_focused_object_get ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_TOP_GET ) , _elm_widget_top_get ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_FOCUS_SET ) , _elm_widget_focus_set ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_FOCUSED_OBJECT_CLEAR ) , _elm_widget_focused_object_clear ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_FOCUS_STEAL ) , _elm_widget_focus_steal ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_FOCUS_RESTORE ) , _elm_widget_focus_restore ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_DISABLED_SET ) , _elm_widget_disabled_set ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_DISABLED_GET ) , _elm_widget_disabled_get ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_SHOW_REGION_SET ) , _elm_widget_show_region_set ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_SHOW_REGION_GET ) , _elm_widget_show_region_get ) ,
2013-06-18 00:28:06 -07:00
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_PARENTS_BOUNCE_GET ) , _elm_widget_parents_bounce_get ) ,
2012-11-25 22:32:53 -08:00
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_SCROLLABLE_CHILDREN_GET ) , _elm_widget_scrollable_children_get ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_SCALE_SET ) , _elm_widget_scale_set ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_SCALE_GET ) , _elm_widget_scale_get ) ,
2013-11-16 23:48:54 -08:00
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_PART_TEXT_SET ) , _elm_widget_part_text_set ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_PART_TEXT_GET ) , _elm_widget_part_text_get ) ,
2013-02-12 03:43:39 -08:00
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_DOMAIN_TRANSLATABLE_PART_TEXT_SET ) , _elm_widget_domain_translatable_part_text_set ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_TRANSLATABLE_PART_TEXT_GET ) , _elm_widget_translatable_part_text_get ) ,
2013-04-23 00:49:49 -07:00
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_DOMAIN_PART_TEXT_TRANSLATABLE_SET ) , _elm_widget_domain_part_text_translatable_set ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_PART_TEXT_TRANSLATE ) , _elm_widget_part_text_translate ) ,
2012-11-25 22:32:53 -08:00
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_ACCESS_INFO_SET ) , _elm_widget_access_info_set ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_ACCESS_INFO_GET ) , _elm_widget_access_info_get ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_THEME_SET ) , _elm_widget_theme_set ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_THEME_GET ) , _elm_widget_theme_get ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_STYLE_SET ) , _elm_widget_style_set ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_STYLE_GET ) , _elm_widget_style_get ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_TOOLTIP_ADD ) , _elm_widget_tooltip_add ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_TOOLTIP_DEL ) , _elm_widget_tooltip_del ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_CURSOR_ADD ) , _elm_widget_cursor_add ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_CURSOR_DEL ) , _elm_widget_cursor_del ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_DRAG_LOCK_X_SET ) , _elm_widget_drag_lock_x_set ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_DRAG_LOCK_Y_SET ) , _elm_widget_drag_lock_y_set ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_DRAG_LOCK_X_GET ) , _elm_widget_drag_lock_x_get ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_DRAG_LOCK_Y_GET ) , _elm_widget_drag_lock_y_get ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_DRAG_CHILD_LOCKED_X_GET ) , _elm_widget_drag_child_locked_x_get ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_DRAG_CHILD_LOCKED_Y_GET ) , _elm_widget_drag_child_locked_y_get ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_EVENT_CALLBACK_ADD ) , _elm_widget_event_callback_add ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_EVENT_CALLBACK_DEL ) , _elm_widget_event_callback_del ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_EVENT_PROPAGATE ) , _elm_widget_event_propagate ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_SIGNAL_EMIT ) , _elm_widget_signal_emit ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_SIGNAL_CALLBACK_ADD ) , _elm_widget_signal_callback_add ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_SIGNAL_CALLBACK_DEL ) , _elm_widget_signal_callback_del ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_NAME_FIND ) , _elm_widget_name_find ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_FOCUS_HIDE_HANDLE ) , _elm_widget_focus_hide_handle ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_FOCUS_MOUSE_UP_HANDLE ) , _elm_widget_focus_mouse_up_handle ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_FOCUS_TREE_UNFOCUSABLE_HANDLE ) , _elm_widget_focus_tree_unfocusable_handle ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_FOCUS_DISABLED_HANDLE ) , _elm_widget_focus_disabled_handle ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_FOCUS_ORDER_GET ) , _elm_widget_focus_order_get ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_FOCUS_REGION_GET ) , _elm_widget_focus_region_get ) ,
2013-07-05 22:41:00 -07:00
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_FOCUS_REGION_SHOW ) , _elm_widget_focus_region_show ) ,
2014-02-05 02:17:41 -08:00
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_FOCUS_HIGHLIGHT_STYLE_SET ) , _elm_widget_focus_highlight_style_set ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_FOCUS_HIGHLIGHT_STYLE_GET ) , _elm_widget_focus_highlight_style_get ) ,
2012-11-25 22:32:53 -08:00
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_THEME_OBJECT_SET ) , _elm_widget_theme_object_set ) ,
2013-02-13 21:38:26 -08:00
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_ORIENTATION_SET ) , _elm_widget_orientation_set ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_ORIENTATION_MODE_DISABLED_SET ) , _elm_widget_orientation_mode_disabled_set ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_ORIENTATION_MODE_DISABLED_GET ) , _elm_widget_orientation_mode_disabled_get ) ,
2012-11-25 22:32:53 -08:00
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_FOCUS_CUSTOM_CHAIN_SET ) , _elm_widget_focus_custom_chain_set ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_FOCUS_CUSTOM_CHAIN_GET ) , _elm_widget_focus_custom_chain_get ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_FOCUS_CUSTOM_CHAIN_UNSET ) , _elm_widget_focus_custom_chain_unset ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_FOCUS_CUSTOM_CHAIN_APPEND ) , _elm_widget_focus_custom_chain_append ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_FOCUS_CUSTOM_CHAIN_PREPEND ) , _elm_widget_focus_custom_chain_prepend ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_FOCUS_CYCLE ) , _elm_widget_focus_cycle ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_FOCUS_DIRECTION_GO ) , _elm_widget_focus_direction_go ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_FOCUS_DIRECTION_GET ) , _elm_widget_focus_direction_get ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_FOCUS_LIST_DIRECTION_GET ) , _elm_widget_focus_list_direction_get ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_FOCUS_NEXT_GET ) , _elm_widget_focus_next_get ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_FOCUS_LIST_NEXT_GET ) , _elm_widget_focus_list_next_get ) ,
2013-03-22 17:36:21 -07:00
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_FOCUS_NEXT_OBJECT_GET ) , _elm_widget_focus_next_object_get ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_FOCUS_NEXT_OBJECT_SET ) , _elm_widget_focus_next_object_set ) ,
2013-01-28 03:13:18 -08:00
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_PARENT_HIGHLIGHT_SET ) , _elm_widget_parent_highlight_set ) ,
2012-11-25 22:32:53 -08:00
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_DISPLAY_MODE_SET ) , _elm_widget_display_mode_set ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_TREE_UNFOCUSABLE_SET ) , _elm_widget_tree_unfocusable_set ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_TREE_UNFOCUSABLE_GET ) , _elm_widget_tree_unfocusable_get ) ,
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_CAN_FOCUS_CHILD_LIST_GET ) , _elm_widget_can_focus_child_list_get ) ,
2013-03-07 23:23:34 -08:00
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_NEWEST_FOCUS_ORDER_GET ) , _elm_widget_newest_focus_order_get ) ,
2014-02-09 02:53:54 -08:00
EO_OP_FUNC ( ELM_WIDGET_ID ( ELM_WIDGET_SUB_ID_FOCUS_HIGHLIGHT_GEOMETRY_GET ) , _elm_widget_focus_highlight_geometry_get ) ,
2012-11-25 22:32:53 -08:00
EO_OP_FUNC_SENTINEL
} ;
eo_class_funcs_set ( klass , func_desc ) ;
2013-02-09 23:52:31 -08:00
2013-11-07 03:44:22 -08:00
evas_smart_legacy_type_register ( MY_CLASS_NAME_LEGACY , klass ) ;
2012-11-25 22:32:53 -08:00
}
static const Eo_Op_Description op_desc [ ] = {
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_ON_FOCUS , " 'Virtual' function handling focus in/out events on the widget. " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_DISABLE , " 'Virtual' function on the widget being disabled. " ) ,
2014-01-21 00:44:45 -08:00
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_THEME_APPLY , " 'Virtual' function on the widget being re-themed. " ) ,
2012-11-25 22:32:53 -08:00
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_TRANSLATE , " 'Virtual' function handling language changes on Elementary. " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_EVENT , " 'Virtual' function handling input events on the widget. " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_ON_FOCUS_REGION , " 'Virtual' function returning an inner area of a widget that should be brought into the visible are of a broader viewport, may this context arise. " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_FOCUS_NEXT_MANAGER_IS , " 'Virtual' function which checks if handling of passing focus to sub-objects is supported by widget. " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_FOCUS_NEXT , " 'Virtual' function handling passing focus to sub-objects. " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_FOCUS_DIRECTION_MANAGER_IS , " 'Virtual' function which checks if handling of passing focus to sub-objects in given direction is supported by widget. " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_FOCUS_DIRECTION , " 'Virtual' function handling passing focus to sub-objects given a direction, in degrees. " ) ,
2014-02-05 02:17:41 -08:00
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_SUB_OBJECT_ADD , " 'Virtual' function handling sub objects being added. " ) ,
2012-11-25 22:32:53 -08:00
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_SUB_OBJECT_DEL , " 'Virtual' function handling sub objects being removed. " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_ACCESS , " 'Virtual' function on the widget being set access. " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_PARENT_SET , " 'Virtual' function handling parent widget attachment to new object. " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_PARENT_GET , " 'Virtual' function handling getting object's parent widget. " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_PARENT2_SET , " " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_PARENT2_GET , " " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_ACTIVATE , " 'Virtual' function to activate widget. " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_MIRRORED_GET , " Returns the widget's mirrored mode. " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_MIRRORED_SET , " Sets the widget's mirrored mode. " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_MIRRORED_AUTOMATIC_GET , " Returns the widget's mirrored mode setting. " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_MIRRORED_AUTOMATIC_SET , " Sets the widget's mirrored mode setting. " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_HIGHLIGHT_IGNORE_SET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_HIGHLIGHT_IGNORE_GET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_HIGHLIGHT_IN_THEME_SET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_HIGHLIGHT_IN_THEME_GET , " description here " ) ,
2014-02-07 19:27:41 -08:00
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_ACCESS_HIGHLIGHT_IN_THEME_SET , " Set the access highlight in widget theme. " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_ACCESS_HIGHLIGHT_IN_THEME_GET , " Get the access highlight in widget theme. " ) ,
2012-11-25 22:32:53 -08:00
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_SCROLL_HOLD_PUSH , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_SCROLL_HOLD_POP , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_SCROLL_HOLD_GET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_SCROLL_FREEZE_PUSH , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_SCROLL_FREEZE_POP , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_SCROLL_FREEZE_GET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_ON_SHOW_REGION_HOOK_SET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_RESIZE_OBJECT_SET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_HOVER_OBJECT_SET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_CAN_FOCUS_SET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_CAN_FOCUS_GET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_CHILD_CAN_FOCUS_GET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_FOCUS_GET , " description here " ) ,
2013-01-28 03:13:18 -08:00
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_HIGHLIGHT_GET , " description here " ) ,
2012-11-25 22:32:53 -08:00
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_FOCUSED_OBJECT_GET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_TOP_GET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_PARENT_WIDGET_GET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_FOCUS_SET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_FOCUSED_OBJECT_CLEAR , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_FOCUS_STEAL , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_FOCUS_RESTORE , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_DISABLED_SET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_DISABLED_GET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_SHOW_REGION_SET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_SHOW_REGION_GET , " description here " ) ,
2013-06-18 00:28:06 -07:00
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_PARENTS_BOUNCE_GET , " Get the whether parents have a bounce. " ) ,
2012-11-25 22:32:53 -08:00
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_SCROLLABLE_CHILDREN_GET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_SCALE_SET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_SCALE_GET , " description here " ) ,
2013-11-16 23:48:54 -08:00
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_PART_TEXT_SET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_PART_TEXT_GET , " description here " ) ,
2012-11-25 22:32:53 -08:00
2013-02-12 03:43:39 -08:00
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_DOMAIN_TRANSLATABLE_PART_TEXT_SET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_TRANSLATABLE_PART_TEXT_GET , " description here " ) ,
2013-04-23 00:56:06 -07:00
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_DOMAIN_PART_TEXT_TRANSLATABLE_SET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_PART_TEXT_TRANSLATE , " description here " ) ,
2012-11-25 22:32:53 -08:00
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_ACCESS_INFO_SET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_ACCESS_INFO_GET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_THEME_SET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_THEME_GET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_STYLE_SET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_STYLE_GET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_TOOLTIP_ADD , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_TOOLTIP_DEL , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_CURSOR_ADD , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_CURSOR_DEL , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_DRAG_LOCK_X_SET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_DRAG_LOCK_Y_SET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_DRAG_LOCK_X_GET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_DRAG_LOCK_Y_GET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_DRAG_CHILD_LOCKED_X_GET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_DRAG_CHILD_LOCKED_Y_GET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_EVENT_CALLBACK_ADD , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_EVENT_CALLBACK_DEL , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_EVENT_PROPAGATE , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_SIGNAL_EMIT , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_SIGNAL_CALLBACK_ADD , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_SIGNAL_CALLBACK_DEL , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_NAME_FIND , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_FOCUS_HIDE_HANDLE , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_FOCUS_MOUSE_UP_HANDLE , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_FOCUS_TREE_UNFOCUSABLE_HANDLE , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_FOCUS_DISABLED_HANDLE , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_FOCUS_ORDER_GET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_FOCUS_REGION_GET , " Get the focus region of the given widget. " ) ,
2013-07-05 22:41:00 -07:00
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_FOCUS_REGION_SHOW , " Show the focus region of the given widget. " ) ,
2014-02-05 02:17:41 -08:00
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_FOCUS_HIGHLIGHT_STYLE_SET , " Function to set the focus highlight style. " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_FOCUS_HIGHLIGHT_STYLE_GET , " Function to get the focus highlight style. " ) ,
2012-11-25 22:32:53 -08:00
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_THEME_OBJECT_SET , " description here " ) ,
2013-02-13 21:38:26 -08:00
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_ORIENTATION_SET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_ORIENTATION_MODE_DISABLED_SET , " description here " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_ORIENTATION_MODE_DISABLED_GET , " description here " ) ,
2012-11-25 22:32:53 -08:00
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_FOCUS_CUSTOM_CHAIN_SET , " Set custom focus chain. " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_FOCUS_CUSTOM_CHAIN_GET , " Get custom focus chain. " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_FOCUS_CUSTOM_CHAIN_UNSET , " Unset custom focus chain. " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_FOCUS_CUSTOM_CHAIN_APPEND , " Append object to custom focus chain. " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_FOCUS_CUSTOM_CHAIN_PREPEND , " Prepend object to custom focus chain. " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_FOCUS_CYCLE , " Give focus to next object in object tree. " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_FOCUS_DIRECTION_GO , " Give focus to near object(in object tree) in one direction. " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_FOCUS_DIRECTION_GET , " Get near object in one direction of base object. " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_FOCUS_LIST_DIRECTION_GET , " Get near object in one direction of base object in list. " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_FOCUS_NEXT_GET , " Get next object in focus chain of object tree. " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_FOCUS_LIST_NEXT_GET , " Get next object in focus chain of object tree in list. " ) ,
2013-03-22 17:36:21 -07:00
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_FOCUS_NEXT_OBJECT_GET , " Get next object specified by focus direction. " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_FOCUS_NEXT_OBJECT_SET , " Set next object with specific focus direction. " ) ,
2013-01-28 03:13:18 -08:00
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_PARENT_HIGHLIGHT_SET , " Set highlighted value from itself to top parent object. " ) ,
2012-11-25 22:32:53 -08:00
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_DISPLAY_MODE_SET , " Sets the widget and child widget's Evas_Display_Mode. " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_TREE_UNFOCUSABLE_SET , " Sets the widget object and its children to be unfocusable " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_TREE_UNFOCUSABLE_GET , " Returns true, if the object sub-tree is unfocusable " ) ,
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_CAN_FOCUS_CHILD_LIST_GET , " Get the list of focusable child objects. " ) ,
2013-03-07 23:23:34 -08:00
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_NEWEST_FOCUS_ORDER_GET , " Get the newest focused object and its order. " ) ,
2014-02-09 02:53:54 -08:00
EO_OP_DESCRIPTION ( ELM_WIDGET_SUB_ID_FOCUS_HIGHLIGHT_GEOMETRY_GET , " Get the focus highlight geometry of widget. " ) ,
2012-11-25 22:32:53 -08:00
EO_OP_DESCRIPTION_SENTINEL
} ;
static const Eo_Class_Description class_desc = {
EO_VERSION ,
MY_CLASS_NAME ,
EO_CLASS_TYPE_REGULAR_NO_INSTANT ,
EO_CLASS_DESCRIPTION_OPS ( & ELM_WIDGET_BASE_ID , op_desc , ELM_WIDGET_SUB_ID_LAST ) ,
NULL ,
sizeof ( Elm_Widget_Smart_Data ) ,
_class_constructor ,
NULL
} ;
EO_DEFINE_CLASS ( elm_widget_class_get , & class_desc , EVAS_OBJ_SMART_CLASS , NULL ) ;