2014-04-20 20:46:11 -07:00
# ifdef HAVE_CONFIG_H
# include "elementary_config.h"
# endif
2018-04-03 04:27:30 -07:00
# define EFL_ACCESS_OBJECT_PROTECTED
2014-10-17 08:56:11 -07:00
2014-04-20 20:46:11 -07:00
# include <Elementary.h>
# include "elm_widget.h"
# include "elm_priv.h"
2017-10-18 18:13:54 -07:00
const char * Access_Name [ ] = {
2014-04-20 20:46:11 -07:00
" 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 "
} ;
2017-10-18 18:13:54 -07:00
struct _Efl_Access_Event_Handler
2015-09-03 05:07:23 -07:00
{
2016-08-10 07:23:04 -07:00
Efl_Event_Cb cb ;
2015-09-03 05:07:23 -07:00
void * data ;
} ;
2018-04-03 04:27:30 -07:00
struct _Efl_Access_Object_Data
2015-10-01 08:24:42 -07:00
{
2018-05-04 14:17:15 -07:00
Eina_List * relations ;
2017-11-21 18:54:44 -08:00
Eina_List * attr_list ;
2015-10-01 08:24:42 -07:00
const char * name ;
const char * description ;
2015-10-02 08:04:38 -07:00
const char * translation_domain ;
2017-11-21 18:54:44 -08:00
Efl_Access_Role role ;
2017-11-22 19:07:52 -08:00
Efl_Access_Reading_Info_Type reading_info ;
2017-10-18 18:13:54 -07:00
Efl_Access_Type type : 2 ;
2015-10-01 08:24:42 -07:00
} ;
2018-04-03 04:27:30 -07:00
typedef struct _Efl_Access_Object_Data Efl_Access_Object_Data ;
2015-10-01 08:24:42 -07:00
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
2018-04-03 04:27:30 -07:00
_efl_access_object_index_in_parent_get ( const Eo * obj , Efl_Access_Object_Data * pd EINA_UNUSED )
2014-04-20 20:46:11 -07:00
{
Eina_List * l , * children = NULL ;
Eo * chld , * parent = NULL ;
int ret = 0 ;
2018-04-03 04:27:30 -07:00
parent = efl_provider_find ( efl_parent_get ( obj ) , EFL_ACCESS_OBJECT_MIXIN ) ;
2014-04-20 20:46:11 -07:00
if ( ! parent ) return - 1 ;
2018-04-03 04:27:30 -07:00
children = efl_access_object_access_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 ) )
{
2016-08-15 06:44:41 -07:00
ERR ( " Object %s not present in its AT-SPI parents (%s) children list! This should never happen. " , efl_class_name_get ( efl_class_get ( obj ) ) , efl_class_name_get ( efl_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 ;
}
2018-02-14 18:14:52 -08:00
EOLIAN static Efl_Object *
2018-04-03 04:27:30 -07:00
_efl_access_object_efl_object_provider_find ( const Eo * obj , Efl_Access_Object_Data * pd EINA_UNUSED , const Efl_Object * klass )
2014-04-20 20:46:11 -07:00
{
2018-02-14 18:14:52 -08:00
if ( efl_isa ( obj , klass ) )
{
2018-04-03 04:27:30 -07:00
if ( klass = = EFL_ACCESS_OBJECT_MIXIN )
2018-02-14 18:14:52 -08:00
{
2018-04-03 04:27:30 -07:00
Efl_Access_Type type = efl_access_object_access_type_get ( obj ) ;
2018-02-14 18:14:52 -08:00
if ( type ! = EFL_ACCESS_TYPE_SKIPPED ) return ( Eo * ) obj ;
}
else return ( Eo * ) obj ;
}
2018-04-03 04:27:30 -07:00
return efl_provider_find ( efl_super ( obj , EFL_ACCESS_OBJECT_MIXIN ) , klass ) ;
2014-04-20 20:46:11 -07:00
}
2014-05-28 01:12:34 -07:00
EOLIAN Eina_List *
2018-04-03 04:27:30 -07:00
_efl_access_object_attributes_get ( const Eo * obj EINA_UNUSED , Efl_Access_Object_Data * pd )
2014-04-20 20:46:11 -07:00
{
2017-11-21 18:54:44 -08:00
Eina_List * attr_list = NULL ;
if ( pd - > attr_list )
{
Eina_List * l = NULL ;
Efl_Access_Attribute * t_attr = NULL ;
EINA_LIST_FOREACH ( pd - > attr_list , l , t_attr )
{
Efl_Access_Attribute * attr = calloc ( 1 , sizeof ( Efl_Access_Attribute ) ) ;
if ( ! attr )
return attr_list ;
attr - > key = eina_stringshare_add ( t_attr - > key ) ;
attr - > value = eina_stringshare_add ( t_attr - > value ) ;
attr_list = eina_list_append ( attr_list , attr ) ;
}
}
return attr_list ;
}
EOLIAN static void
2018-04-03 04:27:30 -07:00
_efl_access_object_attribute_append ( Eo * obj EINA_UNUSED , Efl_Access_Object_Data * pd , const char * key , const char * value )
2017-11-21 18:54:44 -08:00
{
Eina_List * l ;
Efl_Access_Attribute * attr = NULL ;
if ( ! key | | ! value ) return ;
/* Check existing attributes has this key */
EINA_LIST_FOREACH ( pd - > attr_list , l , attr )
{
if ( ! strcmp ( ( const char * ) attr - > key , key ) )
{
eina_stringshare_replace ( & attr - > value , value ) ;
return ;
}
}
/* Add new attribute */
attr = calloc ( 1 , sizeof ( Efl_Access_Attribute ) ) ;
if ( ! attr ) return ;
attr - > key = eina_stringshare_add ( key ) ;
attr - > value = eina_stringshare_add ( value ) ;
pd - > attr_list = eina_list_append ( pd - > attr_list , attr ) ;
}
2018-04-03 04:27:30 -07:00
EOLIAN static void _efl_access_object_attributes_clear ( Eo * obj EINA_UNUSED , Efl_Access_Object_Data * pd )
2017-11-21 18:54:44 -08:00
{
if ( ! pd - > attr_list ) return ;
Efl_Access_Attribute * attr ;
EINA_LIST_FREE ( pd - > attr_list , attr )
{
eina_stringshare_del ( attr - > key ) ;
eina_stringshare_del ( attr - > value ) ;
free ( attr ) ;
}
pd - > attr_list = NULL ;
2014-04-20 20:46:11 -07:00
}
2017-11-22 19:07:52 -08:00
EOLIAN static void
2018-04-03 04:27:30 -07:00
_efl_access_object_reading_info_type_set ( Eo * obj , Efl_Access_Object_Data * pd , Efl_Access_Reading_Info_Type reading_info )
2017-11-22 19:07:52 -08:00
{
Eina_Strbuf * buf = NULL ;
pd - > reading_info = reading_info ;
buf = eina_strbuf_new ( ) ;
eina_strbuf_reset ( buf ) ;
if ( reading_info & ( EFL_ACCESS_READING_INFO_TYPE_NAME ) )
{
eina_strbuf_append ( buf , " name " ) ;
eina_strbuf_append_char ( buf , ' | ' ) ;
}
if ( reading_info & ( EFL_ACCESS_READING_INFO_TYPE_ROLE ) )
{
eina_strbuf_append ( buf , " role " ) ;
eina_strbuf_append_char ( buf , ' | ' ) ;
}
if ( reading_info & ( EFL_ACCESS_READING_INFO_TYPE_DESCRIPTION ) )
{
eina_strbuf_append ( buf , " description " ) ;
eina_strbuf_append_char ( buf , ' | ' ) ;
}
if ( reading_info & ( EFL_ACCESS_READING_INFO_TYPE_STATE ) )
{
eina_strbuf_append ( buf , " state " ) ;
}
2018-04-03 04:27:30 -07:00
efl_access_object_attribute_append ( obj , " reading_info_type " , eina_strbuf_string_get ( buf ) ) ;
2017-11-22 19:07:52 -08:00
eina_strbuf_free ( buf ) ;
}
EOLIAN Efl_Access_Reading_Info_Type
2018-04-03 04:27:30 -07:00
_efl_access_object_reading_info_type_get ( const Eo * obj EINA_UNUSED , Efl_Access_Object_Data * pd )
2017-11-22 19:07:52 -08:00
{
return pd - > reading_info ;
}
2017-10-18 18:13:54 -07:00
EOLIAN static Efl_Access_Role
2018-04-03 04:27:30 -07:00
_efl_access_object_role_get ( const Eo * obj EINA_UNUSED , Efl_Access_Object_Data * pd )
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
2018-04-03 04:27:30 -07:00
_efl_access_object_role_set ( Eo * obj , Efl_Access_Object_Data * pd , Efl_Access_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 ;
2017-10-18 18:13:54 -07:00
efl_access_role_changed_signal_emit ( obj ) ;
2015-10-01 08:24:42 -07:00
}
2014-04-20 20:46:11 -07:00
}
EOLIAN const char *
2018-04-03 04:27:30 -07:00
_efl_access_object_role_name_get ( const Eo * obj , Efl_Access_Object_Data * pd EINA_UNUSED )
2014-04-20 20:46:11 -07:00
{
2017-10-18 18:13:54 -07:00
Efl_Access_Role role ;
2014-04-20 20:46:11 -07:00
2018-04-03 04:27:30 -07:00
role = efl_access_object_role_get ( obj ) ;
2014-04-20 20:46:11 -07:00
2017-10-18 18:13:54 -07:00
return role > EFL_ACCESS_ROLE_LAST_DEFINED ? " " : Access_Name [ role ] ;
2014-04-20 20:46:11 -07:00
}
2016-11-09 17:58:41 -08:00
EOLIAN const char *
2018-04-03 04:27:30 -07:00
_efl_access_object_i18n_name_get ( const Eo * obj EINA_UNUSED , Efl_Access_Object_Data * pd )
2014-04-20 20:46:11 -07:00
{
2015-10-02 08:04:38 -07:00
# ifdef ENABLE_NLS
2016-11-09 17:58:41 -08:00
if ( pd - > translation_domain )
return dgettext ( pd - > translation_domain , pd - > name ) ;
2015-10-02 08:04:38 -07:00
# endif
2016-11-09 17:58:41 -08:00
return pd - > name ;
2014-04-20 20:46:11 -07:00
}
EOLIAN static void
2018-04-03 04:27:30 -07:00
_efl_access_object_i18n_name_set ( Eo * obj EINA_UNUSED , Efl_Access_Object_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 - > name , val ) ;
2014-04-20 20:46:11 -07:00
}
2018-04-03 04:27:30 -07:00
const char * _efl_access_object_description_get ( const Eo * obj EINA_UNUSED , Efl_Access_Object_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
2018-04-03 04:27:30 -07:00
_efl_access_object_description_set ( Eo * obj EINA_UNUSED , Efl_Access_Object_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 *
2018-04-03 04:27:30 -07:00
_efl_access_object_localized_role_name_get ( const Eo * obj , Efl_Access_Object_Data * pd EINA_UNUSED )
2014-04-20 20:46:11 -07:00
{
const char * ret = NULL ;
2018-04-03 04:27:30 -07:00
ret = efl_access_object_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 *
2018-04-03 04:27:30 -07:00
_efl_access_object_access_children_get ( const Eo * obj , Efl_Access_Object_Data * pd EINA_UNUSED )
2014-04-20 20:46:11 -07:00
{
Eina_List * children = NULL ;
Eina_Iterator * iter = NULL ;
Eo * chld ;
2016-08-10 07:23:04 -07:00
// By default use Efl_Object object hierarchy
2018-04-17 11:09:44 -07:00
/* XXX const */
iter = efl_children_iterator_new ( ( Eo * ) obj ) ;
2014-04-20 20:46:11 -07:00
if ( ! iter ) return NULL ;
EINA_ITERATOR_FOREACH ( iter , chld )
{
2018-04-03 04:27:30 -07:00
if ( efl_isa ( chld , EFL_ACCESS_OBJECT_MIXIN ) )
2014-04-20 20:46:11 -07:00
children = eina_list_append ( children , chld ) ;
}
eina_iterator_free ( iter ) ;
return children ;
}
2017-10-18 18:13:54 -07:00
EOLIAN static Efl_Access_State_Set
2018-04-03 04:27:30 -07:00
_efl_access_object_state_set_get ( const Eo * obj EINA_UNUSED , Efl_Access_Object_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
}
2018-05-04 14:17:15 -07:00
EOLIAN Eina_Iterator *
_efl_access_object_relations_get ( const Eo * obj EINA_UNUSED , Efl_Access_Object_Data * pd )
2014-05-28 01:12:34 -07:00
{
2018-05-04 14:17:15 -07:00
return eina_list_iterator_new ( pd - > relations ) ;
2014-05-28 01:12:34 -07:00
}
2019-01-14 11:43:21 -08:00
EAPI void
efl_access_attribute_free ( Efl_Access_Attribute * attr )
{
eina_stringshare_del ( attr - > key ) ;
eina_stringshare_del ( attr - > value ) ;
free ( attr ) ;
}
2017-10-18 18:13:54 -07:00
EAPI void efl_access_attributes_list_free ( Eina_List * list )
2014-05-28 01:12:34 -07:00
{
2017-10-18 18:13:54 -07:00
Efl_Access_Attribute * attr ;
2014-05-28 01:12:34 -07:00
EINA_LIST_FREE ( list , attr )
2014-07-21 06:44:16 -07:00
{
2019-01-14 11:43:21 -08:00
efl_access_attribute_free ( attr ) ;
2014-07-21 06:44:16 -07:00
}
2014-05-28 01:12:34 -07:00
}
2015-09-03 05:07:23 -07:00
EOLIAN void
2019-02-09 09:45:27 -08:00
_efl_access_object_event_emit ( Eo * accessible , const Efl_Event_Description * event , void * event_info )
2015-09-03 05:07:23 -07:00
{
Eina_List * l ;
2017-10-18 18:13:54 -07:00
Efl_Access_Event_Handler * hdl ;
Efl_Access_Type type ;
2015-09-03 05:07:23 -07:00
2018-04-03 04:27:30 -07:00
if ( ! accessible | | ! event | | ! efl_isa ( accessible , EFL_ACCESS_OBJECT_MIXIN ) )
2015-09-03 05:07:23 -07:00
{
2016-08-15 06:44:41 -07:00
CRI ( " Invalid parameters, event: %s, obj: %s " , event ? event - > name : " NULL " , accessible ? efl_class_name_get ( accessible ) : " NULL " ) ;
2015-09-03 05:07:23 -07:00
return ;
}
2018-04-03 04:27:30 -07:00
type = efl_access_object_access_type_get ( accessible ) ;
2017-10-18 18:13:54 -07:00
if ( type ! = EFL_ACCESS_TYPE_REGULAR )
2015-11-26 07:53:32 -08:00
return ;
2018-04-03 04:27:30 -07:00
if ( event = = EFL_ACCESS_OBJECT_EVENT_CHILDREN_CHANGED )
2015-11-26 07:53:32 -08:00
{
2017-10-18 18:13:54 -07:00
Efl_Access_Event_Children_Changed_Data * event_data = event_info ;
2018-04-03 04:27:30 -07:00
type = efl_access_object_access_type_get ( event_data - > child ) ;
2017-10-18 18:13:54 -07:00
if ( type ! = EFL_ACCESS_TYPE_REGULAR )
2015-11-26 07:53:32 -08:00
return ;
}
2016-08-30 05:34:10 -07:00
Efl_Event ev ;
2016-05-18 08:17:36 -07:00
ev . object = accessible ;
2016-02-29 03:32:52 -08:00
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
}
}
2017-10-18 18:13:54 -07:00
EOLIAN Efl_Access_Event_Handler *
2019-02-09 09:45:27 -08:00
_efl_access_object_event_handler_add ( Efl_Event_Cb cb , void * data )
2015-09-03 05:07:23 -07:00
{
2017-10-18 18:13:54 -07:00
Efl_Access_Event_Handler * ret = calloc ( 1 , sizeof ( Efl_Access_Event_Handler ) ) ;
2019-01-29 06:23:44 -08:00
if ( ! ret ) return NULL ;
2015-09-03 05:07:23 -07:00
ret - > cb = cb ;
ret - > data = data ;
global_callbacks = eina_list_append ( global_callbacks , ret ) ;
return ret ;
}
2019-01-14 11:43:21 -08:00
EOLIAN void
2019-02-09 09:45:27 -08:00
_efl_access_object_event_handler_del ( Efl_Access_Event_Handler * handler )
2015-09-03 05:07:23 -07:00
{
Eina_List * l , * l2 ;
2017-10-18 18:13:54 -07:00
Efl_Access_Event_Handler * hdl ;
2015-09-03 05:07:23 -07:00
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
2018-04-03 04:27:30 -07:00
_efl_access_object_translation_domain_set ( Eo * obj EINA_UNUSED , Efl_Access_Object_Data * pd , const char * domain )
2015-10-02 08:04:38 -07:00
{
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 *
2018-04-03 04:27:30 -07:00
_efl_access_object_translation_domain_get ( const Eo * obj EINA_UNUSED , Efl_Access_Object_Data * pd )
2015-10-02 08:04:38 -07:00
{
return pd - > translation_domain ;
}
2016-06-20 07:31:31 -07:00
static void
2016-08-30 05:34:10 -07:00
_on_rel_obj_del ( void * data , const Efl_Event * event )
2015-10-04 13:30:31 -07:00
{
2018-05-04 14:17:15 -07:00
Efl_Access_Object_Data * sd = data ;
2017-10-18 18:13:54 -07:00
Efl_Access_Relation * rel ;
2015-10-04 13:30:31 -07:00
Eina_List * l , * l2 , * p , * p2 ;
Eo * rel_obj ;
2018-05-04 14:17:15 -07:00
EINA_LIST_FOREACH_SAFE ( sd - > relations , l , l2 , rel )
2015-10-04 13:30:31 -07:00
{
EINA_LIST_FOREACH_SAFE ( rel - > objects , p , p2 , rel_obj )
{
2018-05-04 14:17:15 -07:00
if ( rel_obj = = event - > object )
2015-10-04 13:30:31 -07:00
rel - > objects = eina_list_remove_list ( rel - > objects , p ) ;
}
if ( ! rel - > objects )
{
2018-05-04 14:17:15 -07:00
sd - > relations = eina_list_remove_list ( sd - > relations , l ) ;
2015-10-04 13:30:31 -07:00
free ( rel ) ;
}
}
}
2018-05-04 14:17:15 -07:00
static void
efl_access_relation_set_free ( Efl_Access_Object_Data * sd )
2015-10-04 13:30:31 -07:00
{
2017-10-18 18:13:54 -07:00
Efl_Access_Relation * rel ;
2018-05-04 14:17:15 -07:00
Eo * obj ;
2015-10-04 13:30:31 -07:00
2018-05-04 14:17:15 -07:00
EINA_LIST_FREE ( sd - > relations , rel )
{
Eina_List * l ;
2015-10-04 13:30:31 -07:00
2018-05-04 14:17:15 -07:00
EINA_LIST_FOREACH ( rel - > objects , l , obj )
efl_event_callback_del ( obj , EFL_EVENT_DEL , _on_rel_obj_del , sd ) ;
eina_list_free ( rel - > objects ) ;
free ( rel ) ;
}
}
EOLIAN static Eina_Bool
_efl_access_object_relationship_append ( Eo * obj EINA_UNUSED , Efl_Access_Object_Data * sd , Efl_Access_Relation_Type type , const Efl_Access_Object * relation )
{
Efl_Access_Relation * rel ;
Eina_List * l ;
EINA_LIST_FOREACH ( sd - > relations , l , rel )
2015-10-04 13:30:31 -07:00
{
if ( rel - > type = = type )
{
2018-05-04 14:17:15 -07:00
if ( ! eina_list_data_find ( rel - > objects , relation ) )
2015-10-04 13:30:31 -07:00
{
2018-05-04 14:17:15 -07:00
rel - > objects = eina_list_append ( rel - > objects , relation ) ;
efl_event_callback_add ( ( Eo * ) relation , EFL_EVENT_DEL , _on_rel_obj_del , sd ) ;
2015-10-04 13:30:31 -07:00
}
return EINA_TRUE ;
}
}
2017-10-18 18:13:54 -07:00
rel = calloc ( 1 , sizeof ( Efl_Access_Relation ) ) ;
2015-10-04 13:30:31 -07:00
if ( ! rel ) return EINA_FALSE ;
rel - > type = type ;
2018-05-04 14:17:15 -07:00
rel - > objects = eina_list_append ( rel - > objects , relation ) ;
sd - > relations = eina_list_append ( sd - > relations , rel ) ;
efl_event_callback_add ( ( Eo * ) relation , EFL_EVENT_DEL , _on_rel_obj_del , sd ) ;
2015-10-04 13:30:31 -07:00
return EINA_TRUE ;
}
2018-05-04 14:17:15 -07:00
EOLIAN static void
_efl_access_object_relationship_remove ( Eo * obj EINA_UNUSED , Efl_Access_Object_Data * sd , Efl_Access_Relation_Type type , const Efl_Access_Object * relation )
2015-10-04 13:30:31 -07:00
{
2017-10-18 18:13:54 -07:00
Efl_Access_Relation * rel ;
2018-05-04 14:17:15 -07:00
Eina_List * l ;
2015-10-04 13:30:31 -07:00
2018-05-04 14:17:15 -07:00
EINA_LIST_FOREACH ( sd - > relations , l , rel )
2015-10-04 13:30:31 -07:00
{
if ( rel - > type = = type )
{
2018-05-04 14:17:15 -07:00
if ( relation )
2015-10-04 13:30:31 -07:00
{
2018-05-04 14:17:15 -07:00
if ( eina_list_data_find ( rel - > objects , relation ) )
{
efl_event_callback_del ( ( Eo * ) relation , EFL_EVENT_DEL , _on_rel_obj_del , sd ) ;
rel - > objects = eina_list_remove ( rel - > objects , relation ) ;
}
if ( ! rel - > objects )
{
sd - > relations = eina_list_remove ( sd - > relations , rel ) ;
free ( rel ) ;
}
2015-10-04 13:30:31 -07:00
}
2018-05-04 14:17:15 -07:00
else
2015-10-04 13:30:31 -07:00
{
2018-05-04 14:17:15 -07:00
Eina_List * ll ;
Eo * ro ;
2015-10-04 13:30:31 -07:00
2018-05-04 14:17:15 -07:00
EINA_LIST_FOREACH ( rel - > objects , ll , ro )
efl_event_callback_del ( ro , EFL_EVENT_DEL , _on_rel_obj_del , sd ) ;
sd - > relations = eina_list_remove ( sd - > relations , rel ) ;
free ( rel ) ;
}
return ;
2015-10-04 13:30:31 -07:00
}
}
}
EOLIAN static void
2018-04-03 04:27:30 -07:00
_efl_access_object_relationships_clear ( Eo * obj EINA_UNUSED , Efl_Access_Object_Data * sd )
2015-10-04 13:30:31 -07:00
{
2018-05-04 14:17:15 -07:00
efl_access_relation_set_free ( sd ) ;
2015-10-04 13:30:31 -07:00
sd - > relations = NULL ;
}
2015-09-09 04:58:14 -07:00
EOLIAN Eo *
2019-02-09 09:45:27 -08:00
_efl_access_object_access_root_get ( void )
2015-09-09 04:58:14 -07:00
{
if ( ! root )
2018-03-19 15:38:26 -07:00
root = efl_add ( ELM_ATSPI_APP_OBJECT_CLASS , efl_main_loop_get ( ) ) ;
2015-09-09 04:58:14 -07:00
return root ;
}
2017-10-18 18:13:54 -07:00
EOLIAN Efl_Access_Type
2018-04-03 04:27:30 -07:00
_efl_access_object_access_type_get ( const Eo * obj EINA_UNUSED , Efl_Access_Object_Data * pd )
2015-11-26 07:53:32 -08:00
{
return pd - > type ;
}
EOLIAN void
2018-04-03 04:27:30 -07:00
_efl_access_object_access_type_set ( Eo * obj , Efl_Access_Object_Data * pd , Efl_Access_Type val )
2015-11-26 07:53:32 -08:00
{
2018-04-03 04:27:30 -07:00
Efl_Access_Object * parent ;
2015-12-01 07:55:12 -08:00
if ( val = = pd - > type )
return ;
2018-04-03 04:27:30 -07:00
parent = efl_provider_find ( efl_parent_get ( obj ) , EFL_ACCESS_OBJECT_MIXIN ) ;
2015-12-15 07:49:02 -08:00
2015-12-01 07:55:12 -08:00
switch ( val )
{
2017-10-18 18:13:54 -07:00
case EFL_ACCESS_TYPE_DISABLED :
case EFL_ACCESS_TYPE_SKIPPED :
if ( parent ) efl_access_children_changed_del_signal_emit ( parent , obj ) ;
efl_access_removed ( obj ) ;
2015-12-01 07:55:12 -08:00
break ;
2017-10-18 18:13:54 -07:00
case EFL_ACCESS_TYPE_REGULAR :
if ( parent ) efl_access_children_changed_added_signal_emit ( parent , obj ) ;
efl_access_added ( obj ) ;
2015-12-01 07:55:12 -08:00
}
2015-11-26 07:53:32 -08:00
pd - > type = val ;
}
2018-05-04 14:17:15 -07:00
EOLIAN void
_efl_access_object_efl_object_invalidate ( Eo * obj , Efl_Access_Object_Data * pd )
{
efl_access_relation_set_free ( pd ) ;
efl_invalidate ( efl_super ( obj , EFL_ACCESS_OBJECT_MIXIN ) ) ;
}
2016-11-14 11:10:57 -08:00
EOLIAN void
2018-04-03 04:27:30 -07:00
_efl_access_object_efl_object_destructor ( Eo * obj , Efl_Access_Object_Data * pd )
2016-11-14 11:10:57 -08:00
{
eina_stringshare_del ( pd - > name ) ;
eina_stringshare_del ( pd - > description ) ;
eina_stringshare_del ( pd - > translation_domain ) ;
2018-04-03 04:27:30 -07:00
efl_destructor ( efl_super ( obj , EFL_ACCESS_OBJECT_MIXIN ) ) ;
2016-11-14 11:10:57 -08:00
}
2017-09-26 01:14:19 -07:00
void
2017-10-18 18:13:54 -07:00
_efl_access_shutdown ( void )
2017-09-26 01:14:19 -07:00
{
2017-10-18 18:13:54 -07:00
Efl_Access_Event_Handler * hdl ;
2017-09-26 01:56:56 -07:00
EINA_LIST_FREE ( global_callbacks , hdl )
free ( hdl ) ;
2017-09-26 01:14:19 -07:00
ELM_SAFE_DEL ( root ) ;
}
2018-04-03 04:27:30 -07:00
# include "efl_access_object.eo.c"