2014-04-20 20:46:11 -07:00
# ifdef HAVE_CONFIG_H
# include "elementary_config.h"
# endif
2014-10-17 08:56:11 -07:00
# define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
2014-04-20 20:46:11 -07:00
# include <Elementary.h>
# include "elm_widget.h"
# include "elm_priv.h"
const char * Atspi_Name [ ] = {
" invalid " ,
" accelerator label " ,
" alert " ,
" animation " ,
" arrow " ,
" calendar " ,
" canvas " ,
" check box " ,
" check menu item " ,
" color chooser " ,
" column header " ,
" combo box " ,
" dateeditor " ,
" desktop icon " ,
" desktop frame " ,
" dial " ,
" dialog " ,
" directory pane " ,
" drawing area " ,
" file chooser " ,
" filler " ,
" focus traversable " ,
" font chooser " ,
" frame " ,
" glass pane " ,
" html container " ,
" icon " ,
" image " ,
" internal frame " ,
" label " ,
" layered pane " ,
" list " ,
" list item " ,
" menu " ,
" menu bar " ,
" menu item " ,
" option pane " ,
" page tab " ,
" page tab list " ,
" panel " ,
" password text " ,
" popup menu " ,
" progress bar " ,
" push button " ,
" radio button " ,
" radio menu item " ,
" root pane " ,
" row header " ,
" scroll bar " ,
" scroll pane " ,
" separator " ,
" slider " ,
" spin button " ,
" split pane " ,
" status bar " ,
" table " ,
" table cell " ,
" table column header " ,
" table row header " ,
" tearoff menu item " ,
" terminal " ,
" text " ,
" toggle button " ,
" tool bar " ,
" tool tip " ,
" tree " ,
" tree table " ,
" unknown " ,
" viewport " ,
" window " ,
" extended " ,
" header " ,
" footer " ,
" paragraph " ,
" ruler " ,
" application " ,
" autocomplete " ,
" editbar " ,
" embedded " ,
" entry " ,
" chart " ,
" caption " ,
" document frame " ,
" heading " ,
" page " ,
" section " ,
" redundant object " ,
" form " ,
" link " ,
" input method window " ,
" table row " ,
" tree item " ,
" document spreadsheet " ,
" document presentation " ,
" document text " ,
" document web " ,
" document email " ,
" comment " ,
" list box " ,
" grouping " ,
" image map " ,
" notification " ,
" info bar " ,
" last defined "
} ;
2015-09-03 05:07:23 -07:00
struct _Elm_Atspi_Event_Handler
{
Eo_Event_Cb cb ;
void * data ;
} ;
2015-10-01 08:24:42 -07:00
struct _Elm_Interface_Atspi_Accessible_Data
{
Elm_Atspi_Role role ;
const char * name ;
const char * description ;
2015-10-02 08:04:38 -07:00
const char * translation_domain ;
2015-10-04 13:30:31 -07:00
Elm_Atspi_Relation_Set relations ;
2015-11-26 07:53:32 -08:00
Elm_Atspi_Type type : 2 ;
2015-10-01 08:24:42 -07:00
} ;
typedef struct _Elm_Interface_Atspi_Accessible_Data Elm_Interface_Atspi_Accessible_Data ;
2015-09-03 05:07:23 -07:00
static Eina_List * global_callbacks ;
2015-09-09 04:58:14 -07:00
static Eo * root ;
2014-04-20 20:46:11 -07:00
EOLIAN static int
2015-10-01 08:24:42 -07:00
_elm_interface_atspi_accessible_index_in_parent_get ( Eo * obj , Elm_Interface_Atspi_Accessible_Data * pd EINA_UNUSED )
2014-04-20 20:46:11 -07:00
{
Eina_List * l , * children = NULL ;
Eo * chld , * parent = NULL ;
int ret = 0 ;
2016-03-02 04:10:48 -08:00
parent = elm_interface_atspi_accessible_parent_get ( obj ) ;
2014-04-20 20:46:11 -07:00
if ( ! parent ) return - 1 ;
2016-03-02 04:10:48 -08:00
children = elm_interface_atspi_accessible_children_get ( parent ) ;
2014-04-20 20:46:11 -07:00
if ( ! children ) return - 1 ;
EINA_LIST_FOREACH ( children , l , chld )
{
if ( obj = = chld )
break ;
ret + + ;
}
if ( ret = = ( int ) eina_list_count ( children ) )
{
ERR ( " Object %s not present in its AT-SPI parents (%s) children list! This should never happen. " , eo_class_name_get ( eo_class_get ( obj ) ) , eo_class_name_get ( eo_class_get ( parent ) ) ) ;
2015-03-26 03:51:37 -07:00
ret = - 1 ;
2014-04-20 20:46:11 -07:00
}
2015-03-26 03:51:37 -07:00
eina_list_free ( children ) ;
2014-04-20 20:46:11 -07:00
return ret ;
}
2015-10-01 08:24:42 -07:00
EOLIAN static Elm_Interface_Atspi_Accessible *
2015-12-01 07:55:12 -08:00
_elm_interface_atspi_accessible_parent_get ( Eo * obj EINA_UNUSED , Elm_Interface_Atspi_Accessible_Data * pd EINA_UNUSED )
2014-04-20 20:46:11 -07:00
{
2015-11-26 07:53:32 -08:00
Elm_Atspi_Type type ;
Eo * parent = obj ;
do {
2016-03-02 04:10:48 -08:00
parent = eo_parent_get ( obj ) ;
2015-11-26 07:53:32 -08:00
if ( eo_isa ( parent , ELM_INTERFACE_ATSPI_ACCESSIBLE_MIXIN ) )
{
2016-03-02 04:10:48 -08:00
type = elm_interface_atspi_accessible_type_get ( parent ) ;
2015-11-26 07:53:32 -08:00
if ( type ! = ELM_ATSPI_TYPE_SKIPPED ) break ;
}
} while ( parent ) ;
return eo_isa ( parent , ELM_INTERFACE_ATSPI_ACCESSIBLE_MIXIN ) ? parent : NULL ;
2014-04-20 20:46:11 -07:00
}
EOLIAN static void
2015-12-01 07:55:12 -08:00
_elm_interface_atspi_accessible_parent_set ( Eo * obj , Elm_Interface_Atspi_Accessible_Data * pd EINA_UNUSED , Elm_Interface_Atspi_Accessible * new_parent EINA_UNUSED )
2014-04-20 20:46:11 -07:00
{
2015-12-01 07:55:12 -08:00
WRN ( " The %s object does not implement the \" accessible_parent_set \" function. " ,
eo_class_name_get ( eo_class_get ( obj ) ) ) ;
2014-04-20 20:46:11 -07:00
}
2014-05-28 01:12:34 -07:00
EOLIAN Eina_List *
2015-10-01 08:24:42 -07:00
_elm_interface_atspi_accessible_attributes_get ( Eo * obj EINA_UNUSED , Elm_Interface_Atspi_Accessible_Data * pd EINA_UNUSED )
2014-04-20 20:46:11 -07:00
{
WRN ( " The %s object does not implement the \" accessible_attributes_set \" function. " ,
eo_class_name_get ( eo_class_get ( obj ) ) ) ;
2014-05-28 01:12:34 -07:00
return NULL ;
2014-04-20 20:46:11 -07:00
}
EOLIAN static Elm_Atspi_Role
2015-10-01 08:24:42 -07:00
_elm_interface_atspi_accessible_role_get ( Eo * obj EINA_UNUSED , Elm_Interface_Atspi_Accessible_Data * pd EINA_UNUSED )
2014-04-20 20:46:11 -07:00
{
2015-10-01 08:24:42 -07:00
return pd - > role ;
2014-04-20 20:46:11 -07:00
}
EOLIAN static void
2015-10-01 08:24:42 -07:00
_elm_interface_atspi_accessible_role_set ( Eo * obj , Elm_Interface_Atspi_Accessible_Data * pd EINA_UNUSED , Elm_Atspi_Role role )
2014-04-20 20:46:11 -07:00
{
2015-10-01 08:24:42 -07:00
if ( pd - > role ! = role )
{
pd - > role = role ;
elm_interface_atspi_accessible_role_changed_signal_emit ( obj ) ;
}
2014-04-20 20:46:11 -07:00
}
EOLIAN const char *
2015-10-01 08:24:42 -07:00
_elm_interface_atspi_accessible_role_name_get ( Eo * obj EINA_UNUSED , Elm_Interface_Atspi_Accessible_Data * pd EINA_UNUSED )
2014-04-20 20:46:11 -07:00
{
Elm_Atspi_Role role ;
2016-03-02 04:10:48 -08:00
role = elm_interface_atspi_accessible_role_get ( obj ) ;
2014-04-20 20:46:11 -07:00
return role > ELM_ATSPI_ROLE_LAST_DEFINED ? " " : Atspi_Name [ role ] ;
}
2014-10-21 05:46:35 -07:00
EOLIAN char *
2015-10-01 08:24:42 -07:00
_elm_interface_atspi_accessible_name_get ( Eo * obj EINA_UNUSED , Elm_Interface_Atspi_Accessible_Data * pd )
2014-04-20 20:46:11 -07:00
{
2015-10-02 08:04:38 -07:00
if ( pd - > name )
{
# ifdef ENABLE_NLS
if ( pd - > translation_domain )
return strdup ( dgettext ( pd - > translation_domain , pd - > name ) ) ;
else
return strdup ( pd - > name ) ;
# else
return strdup ( pd - > name ) ;
# endif
}
return NULL ;
2014-04-20 20:46:11 -07:00
}
EOLIAN static void
2015-10-01 08:24:42 -07:00
_elm_interface_atspi_accessible_name_set ( Eo * obj EINA_UNUSED , Elm_Interface_Atspi_Accessible_Data * pd , char * val )
2014-04-20 20:46:11 -07:00
{
2015-10-01 08:24:42 -07:00
eina_stringshare_replace ( & pd - > name , val ) ;
2014-04-20 20:46:11 -07:00
}
2015-10-01 08:24:42 -07:00
const char * _elm_interface_atspi_accessible_description_get ( Eo * obj EINA_UNUSED , Elm_Interface_Atspi_Accessible_Data * pd )
2014-04-20 20:46:11 -07:00
{
2015-10-02 08:04:38 -07:00
# ifdef ENABLE_NLS
if ( pd - > translation_domain )
return dgettext ( pd - > translation_domain , pd - > description ) ;
# endif
2015-10-01 08:24:42 -07:00
return pd - > description ;
2014-04-20 20:46:11 -07:00
}
EOLIAN static void
2015-10-01 08:24:42 -07:00
_elm_interface_atspi_accessible_description_set ( Eo * obj EINA_UNUSED , Elm_Interface_Atspi_Accessible_Data * pd , const char * val )
2014-04-20 20:46:11 -07:00
{
2015-10-01 08:24:42 -07:00
eina_stringshare_replace ( & pd - > description , val ) ;
2014-04-20 20:46:11 -07:00
}
EOLIAN static const char *
2015-10-01 08:24:42 -07:00
_elm_interface_atspi_accessible_localized_role_name_get ( Eo * obj EINA_UNUSED , Elm_Interface_Atspi_Accessible_Data * pd EINA_UNUSED )
2014-04-20 20:46:11 -07:00
{
const char * ret = NULL ;
2016-03-02 04:10:48 -08:00
ret = elm_interface_atspi_accessible_role_name_get ( obj ) ;
2014-04-20 20:46:11 -07:00
# ifdef ENABLE_NLS
ret = gettext ( ret ) ;
# endif
return ret ;
}
EOLIAN static Eina_List *
2015-10-01 08:24:42 -07:00
_elm_interface_atspi_accessible_children_get ( Eo * obj EINA_UNUSED , Elm_Interface_Atspi_Accessible_Data * pd EINA_UNUSED )
2014-04-20 20:46:11 -07:00
{
Eina_List * children = NULL ;
Eina_Iterator * iter = NULL ;
Eo * chld ;
// By default use Eo_Base object hierarchy
2016-03-02 04:10:48 -08:00
iter = eo_children_iterator_new ( obj ) ;
2014-04-20 20:46:11 -07:00
if ( ! iter ) return NULL ;
EINA_ITERATOR_FOREACH ( iter , chld )
{
2014-06-30 13:37:04 -07:00
if ( eo_isa ( chld , ELM_INTERFACE_ATSPI_ACCESSIBLE_MIXIN ) )
2014-04-20 20:46:11 -07:00
children = eina_list_append ( children , chld ) ;
}
eina_iterator_free ( iter ) ;
return children ;
}
EOLIAN static Elm_Atspi_State_Set
2015-10-01 08:24:42 -07:00
_elm_interface_atspi_accessible_state_set_get ( Eo * obj EINA_UNUSED , Elm_Interface_Atspi_Accessible_Data * pd EINA_UNUSED )
2014-04-20 20:46:11 -07:00
{
2015-10-01 08:24:42 -07:00
return 0 ;
2014-04-20 20:46:11 -07:00
}
2015-10-04 13:30:31 -07:00
EOLIAN Elm_Atspi_Relation_Set
2015-10-01 08:24:42 -07:00
_elm_interface_atspi_accessible_relation_set_get ( Eo * obj EINA_UNUSED , Elm_Interface_Atspi_Accessible_Data * pd EINA_UNUSED )
2014-05-28 01:12:34 -07:00
{
2015-10-04 13:30:31 -07:00
return elm_atspi_relation_set_clone ( pd - > relations ) ;
2014-05-28 01:12:34 -07:00
}
2014-10-17 08:56:11 -07:00
EAPI void elm_atspi_attributes_list_free ( Eina_List * list )
2014-05-28 01:12:34 -07:00
{
Elm_Atspi_Attribute * attr ;
EINA_LIST_FREE ( list , attr )
2014-07-21 06:44:16 -07:00
{
eina_stringshare_del ( attr - > key ) ;
eina_stringshare_del ( attr - > value ) ;
free ( attr ) ;
}
2014-05-28 01:12:34 -07:00
}
2015-09-03 05:07:23 -07:00
EOLIAN void
_elm_interface_atspi_accessible_event_emit ( Eo * class EINA_UNUSED , void * pd EINA_UNUSED , Eo * accessible , const Eo_Event_Description * event , void * event_info )
{
Eina_List * l ;
Elm_Atspi_Event_Handler * hdl ;
2015-11-26 07:53:32 -08:00
Elm_Atspi_Type type ;
2015-09-03 05:07:23 -07:00
if ( ! accessible | | ! event | | ! eo_isa ( accessible , ELM_INTERFACE_ATSPI_ACCESSIBLE_MIXIN ) )
{
2015-10-02 02:35:27 -07:00
CRI ( " Invalid parameters, event: %s, obj: %s " , event ? event - > name : " NULL " , accessible ? eo_class_name_get ( accessible ) : " NULL " ) ;
2015-09-03 05:07:23 -07:00
return ;
}
2016-03-02 04:10:48 -08:00
type = elm_interface_atspi_accessible_type_get ( accessible ) ;
2015-11-26 07:53:32 -08:00
if ( type ! = ELM_ATSPI_TYPE_REGULAR )
return ;
if ( event = = ELM_INTERFACE_ATSPI_ACCESSIBLE_EVENT_CHILDREN_CHANGED )
{
Elm_Atspi_Event_Children_Changed_Data * atspi_data = event_info ;
2016-03-02 04:10:48 -08:00
type = elm_interface_atspi_accessible_type_get ( atspi_data - > child ) ;
2015-11-26 07:53:32 -08:00
if ( type ! = ELM_ATSPI_TYPE_REGULAR )
return ;
}
2016-02-29 03:32:52 -08:00
Eo_Event ev ;
ev . obj = accessible ;
ev . desc = event ;
2016-04-12 07:23:55 -07:00
ev . info = event_info ;
2015-09-03 05:07:23 -07:00
EINA_LIST_FOREACH ( global_callbacks , l , hdl )
{
if ( hdl - > cb )
2016-02-29 03:32:52 -08:00
hdl - > cb ( hdl - > data , & ev ) ;
2015-09-03 05:07:23 -07:00
}
}
EOLIAN Elm_Atspi_Event_Handler *
_elm_interface_atspi_accessible_event_handler_add ( Eo * class EINA_UNUSED , void * pd EINA_UNUSED , Eo_Event_Cb cb , void * data )
{
2015-11-30 06:15:52 -08:00
Elm_Atspi_Event_Handler * ret = calloc ( 1 , sizeof ( Elm_Atspi_Event_Handler ) ) ;
2015-09-03 05:07:23 -07:00
ret - > cb = cb ;
ret - > data = data ;
global_callbacks = eina_list_append ( global_callbacks , ret ) ;
return ret ;
}
EOLIAN void
_elm_interface_atspi_accessible_event_handler_del ( Eo * class EINA_UNUSED , void * pd EINA_UNUSED , Elm_Atspi_Event_Handler * handler )
{
Eina_List * l , * l2 ;
Elm_Atspi_Event_Handler * hdl ;
EINA_LIST_FOREACH_SAFE ( global_callbacks , l , l2 , hdl )
{
if ( hdl = = handler )
{
global_callbacks = eina_list_remove_list ( global_callbacks , l ) ;
free ( hdl ) ;
break ;
}
}
}
2015-10-02 08:04:38 -07:00
EOLIAN void
_elm_interface_atspi_accessible_translation_domain_set ( Eo * obj EINA_UNUSED , Elm_Interface_Atspi_Accessible_Data * pd , const char * domain )
{
eina_stringshare_replace ( & pd - > translation_domain , domain ) ;
}
2015-09-09 04:58:14 -07:00
2015-10-02 08:04:38 -07:00
EOLIAN const char *
_elm_interface_atspi_accessible_translation_domain_get ( Eo * obj EINA_UNUSED , Elm_Interface_Atspi_Accessible_Data * pd )
{
return pd - > translation_domain ;
}
2015-10-04 13:30:31 -07:00
EAPI void
elm_atspi_relation_free ( Elm_Atspi_Relation * relation )
{
eina_list_free ( relation - > objects ) ;
free ( relation ) ;
}
EAPI Elm_Atspi_Relation *
elm_atspi_relation_clone ( const Elm_Atspi_Relation * relation )
{
2015-11-30 06:15:52 -08:00
Elm_Atspi_Relation * ret = calloc ( 1 , sizeof ( Elm_Atspi_Relation ) ) ;
2015-10-04 13:30:31 -07:00
if ( ! ret ) return NULL ;
ret - > type = relation - > type ;
ret - > objects = eina_list_clone ( relation - > objects ) ;
return ret ;
}
static Eina_Bool
2016-02-29 03:32:52 -08:00
_on_rel_obj_del ( void * data , const Eo_Event * event )
2015-10-04 13:30:31 -07:00
{
Elm_Atspi_Relation_Set * set = data ;
Elm_Atspi_Relation * rel ;
Eina_List * l , * l2 , * p , * p2 ;
Eo * rel_obj ;
EINA_LIST_FOREACH_SAFE ( * set , l , l2 , rel )
{
EINA_LIST_FOREACH_SAFE ( rel - > objects , p , p2 , rel_obj )
{
2016-02-29 03:32:52 -08:00
if ( rel_obj = = event - > obj )
2015-10-04 13:30:31 -07:00
rel - > objects = eina_list_remove_list ( rel - > objects , p ) ;
}
if ( ! rel - > objects )
{
* set = eina_list_remove_list ( * set , l ) ;
free ( rel ) ;
}
}
return EINA_TRUE ;
}
EAPI Eina_Bool
elm_atspi_relation_set_relation_append ( Elm_Atspi_Relation_Set * set , Elm_Atspi_Relation_Type type , const Eo * rel_obj )
{
Elm_Atspi_Relation * rel ;
Eina_List * l ;
if ( ! eo_isa ( rel_obj , ELM_INTERFACE_ATSPI_ACCESSIBLE_MIXIN ) )
return EINA_FALSE ;
EINA_LIST_FOREACH ( * set , l , rel )
{
if ( rel - > type = = type )
{
if ( ! eina_list_data_find ( rel - > objects , rel_obj ) )
{
rel - > objects = eina_list_append ( rel - > objects , rel_obj ) ;
2016-05-17 09:14:47 -07:00
eo_event_callback_add ( ( Eo * ) rel_obj , EO_EVENT_DEL , _on_rel_obj_del , set ) ;
2015-10-04 13:30:31 -07:00
}
return EINA_TRUE ;
}
}
2015-11-30 06:15:52 -08:00
rel = calloc ( 1 , sizeof ( Elm_Atspi_Relation ) ) ;
2015-10-04 13:30:31 -07:00
if ( ! rel ) return EINA_FALSE ;
rel - > type = type ;
rel - > objects = eina_list_append ( rel - > objects , rel_obj ) ;
* set = eina_list_append ( * set , rel ) ;
2016-05-17 09:14:47 -07:00
eo_event_callback_add ( ( Eo * ) rel_obj , EO_EVENT_DEL , _on_rel_obj_del , set ) ;
2015-10-04 13:30:31 -07:00
return EINA_TRUE ;
}
EAPI void
elm_atspi_relation_set_relation_remove ( Elm_Atspi_Relation_Set * set , Elm_Atspi_Relation_Type type , const Eo * rel_obj )
{
Eina_List * l ;
Elm_Atspi_Relation * rel ;
EINA_LIST_FOREACH ( * set , l , rel )
{
if ( rel - > type = = type )
{
if ( eina_list_data_find ( rel - > objects , rel_obj ) )
{
2016-05-17 09:14:47 -07:00
eo_event_callback_del ( ( Eo * ) rel_obj , EO_EVENT_DEL , _on_rel_obj_del , set ) ;
2015-10-04 13:30:31 -07:00
rel - > objects = eina_list_remove ( rel - > objects , rel_obj ) ;
}
if ( ! rel - > objects )
{
* set = eina_list_remove ( * set , rel ) ;
elm_atspi_relation_free ( rel ) ;
}
return ;
}
}
}
EAPI void
elm_atspi_relation_set_relation_type_remove ( Elm_Atspi_Relation_Set * set , Elm_Atspi_Relation_Type type )
{
Eina_List * l ;
Elm_Atspi_Relation * rel ;
Eo * obj ;
EINA_LIST_FOREACH ( * set , l , rel )
{
if ( rel - > type = = type )
{
EINA_LIST_FOREACH ( rel - > objects , l , obj )
2016-05-17 09:14:47 -07:00
eo_event_callback_del ( obj , EO_EVENT_DEL , _on_rel_obj_del , set ) ;
2015-10-04 13:30:31 -07:00
* set = eina_list_remove ( * set , rel ) ;
elm_atspi_relation_free ( rel ) ;
return ;
}
}
}
EAPI void
elm_atspi_relation_set_free ( Elm_Atspi_Relation_Set set )
{
Elm_Atspi_Relation * rel ;
Eina_List * l ;
Eo * obj ;
EINA_LIST_FREE ( set , rel )
{
EINA_LIST_FOREACH ( rel - > objects , l , obj )
2016-05-17 09:14:47 -07:00
eo_event_callback_del ( obj , EO_EVENT_DEL , _on_rel_obj_del , set ) ;
2015-10-04 13:30:31 -07:00
elm_atspi_relation_free ( rel ) ;
}
}
EAPI Elm_Atspi_Relation_Set
elm_atspi_relation_set_clone ( const Elm_Atspi_Relation_Set set )
{
Elm_Atspi_Relation_Set ret = NULL ;
Eina_List * l ;
Elm_Atspi_Relation * rel ;
EINA_LIST_FOREACH ( set , l , rel )
{
Elm_Atspi_Relation * cpy = elm_atspi_relation_clone ( rel ) ;
ret = eina_list_append ( ret , cpy ) ;
}
return ret ;
}
EOLIAN static Eina_Bool
_elm_interface_atspi_accessible_relationship_append ( Eo * obj EINA_UNUSED , Elm_Interface_Atspi_Accessible_Data * sd , Elm_Atspi_Relation_Type type , const Elm_Interface_Atspi_Accessible * relation_obj )
{
return elm_atspi_relation_set_relation_append ( & sd - > relations , type , relation_obj ) ;
}
EOLIAN static void
_elm_interface_atspi_accessible_relationship_remove ( Eo * obj EINA_UNUSED , Elm_Interface_Atspi_Accessible_Data * sd , Elm_Atspi_Relation_Type type , const Elm_Interface_Atspi_Accessible * relation_obj )
{
if ( relation_obj )
elm_atspi_relation_set_relation_remove ( & sd - > relations , type , relation_obj ) ;
else
elm_atspi_relation_set_relation_type_remove ( & sd - > relations , type ) ;
}
EOLIAN static void
_elm_interface_atspi_accessible_relationships_clear ( Eo * obj EINA_UNUSED , Elm_Interface_Atspi_Accessible_Data * sd )
{
elm_atspi_relation_set_free ( sd - > relations ) ;
sd - > relations = NULL ;
}
2015-09-09 04:58:14 -07:00
EOLIAN Eo *
_elm_interface_atspi_accessible_root_get ( Eo * class EINA_UNUSED , void * pd EINA_UNUSED )
{
if ( ! root )
2016-03-11 04:34:16 -08:00
root = eo_add ( ELM_ATSPI_APP_OBJECT_CLASS , NULL ) ;
2015-09-09 04:58:14 -07:00
return root ;
}
2015-11-26 07:53:32 -08:00
EOLIAN Elm_Atspi_Type
_elm_interface_atspi_accessible_type_get ( Eo * obj EINA_UNUSED , Elm_Interface_Atspi_Accessible_Data * pd )
{
return pd - > type ;
}
EOLIAN void
2015-12-01 07:55:12 -08:00
_elm_interface_atspi_accessible_type_set ( Eo * obj , Elm_Interface_Atspi_Accessible_Data * pd , Elm_Atspi_Type val )
2015-11-26 07:53:32 -08:00
{
2015-12-15 07:49:02 -08:00
Elm_Interface_Atspi_Accessible * parent ;
2015-12-01 07:55:12 -08:00
if ( val = = pd - > type )
return ;
2016-03-02 04:10:48 -08:00
parent = elm_interface_atspi_accessible_parent_get ( obj ) ;
2015-12-15 07:49:02 -08:00
2015-12-01 07:55:12 -08:00
switch ( val )
{
case ELM_ATSPI_TYPE_DISABLED :
case ELM_ATSPI_TYPE_SKIPPED :
2015-12-15 07:49:02 -08:00
if ( parent ) elm_interface_atspi_accessible_children_changed_del_signal_emit ( parent , obj ) ;
2015-12-01 07:55:12 -08:00
elm_interface_atspi_accessible_removed ( obj ) ;
break ;
case ELM_ATSPI_TYPE_REGULAR :
2015-12-15 07:49:02 -08:00
if ( parent ) elm_interface_atspi_accessible_children_changed_added_signal_emit ( parent , obj ) ;
2015-12-01 07:55:12 -08:00
elm_interface_atspi_accessible_added ( obj ) ;
}
2015-11-26 07:53:32 -08:00
pd - > type = val ;
}
2014-04-20 20:46:11 -07:00
# include "elm_interface_atspi_accessible.eo.c"