enlightenment/efl
enlightenment
/
efl
8
7
Fork 14
Code Issues 13 Pull Requests 1 Projects Releases Wiki Activity

Eo: Rename most of Eo to the Efl prefix. 

This includes Eo.Base -> Efl.Object and many (but not all) of the eo
functions. This commit is only for eo itself, not the rest of the EFL.
This commit is contained in:
Tom Hacohen 2016-08-09 14:10:05 +01:00
parent 4bbe8733c4
commit e64e120a51
12 changed files with 442 additions and 442 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/Makefile_Eo.am
View File

@ -2,10 +2,10 @@
### Library ### Library
eo_eolian_files = \ eo_eolian_files = \
lib/eo/eo_base.eo \ lib/eo/efl_object.eo \
lib/eo/eo_class.eo \ lib/eo/efl_class.eo \
lib/eo/eo_override.eo \ lib/eo/efl_object_override.eo \
lib/eo/eo_interface.eo lib/eo/efl_interface.eo
eo_eolian_c = $(eo_eolian_files:%.eo=%.eo.c) eo_eolian_c = $(eo_eolian_files:%.eo=%.eo.c)
eo_eolian_h = $(eo_eolian_files:%.eo=%.eo.h) eo_eolian_h = $(eo_eolian_files:%.eo=%.eo.h)

204
src/lib/eo/Eo.h
View File

@ -89,8 +89,8 @@ extern "C" {
* *
* Recommended reading: * Recommended reading:
* *
* @li @ref Eo_Class_Base * @li @ref Efl_Class_Base
* @li @ref Eo_Class * @li @ref Efl_Class
* @li @ref Eo_Events * @li @ref Eo_Events
* @li @ref Eo_Composite_Objects * @li @ref Eo_Composite_Objects
* *
@ -113,14 +113,14 @@ typedef struct _Eo_Object _Eo_Object;
typedef struct _Eo_Opaque Eo; typedef struct _Eo_Opaque Eo;
/** /**
* @typedef Eo_Class * @typedef Efl_Class
* The basic class type - should be removed, just for compat. * The basic class type - should be removed, just for compat.
*/ */
typedef Eo Eo_Class; typedef Eo Efl_Class;
#define _EO_CLASS_EO_CLASS_TYPE #define _EFL_CLASS_EO_CLASS_TYPE
typedef Eo Eo_Base; typedef Eo Efl_Object;
#define _EO_BASE_EO_CLASS_TYPE #define _EFL_BASE_EO_CLASS_TYPE
#ifdef EFL_BETA_API_SUPPORT #ifdef EFL_BETA_API_SUPPORT
@ -174,10 +174,10 @@ typedef enum _Eo_Op_Type Eo_Op_Type;
*/ */
typedef void (*Eo_Del_Intercept) (Eo *obj_id); typedef void (*Eo_Del_Intercept) (Eo *obj_id);
#include "eo_override.eo.h" #include "efl_object_override.eo.h"
#include "eo_base.eo.h" #include "efl_object.eo.h"
#include "eo_interface.eo.h" #include "efl_interface.eo.h"
#define EO_CLASS EO_BASE_CLASS #define EO_CLASS EFL_OBJECT_CLASS
/** /**
* @addtogroup Eo_Debug_Information Eo's Debug information helper. * @addtogroup Eo_Debug_Information Eo's Debug information helper.
@ -196,10 +196,10 @@ EAPI extern const Eina_Value_Type *EO_DBG_INFO_TYPE;
* @param[in] name name of the list * @param[in] name name of the list
* @return the new list * @return the new list
*/ */
static inline Eo_Dbg_Info * static inline Efl_Dbg_Info *
EO_DBG_INFO_LIST_APPEND(Eo_Dbg_Info *list, const char *name) EO_DBG_INFO_LIST_APPEND(Efl_Dbg_Info *list, const char *name)
{ {
Eo_Dbg_Info *tmp = (Eo_Dbg_Info *)calloc(1, sizeof(*tmp)); Efl_Dbg_Info *tmp = (Efl_Dbg_Info *)calloc(1, sizeof(*tmp));
if (!tmp) return NULL; if (!tmp) return NULL;
tmp->name = eina_stringshare_add(name); tmp->name = eina_stringshare_add(name);
@ -214,17 +214,17 @@ EO_DBG_INFO_LIST_APPEND(Eo_Dbg_Info *list, const char *name)
/** /**
* @def EO_DBG_INFO_APPEND * @def EO_DBG_INFO_APPEND
* Creates a new debug info into a list * Creates a new debug info into a list
* @param[in] LIST list where to append (Eo_Dbg_Info *) * @param[in] LIST list where to append (Efl_Dbg_Info *)
* @param[in] NAME name of the parameter (const char *) * @param[in] NAME name of the parameter (const char *)
* @param[in] TYPE type of the parameter (Eina_Value_Type *) * @param[in] TYPE type of the parameter (Eina_Value_Type *)
* @param[in] VALUE value of the parameter * @param[in] VALUE value of the parameter
*/ */
#define EO_DBG_INFO_APPEND(LIST, NAME, TYPE, VALUE) \ #define EO_DBG_INFO_APPEND(LIST, NAME, TYPE, VALUE) \
do { \ do { \
Eo_Dbg_Info *List = LIST; \ Efl_Dbg_Info *List = LIST; \
if (List) \ if (List) \
{ \ { \
Eo_Dbg_Info *Tmp = calloc(1, sizeof(*Tmp)); \ Efl_Dbg_Info *Tmp = calloc(1, sizeof(*Tmp)); \
\ \
if (!Tmp) break; \ if (!Tmp) break; \
Tmp->name = eina_stringshare_add(NAME); \ Tmp->name = eina_stringshare_add(NAME); \
@ -235,10 +235,10 @@ do { \
} while (0) } while (0)
/** /**
* Frees the Eo_Dbg_Info tree. (The whole tree recursively). * Frees the Efl_Dbg_Info tree. (The whole tree recursively).
* @param[in] info The tree to delete. * @param[in] info The tree to delete.
*/ */
EAPI void eo_dbg_info_free(Eo_Dbg_Info *info); EAPI void eo_dbg_info_free(Efl_Dbg_Info *info);
/** /**
* @} * @}
@ -262,40 +262,40 @@ typedef unsigned int Eo_Op;
*/ */
/** /**
* @def EO_EVENT_DESCRIPTION(name) * @def EFL_EVENT_DESCRIPTION(name)
* An helper macro to help populating #Eo_Event_Description * An helper macro to help populating #Efl_Event_Description
* @param name The name of the event. * @param name The name of the event.
* @see Eo_Event_Description * @see Efl_Event_Description
*/ */
#define EO_EVENT_DESCRIPTION(name) { name, EINA_FALSE, EINA_FALSE, EINA_FALSE } #define EFL_EVENT_DESCRIPTION(name) { name, EINA_FALSE, EINA_FALSE, EINA_FALSE }
/** /**
* @def EO_EVENT_DESCRIPTION_HOT(name) * @def EFL_EVENT_DESCRIPTION_HOT(name)
* An helper macro to help populating #Eo_Event_Description and make * An helper macro to help populating #Efl_Event_Description and make
* the event impossible to freeze. * the event impossible to freeze.
* @param name The name of the event. * @param name The name of the event.
* @see Eo_Event_Description * @see Efl_Event_Description
* @see EO_EVENT_DESCRIPTION * @see EFL_EVENT_DESCRIPTION
*/ */
#define EO_EVENT_DESCRIPTION_HOT(name) { name, EINA_TRUE, EINA_FALSE, EINA_FALSE } #define EFL_EVENT_DESCRIPTION_HOT(name) { name, EINA_TRUE, EINA_FALSE, EINA_FALSE }
/** /**
* @def EO_EVENT_DESCRIPTION(name) * @def EFL_EVENT_DESCRIPTION(name)
* An helper macro to help populating #Eo_Event_Description * An helper macro to help populating #Efl_Event_Description
* @param name The name of the event. * @param name The name of the event.
* @see Eo_Event_Description * @see Efl_Event_Description
*/ */
#define EO_EVENT_DESCRIPTION_RESTART(name) { name, EINA_FALSE, EINA_FALSE, EINA_TRUE } #define EFL_EVENT_DESCRIPTION_RESTART(name) { name, EINA_FALSE, EINA_FALSE, EINA_TRUE }
/** /**
* @def EO_EVENT_DESCRIPTION_HOT(name) * @def EFL_EVENT_DESCRIPTION_HOT(name)
* An helper macro to help populating #Eo_Event_Description and make * An helper macro to help populating #Efl_Event_Description and make
* the event impossible to freeze. * the event impossible to freeze.
* @param name The name of the event. * @param name The name of the event.
* @see Eo_Event_Description * @see Efl_Event_Description
* @see EO_EVENT_DESCRIPTION * @see EFL_EVENT_DESCRIPTION
*/ */
#define EO_EVENT_DESCRIPTION_HOT_RESTART(name) { name, EINA_TRUE, EINA_FALSE, EINA_TRUE } #define EFL_EVENT_DESCRIPTION_HOT_RESTART(name) { name, EINA_TRUE, EINA_FALSE, EINA_TRUE }
@ -304,7 +304,7 @@ typedef unsigned int Eo_Op;
*/ */
/** /**
* @addtogroup Eo_Class Eo Class * @addtogroup Efl_Class Efl Class
* @{ * @{
*/ */
@ -321,13 +321,13 @@ typedef unsigned int Eo_Op;
* You must use this macro if you want thread safety in class creation. * You must use this macro if you want thread safety in class creation.
*/ */
#define EO_DEFINE_CLASS(class_get_func_name, class_desc, parent_class, ...) \ #define EO_DEFINE_CLASS(class_get_func_name, class_desc, parent_class, ...) \
const Eo_Class * \ const Efl_Class * \
class_get_func_name(void) \ class_get_func_name(void) \
{ \ { \
const Eo_Class *_tmp_parent_class; \ const Efl_Class *_tmp_parent_class; \
static volatile unsigned char lk_init = 0; \ static volatile unsigned char lk_init = 0; \
static Eina_Spinlock _my_lock; \ static Eina_Spinlock _my_lock; \
static const Eo_Class * volatile _my_class = NULL; \ static const Efl_Class * volatile _my_class = NULL; \
static unsigned int _my_init_generation = 1; \ static unsigned int _my_init_generation = 1; \
if (EINA_UNLIKELY(_eo_init_generation != _my_init_generation)) \ if (EINA_UNLIKELY(_eo_init_generation != _my_init_generation)) \
{ \ { \
@ -365,7 +365,7 @@ class_get_func_name(void) \
/** /**
* An enum representing the possible types of an Eo class. * An enum representing the possible types of an Eo class.
*/ */
enum _Eo_Class_Type enum _Efl_Class_Type
{ {
EO_CLASS_TYPE_REGULAR = 0, /**< Regular class. */ EO_CLASS_TYPE_REGULAR = 0, /**< Regular class. */
EO_CLASS_TYPE_REGULAR_NO_INSTANT, /**< Regular non instant-able class. */ EO_CLASS_TYPE_REGULAR_NO_INSTANT, /**< Regular non instant-able class. */
@ -374,10 +374,10 @@ enum _Eo_Class_Type
}; };
/** /**
* @typedef Eo_Class_Type * @typedef Efl_Class_Type
* A convenience typedef for #_Eo_Class_Type. * A convenience typedef for #_Efl_Class_Type.
*/ */
typedef enum _Eo_Class_Type Eo_Class_Type; typedef enum _Efl_Class_Type Efl_Class_Type;
/** /**
* @def EO_VERSION * @def EO_VERSION
@ -385,12 +385,12 @@ typedef enum _Eo_Class_Type Eo_Class_Type;
*/ */
#define EO_VERSION 2 #define EO_VERSION 2
typedef struct _Eo_Op_Description typedef struct _Efl_Op_Description
{ {
void *api_func; /**< The EAPI function offering this op. (The name of the func on windows) */ void *api_func; /**< The EAPI function offering this op. (The name of the func on windows) */
void *func; /**< The static function to call for the op. */ void *func; /**< The static function to call for the op. */
Eo_Op_Type op_type; /**< The type of the Op. */ Eo_Op_Type op_type; /**< The type of the Op. */
} Eo_Op_Description; } Efl_Op_Description;
/** /**
* @struct _Eo_Ops * @struct _Eo_Ops
@ -400,33 +400,33 @@ typedef struct _Eo_Op_Description
*/ */
typedef struct _Eo_Ops typedef struct _Eo_Ops
{ {
const Eo_Op_Description *descs; /**< The op descriptions array of size count. */ const Efl_Op_Description *descs; /**< The op descriptions array of size count. */
size_t count; /**< Number of op descriptions. */ size_t count; /**< Number of op descriptions. */
} Eo_Ops; } Eo_Ops;
/** /**
* @struct _Eo_Class_Description * @struct _Efl_Class_Description
* This struct holds the description of a class. * This struct holds the description of a class.
* This description should be passed to eo_class_new. * This description should be passed to eo_class_new.
* Please use the #EO_CLASS_DESCRIPTION_OPS macro when populating it. * Please use the #EO_CLASS_DESCRIPTION_OPS macro when populating it.
*/ */
struct _Eo_Class_Description struct _Efl_Class_Description
{ {
unsigned int version; /**< The current version of eo, use #EO_VERSION */ unsigned int version; /**< The current version of eo, use #EO_VERSION */
const char *name; /**< The name of the class. */ const char *name; /**< The name of the class. */
Eo_Class_Type type; /**< The type of the class. */ Efl_Class_Type type; /**< The type of the class. */
Eo_Ops ops; /**< The ops description, should be filled using #EO_CLASS_DESCRIPTION_OPS (later sorted by Eo). */ Eo_Ops ops; /**< The ops description, should be filled using #EO_CLASS_DESCRIPTION_OPS (later sorted by Eo). */
const Eo_Event_Description **events; /**< The event descriptions for this class. */ const Efl_Event_Description **events; /**< The event descriptions for this class. */
size_t data_size; /**< The size of data (private + protected + public) this class needs per object. */ size_t data_size; /**< The size of data (private + protected + public) this class needs per object. */
void (*class_constructor)(Eo_Class *klass); /**< The constructor of the class. */ void (*class_constructor)(Efl_Class *klass); /**< The constructor of the class. */
void (*class_destructor)(Eo_Class *klass); /**< The destructor of the class. */ void (*class_destructor)(Efl_Class *klass); /**< The destructor of the class. */
}; };
/** /**
* @typedef Eo_Class_Description * @typedef Efl_Class_Description
* A convenience typedef for #_Eo_Class_Description * A convenience typedef for #_Efl_Class_Description
*/ */
typedef struct _Eo_Class_Description Eo_Class_Description; typedef struct _Efl_Class_Description Efl_Class_Description;
/** /**
* @brief Create a new class. * @brief Create a new class.
@ -440,7 +440,7 @@ typedef struct _Eo_Class_Description Eo_Class_Description;
* *
* @see #EO_DEFINE_CLASS * @see #EO_DEFINE_CLASS
*/ */
EAPI const Eo_Class *eo_class_new(const Eo_Class_Description *desc, const Eo_Class *parent, ...); EAPI const Efl_Class *eo_class_new(const Efl_Class_Description *desc, const Efl_Class *parent, ...);
/** /**
* @brief Override Eo functions of this object. * @brief Override Eo functions of this object.
@ -479,7 +479,7 @@ EAPI Eina_Bool eo_override(Eo *obj, const Eo_Ops *ops);
* @see eo_override * @see eo_override
*/ */
#define EO_OVERRIDE_OPS_DEFINE(ops, ...) \ #define EO_OVERRIDE_OPS_DEFINE(ops, ...) \
const Eo_Op_Description _##ops##_descs[] = { __VA_ARGS__ }; \ const Efl_Op_Description _##ops##_descs[] = { __VA_ARGS__ }; \
const Eo_Ops ops = { _##ops##_descs, EINA_C_ARRAY_LENGTH(_##ops##_descs) } const Eo_Ops ops = { _##ops##_descs, EINA_C_ARRAY_LENGTH(_##ops##_descs) }
/** /**
@ -490,7 +490,7 @@ EAPI Eina_Bool eo_override(Eo *obj, const Eo_Ops *ops);
* *
* Notice: This function does not support composite objects. * Notice: This function does not support composite objects.
*/ */
EAPI Eina_Bool eo_isa(const Eo *obj, const Eo_Class *klass); EAPI Eina_Bool eo_isa(const Eo *obj, const Efl_Class *klass);
/** /**
* @brief Gets the name of the passed class. * @brief Gets the name of the passed class.
@ -499,7 +499,7 @@ EAPI Eina_Bool eo_isa(const Eo *obj, const Eo_Class *klass);
* *
* @see eo_class_get() * @see eo_class_get()
*/ */
EAPI const char *eo_class_name_get(const Eo_Class *klass); EAPI const char *eo_class_name_get(const Efl_Class *klass);
/** /**
* @} * @}
@ -521,7 +521,7 @@ EAPI Eina_Bool eo_init(void);
*/ */
EAPI Eina_Bool eo_shutdown(void); EAPI Eina_Bool eo_shutdown(void);
// Helpers macro to help populating #Eo_Class_Description. // Helpers macro to help populating #Efl_Class_Description.
#define EO_CLASS_DESCRIPTION_NOOPS() { NULL, 0} #define EO_CLASS_DESCRIPTION_NOOPS() { NULL, 0}
#define EO_CLASS_DESCRIPTION_OPS(op_descs) { op_descs, EINA_C_ARRAY_LENGTH(op_descs) } #define EO_CLASS_DESCRIPTION_OPS(op_descs) { op_descs, EINA_C_ARRAY_LENGTH(op_descs) }
@ -679,7 +679,7 @@ EAPI void _eo_call_end(Eo_Op_Call_Data *call);
// end of the eo_add. Calls finalize among others // end of the eo_add. Calls finalize among others
EAPI Eo * _eo_add_end(Eo *obj, Eina_Bool is_ref, Eina_Bool is_fallback); EAPI Eo * _eo_add_end(Eo *obj, Eina_Bool is_ref, Eina_Bool is_fallback);
EAPI Eo *eo_super(const Eo *obj, const Eo_Class *cur_klass); EAPI Eo *eo_super(const Eo *obj, const Efl_Class *cur_klass);
/*****************************************************************************/ /*****************************************************************************/
@ -690,7 +690,7 @@ EAPI Eo *eo_super(const Eo *obj, const Eo_Class *cur_klass);
* *
* @see eo_class_name_get() * @see eo_class_name_get()
*/ */
EAPI const Eo_Class *eo_class_get(const Eo *obj); EAPI const Efl_Class *eo_class_get(const Eo *obj);
EAPI Eo *_eo_self_get(void); EAPI Eo *_eo_self_get(void);
@ -757,7 +757,7 @@ EAPI Eo *_eo_self_get(void);
*/ */
#define eo_add_ref(klass, parent, ...) _eo_add_common(klass, parent, EINA_TRUE, ##__VA_ARGS__) #define eo_add_ref(klass, parent, ...) _eo_add_common(klass, parent, EINA_TRUE, ##__VA_ARGS__)
EAPI Eo * _eo_add_internal_start(const char *file, int line, const Eo_Class *klass_id, Eo *parent, Eina_Bool ref, Eina_Bool is_fallback); EAPI Eo * _eo_add_internal_start(const char *file, int line, const Efl_Class *klass_id, Eo *parent, Eina_Bool ref, Eina_Bool is_fallback);
/** /**
* @brief Get a pointer to the data of an object for a specific class. * @brief Get a pointer to the data of an object for a specific class.
@ -770,7 +770,7 @@ EAPI Eo * _eo_add_internal_start(const char *file, int line, const Eo_Class *kla
* @see eo_data_ref() * @see eo_data_ref()
* @see eo_data_unref() * @see eo_data_unref()
*/ */
EAPI void *eo_data_scope_get(const Eo *obj, const Eo_Class *klass); EAPI void *eo_data_scope_get(const Eo *obj, const Efl_Class *klass);
/** /**
* @def eo_data_xref(obj, klass, ref_obj) * @def eo_data_xref(obj, klass, ref_obj)
@ -798,7 +798,7 @@ EAPI void *eo_data_scope_get(const Eo *obj, const Eo_Class *klass);
* *
* @see eo_data_xunref_internal() * @see eo_data_xunref_internal()
*/ */
EAPI void *eo_data_xref_internal(const char *file, int line, const Eo *obj, const Eo_Class *klass, const Eo *ref_obj); EAPI void *eo_data_xref_internal(const char *file, int line, const Eo *obj, const Efl_Class *klass, const Eo *ref_obj);
/** /**
* @def eo_data_xunref(obj, data, ref_obj) * @def eo_data_xunref(obj, data, ref_obj)
@ -888,18 +888,18 @@ EAPI int eo_ref_get(const Eo *obj);
* set the intercept function to NULL so it is not called again on the next * set the intercept function to NULL so it is not called again on the next
* "real deletion". * "real deletion".
* *
* @see eo_del_intercept_get() * @see efl_del_intercept_get()
* @see eo_unref() * @see eo_unref()
* @see eo_del() * @see efl_del()
*/ */
EAPI void eo_del_intercept_set(Eo *obj, Eo_Del_Intercept del_intercept_func); EAPI void efl_del_intercept_set(Eo *obj, Eo_Del_Intercept del_intercept_func);
/** /**
* @brief Get the deletion interceptor function * @brief Get the deletion interceptor function
* @param obj The object to get the interceptor of * @param obj The object to get the interceptor of
* @return The intercept function or NULL if none is set. * @return The intercept function or NULL if none is set.
* *
* This returns the interceptor function set by eo_del_intercept_set(). Note * This returns the interceptor function set by efl_del_intercept_set(). Note
* that objects by default have no interceptor (NULL) set, but certain * that objects by default have no interceptor (NULL) set, but certain
* classes may set one up in a constructor, so it is important to be able * classes may set one up in a constructor, so it is important to be able
* to get the interceptor function to know if this has happend and * to get the interceptor function to know if this has happend and
@ -907,9 +907,9 @@ EAPI void eo_del_intercept_set(Eo *obj, Eo_Del_Intercept del_intercept_func);
* own interceptor function has finished. It would generally be a bad idea * own interceptor function has finished. It would generally be a bad idea
* though to override these functions. * though to override these functions.
* *
* @see eo_del_intercept_set() * @see efl_del_intercept_set()
*/ */
EAPI Eo_Del_Intercept eo_del_intercept_get(const Eo *obj); EAPI Eo_Del_Intercept efl_del_intercept_get(const Eo *obj);
/** /**
* @def eo_xref(obj, ref_obj) * @def eo_xref(obj, ref_obj)
@ -988,27 +988,27 @@ EAPI Eina_Bool eo_manual_free(Eo *obj);
EAPI Eina_Bool eo_destructed_is(const Eo *obj); EAPI Eina_Bool eo_destructed_is(const Eo *obj);
/** /**
* @addtogroup Eo_Class_Class Eo's Class class. * @addtogroup Efl_Class_Class Eo's Class class.
* @{ * @{
*/ */
#include "eo_class.eo.h" #include "efl_class.eo.h"
/** /**
* @} * @}
*/ */
/** /**
* @addtogroup Eo_Class_Base Eo's Base class. * @addtogroup Efl_Class_Base Eo's Base class.
* @{ * @{
*/ */
/** /**
* @typedef eo_key_data_free_func * @typedef efl_key_data_free_func
* Data free func prototype. * Data free func prototype.
* XXX: DO NOT USE, only here for legacy. * XXX: DO NOT USE, only here for legacy.
*/ */
typedef void (*eo_key_data_free_func)(void *); typedef void (*efl_key_data_free_func)(void *);
/** /**
* @def eo_weak_ref * @def eo_weak_ref
@ -1016,11 +1016,11 @@ typedef void (*eo_key_data_free_func)(void *);
* @param wref the pointer to use for the weak ref * @param wref the pointer to use for the weak ref
* *
* @see eo_weak_unref * @see eo_weak_unref
* @see eo_wref_add * @see efl_wref_add
*/ */
#define eo_weak_ref(wref) \ #define eo_weak_ref(wref) \
do { \ do { \
if (*wref) eo_wref_add(*wref, wref); \ if (*wref) efl_wref_add(*wref, wref); \
} while (0) } while (0)
/** /**
@ -1029,22 +1029,22 @@ typedef void (*eo_key_data_free_func)(void *);
* @param wref the pointer to use for the weak unref * @param wref the pointer to use for the weak unref
* *
* @see eo_weak_ref * @see eo_weak_ref
* @see eo_wref_del * @see efl_wref_del
* @see eo_wref_del_safe * @see efl_wref_del_safe
*/ */
#define eo_weak_unref(wref) \ #define eo_weak_unref(wref) \
do { \ do { \
if (*wref) eo_wref_del(*wref, wref); \ if (*wref) efl_wref_del(*wref, wref); \
} while (0) } while (0)
/** /**
* @def eo_wref_del_safe * @def efl_wref_del_safe
* @brief Delete the weak reference passed. * @brief Delete the weak reference passed.
* @param wref the weak reference to free. * @param wref the weak reference to free.
* *
* @see #eo_wref_del * @see #efl_wref_del
*/ */
#define eo_wref_del_safe(wref) eo_weak_unref(wref) #define efl_wref_del_safe(wref) eo_weak_unref(wref)
/** /**
* @addtogroup Eo_Events Eo's Event Handling * @addtogroup Eo_Events Eo's Event Handling
@ -1057,7 +1057,7 @@ typedef void (*eo_key_data_free_func)(void *);
* anything about them. * anything about them.
* @internal * @internal
*/ */
EAPI const Eo_Event_Description *eo_base_legacy_only_event_description_get(const char *_event_name); EAPI const Efl_Event_Description *efl_object_legacy_only_event_description_get(const char *_event_name);
/** /**
* @def EO_CALLBACK_PRIORITY_BEFORE * @def EO_CALLBACK_PRIORITY_BEFORE
@ -1081,24 +1081,24 @@ EAPI const Eo_Event_Description *eo_base_legacy_only_event_description_get(const
* external symbols in it, because the addresses are only known at runtime. * external symbols in it, because the addresses are only known at runtime.
*/ */
#define EO_CALLBACKS_ARRAY_DEFINE(Name, ...) \ #define EO_CALLBACKS_ARRAY_DEFINE(Name, ...) \
static Eo_Callback_Array_Item * \ static Efl_Callback_Array_Item * \
Name(void) \ Name(void) \
{ \ { \
static Eo_Callback_Array_Item internal[sizeof ((Eo_Callback_Array_Item[]) { __VA_ARGS__ }) / \ static Efl_Callback_Array_Item internal[sizeof ((Efl_Callback_Array_Item[]) { __VA_ARGS__ }) / \
sizeof (Eo_Callback_Array_Item) + \ sizeof (Efl_Callback_Array_Item) + \
1] = { { 0, 0 } }; \ 1] = { { 0, 0 } }; \
if (internal[0].desc == NULL) \ if (internal[0].desc == NULL) \
{ \ { \
memcpy(internal, \ memcpy(internal, \
((Eo_Callback_Array_Item[]) { __VA_ARGS__, { NULL, NULL } }), \ ((Efl_Callback_Array_Item[]) { __VA_ARGS__, { NULL, NULL } }), \
sizeof (Eo_Callback_Array_Item) + \ sizeof (Efl_Callback_Array_Item) + \
sizeof ((Eo_Callback_Array_Item[]) { __VA_ARGS__ })); \ sizeof ((Efl_Callback_Array_Item[]) { __VA_ARGS__ })); \
} \ } \
return internal; \ return internal; \
} }
/** /**
* @def eo_event_callback_add(obj, desc, cb, data) * @def efl_event_callback_add(obj, desc, cb, data)
* Add a callback for an event. * Add a callback for an event.
* @param[in] desc The description of the event to listen to. * @param[in] desc The description of the event to listen to.
* @param[in] cb the callback to call. * @param[in] cb the callback to call.
@ -1106,24 +1106,24 @@ EAPI const Eo_Event_Description *eo_base_legacy_only_event_description_get(const
* *
* callbacks of the same priority are called in reverse order of creation. * callbacks of the same priority are called in reverse order of creation.
* *
* @see eo_event_callback_priority_add() * @see efl_event_callback_priority_add()
*/ */
#define eo_event_callback_add(obj, desc, cb, data) \ #define efl_event_callback_add(obj, desc, cb, data) \
eo_event_callback_priority_add(obj, desc, \ efl_event_callback_priority_add(obj, desc, \
EO_CALLBACK_PRIORITY_DEFAULT, cb, data) EO_CALLBACK_PRIORITY_DEFAULT, cb, data)
/** /**
* @def eo_event_callback_array_add(obj, desc, cb, data) * @def efl_event_callback_array_add(obj, desc, cb, data)
* Add a callback array for an event. * Add a callback array for an event.
* @param[in] array an #Eo_Callback_Array_Item of events to listen to. * @param[in] array an #Efl_Callback_Array_Item of events to listen to.
* @param[in] data additional data to pass to the callback. * @param[in] data additional data to pass to the callback.
* *
* callbacks of the same priority are called in reverse order of creation. * callbacks of the same priority are called in reverse order of creation.
* *
* @see eo_event_callback_array_priority_add() * @see efl_event_callback_array_priority_add()
*/ */
#define eo_event_callback_array_add(obj, array, data) \ #define efl_event_callback_array_add(obj, array, data) \
eo_event_callback_array_priority_add(obj, array, \ efl_event_callback_array_priority_add(obj, array, \
EO_CALLBACK_PRIORITY_DEFAULT, data) EO_CALLBACK_PRIORITY_DEFAULT, data)
/** /**

4
src/lib/eo/efl_class.eo Normal file
View File

@ -0,0 +1,4 @@
abstract Efl.Class ()
{
data: null;
}

4
src/lib/eo/eo_interface.eo → src/lib/eo/efl_interface.eo
View File

@ -1,7 +1,7 @@
interface Eo.Interface () interface Efl.Interface ()
{ {
[[An interface for other interfaces to inherit from. [[An interface for other interfaces to inherit from.
This is useful when you want to create interfaces and mixins that expose This is useful when you want to create interfaces and mixins that expose
functions from a normal class, like for example @Eo.Base.constructor.]] functions from a normal class, like for example @Efl.Object.constructor.]]
} }

86
src/lib/eo/eo_base.eo → src/lib/eo/efl_object.eo
View File

@ -1,6 +1,6 @@
import eina_types; import eina_types;
struct Eo.Event.Description { struct Efl.Event.Description {
[[This struct holds the description of a specific event.]] [[This struct holds the description of a specific event.]]
name: string; [[name of the event.]] name: string; [[name of the event.]]
unfreezable: bool; [[Eina_True if the event cannot be frozen.]] unfreezable: bool; [[Eina_True if the event cannot be frozen.]]
@ -10,32 +10,32 @@ struct Eo.Event.Description {
struct Eo.Event { struct Eo.Event {
[[Parameter passed in event callbacks holding extra event parameters]] [[Parameter passed in event callbacks holding extra event parameters]]
object: Eo.Base; [[The object the event was called on.]] object: Efl.Object; [[The object the event was called on.]]
desc: ref(const(Eo.Event.Description)); [[The event description.]] desc: ref(const(Efl.Event.Description)); [[The event description.]]
info: void_ptr; [[Extra event information passed by the event caller.]] info: void_ptr; [[Extra event information passed by the event caller.]]
} }
type Eo.Event_Cb: __builtin_event_cb; [[An event callback prototype. type Efl.Event_Cb: __builtin_event_cb; [[An event callback prototype.
return $EO_CALLBACK_STOP to stop calling additional callbacks for the event, $EO_CALLBACK_CONTINUE to continue.]] return $EO_CALLBACK_STOP to stop calling additional callbacks for the event, $EO_CALLBACK_CONTINUE to continue.]]
struct Eo.Callback_Array_Item { struct Efl.Callback_Array_Item {
[[An item in an array of callback desc/func. [[An item in an array of callback desc/func.
See also \@ref eo_event_callback_array_add. See also \@ref efl_event_callback_array_add.
]] ]]
desc: ref(const(Eo.Event.Description)); [[The event description.]] desc: ref(const(Efl.Event.Description)); [[The event description.]]
func: Eo.Event_Cb; [[The callback function.]] func: Efl.Event_Cb; [[The callback function.]]
} }
struct Eo.Dbg_Info { struct Efl.Dbg_Info {
[[The structure for the debug info used by Eo.]] [[The structure for the debug info used by Eo.]]
name: stringshare; [[The name of the part (stringshare).]] name: stringshare; [[The name of the part (stringshare).]]
value: generic_value; [[The value.]] value: generic_value; [[The value.]]
} }
type Eo.Callback_Priority: short; [[Callback priority value. Range is -32k - 32k. type Efl.Callback_Priority: short; [[Callback priority value. Range is -32k - 32k.
The lower the number, the higher the priority. The lower the number, the higher the priority.
See \@ref EO_CALLBACK_PRIORITY_AFTER, See \@ref EO_CALLBACK_PRIORITY_AFTER,
@ -43,9 +43,9 @@ type Eo.Callback_Priority: short; [[Callback priority value. Range is -32k - 32k
\@ref EO_CALLBACK_PRIORITY_DEFAULT \@ref EO_CALLBACK_PRIORITY_DEFAULT
]] ]]
abstract Eo.Base () abstract Efl.Object ()
{ {
eo_prefix: eo; eo_prefix: efl;
methods { methods {
@property parent { @property parent {
@ -53,7 +53,7 @@ abstract Eo.Base ()
Parents keep references to their children so in order to Parents keep references to their children so in order to
delete objects that have parents you need to set parent to delete objects that have parents you need to set parent to
NULL or use eo_del() that does that for you (and also unrefs NULL or use efl_del() that does that for you (and also unrefs
the object). the object).
The Eo parent is conceptually user set. That means that a parent The Eo parent is conceptually user set. That means that a parent
@ -70,13 +70,13 @@ abstract Eo.Base ()
get { get {
} }
values { values {
parent: Eo.Base @nullable; [[the new parent]] parent: Efl.Object @nullable; [[the new parent]]
} }
} }
del @const { del @const {
[[Unrefs the object and reparents it to NULL. [[Unrefs the object and reparents it to NULL.
Because eo_del() unrefs and reparents to NULL, it doesn't really delete the object. Because efl_del() unrefs and reparents to NULL, it doesn't really delete the object.
This method accepts a const object for convenience, so all objects This method accepts a const object for convenience, so all objects
could be passed to it easily. could be passed to it easily.
@ -156,16 +156,16 @@ abstract Eo.Base ()
If this is not done the class cannot be found up in the object tree. If this is not done the class cannot be found up in the object tree.
]] ]]
params { params {
klass : const(Eo.Base); [[The class identifier to search for]] klass : const(Efl.Object); [[The class identifier to search for]]
} }
return : Eo.Base; return : Efl.Object;
} }
constructor { constructor {
[[Call the object's constructor. [[Call the object's constructor.
Should not be used with #eo_do. Only use it with #eo_do_super. Should not be used with #eo_do. Only use it with #eo_do_super.
]] ]]
return: Eo.Base; [[The new object created, can be NULL if aborting]] return: Efl.Object; [[The new object created, can be NULL if aborting]]
} }
destructor { destructor {
[[Call the object's destructor. [[Call the object's destructor.
@ -175,7 +175,7 @@ abstract Eo.Base ()
} }
finalize { finalize {
[[Called at the end of #eo_add. Should not be called, just overridden.]] [[Called at the end of #eo_add. Should not be called, just overridden.]]
return: Eo.Base; [[The new object created, can be NULL if aborting]] return: Efl.Object; [[The new object created, can be NULL if aborting]]
} }
name_find { name_find {
[[Find a child object with the given name and return it. [[Find a child object with the given name and return it.
@ -188,7 +188,7 @@ abstract Eo.Base ()
params { params {
@in search: string; [[the name search string]] @in search: string; [[the name search string]]
} }
return: Eo.Base; [[the first object found]] return: Efl.Object; [[the first object found]]
} }
wref_add { wref_add {
[[Add a new weak reference to obj. [[Add a new weak reference to obj.
@ -200,13 +200,13 @@ abstract Eo.Base ()
being freed. being freed.
]] ]]
params { params {
@in wref: ref(Eo.Base); @in wref: ref(Efl.Object);
} }
} }
wref_del { wref_del {
[[Delete the weak reference passed.]] [[Delete the weak reference passed.]]
params { params {
@in wref: ref(Eo.Base); @in wref: ref(Efl.Object);
} }
} }
@property key_data { @property key_data {
@ -244,12 +244,12 @@ abstract Eo.Base ()
} }
set { set {
values { values {
objdata: const(Eo.Base); [[the object to set]] objdata: const(Efl.Object); [[the object to set]]
} }
} }
get { get {
values { values {
objdata: Eo.Base; [[the object to set]] objdata: Efl.Object; [[the object to set]]
} }
} }
} }
@ -267,12 +267,12 @@ abstract Eo.Base ()
} }
set { set {
values { values {
objdata: const(Eo.Base); [[the object to set]] objdata: const(Efl.Object); [[the object to set]]
} }
} }
get { get {
values { values {
objdata: Eo.Base; [[the object to set]] objdata: Efl.Object; [[the object to set]]
} }
} }
} }
@ -325,9 +325,9 @@ abstract Eo.Base ()
]] ]]
return: bool; [[Return true when the callback has been successfully added.]] return: bool; [[Return true when the callback has been successfully added.]]
params { params {
@in desc: ref(const(Eo.Event.Description)); [[The description of the event to listen to]] @in desc: ref(const(Efl.Event.Description)); [[The description of the event to listen to]]
@in priority: Eo.Callback_Priority; [[The priority of the callback]] @in priority: Efl.Callback_Priority; [[The priority of the callback]]
@in cb: Eo.Event_Cb; [[the callback to call]] @in cb: Efl.Event_Cb; [[the callback to call]]
@in data: const(void_ptr); [[additional data to pass to the callback]] @in data: const(void_ptr); [[additional data to pass to the callback]]
} }
} }
@ -335,8 +335,8 @@ abstract Eo.Base ()
[[Del a callback with a specific data associated to it for an event.]] [[Del a callback with a specific data associated to it for an event.]]
return: bool; [[Return true when the callback has been successfully removed.]] return: bool; [[Return true when the callback has been successfully removed.]]
params { params {
@in desc: ref(const(Eo.Event.Description)); [[The description of the event to listen to]] @in desc: ref(const(Efl.Event.Description)); [[The description of the event to listen to]]
@in func: Eo.Event_Cb; [[the callback to delete]] @in func: Efl.Event_Cb; [[the callback to delete]]
@in user_data: const(void_ptr); [[The data to compare]] @in user_data: const(void_ptr); [[The data to compare]]
} }
} }
@ -348,8 +348,8 @@ abstract Eo.Base ()
]] ]]
return: bool; [[Return true when the callback has been successfully added.]] return: bool; [[Return true when the callback has been successfully added.]]
params { params {
@in array: ref(const(Eo.Callback_Array_Item)); [[an #Eo_Callback_Array_Item of events to listen to]] @in array: ref(const(Efl.Callback_Array_Item)); [[an #Efl_Callback_Array_Item of events to listen to]]
@in priority: Eo.Callback_Priority; [[The priority of the callback]] @in priority: Efl.Callback_Priority; [[The priority of the callback]]
@in data: const(void_ptr); [[additional data to pass to the callback]] @in data: const(void_ptr); [[additional data to pass to the callback]]
} }
} }
@ -359,14 +359,14 @@ abstract Eo.Base ()
]] ]]
return: bool; [[Return true when the callback has been successfully removed.]] return: bool; [[Return true when the callback has been successfully removed.]]
params { params {
@in array: ref(const(Eo.Callback_Array_Item)); [[an #Eo_Callback_Array_Item of events to listen to]] @in array: ref(const(Efl.Callback_Array_Item)); [[an #Efl_Callback_Array_Item of events to listen to]]
@in user_data: const(void_ptr); [[The data to compare]] @in user_data: const(void_ptr); [[The data to compare]]
} }
} }
event_callback_call { event_callback_call {
[[Call the callbacks for an event of an object.]] [[Call the callbacks for an event of an object.]]
params { params {
@in desc: ref(const(Eo.Event.Description)); [[The description of the event to call]] @in desc: ref(const(Efl.Event.Description)); [[The description of the event to call]]
@in event_info: void_ptr; [[Extra event info to pass to the callbacks]] @in event_info: void_ptr; [[Extra event info to pass to the callbacks]]
} }
return: bool; [[$false if one of the callbacks aborted the call, return: bool; [[$false if one of the callbacks aborted the call,
@ -385,26 +385,26 @@ abstract Eo.Base ()
event_callback_forwarder_add { event_callback_forwarder_add {
[[Add an event callback forwarder for an event and an object.]] [[Add an event callback forwarder for an event and an object.]]
params { params {
@in desc: ref(const(Eo.Event.Description)); [[The description of the event to listen to]] @in desc: ref(const(Efl.Event.Description)); [[The description of the event to listen to]]
@in new_obj: Eo.Base; [[The object to emit events from]] @in new_obj: Efl.Object; [[The object to emit events from]]
} }
} }
event_callback_forwarder_del { event_callback_forwarder_del {
[[Remove an event callback forwarder for an event and an object.]] [[Remove an event callback forwarder for an event and an object.]]
params { params {
@in desc: ref(const(Eo.Event.Description)); [[The description of the event to listen to]] @in desc: ref(const(Efl.Event.Description)); [[The description of the event to listen to]]
@in new_obj: Eo.Base; [[The object to emit events from]] @in new_obj: Efl.Object; [[The object to emit events from]]
} }
} }
dbg_info_get { dbg_info_get {
[[Get dbg information from the object.]] [[Get dbg information from the object.]]
params { params {
@in root_node: ref(Eo.Dbg_Info); [[node of the tree]] @in root_node: ref(Efl.Dbg_Info); [[node of the tree]]
} }
} }
children_iterator_new { children_iterator_new {
[[Get an iterator on all childrens]] [[Get an iterator on all childrens]]
return: free(own(iterator<Eo.Base>), eina_iterator_free) @warn_unused; return: free(own(iterator<Efl.Object>), eina_iterator_free) @warn_unused;
} }
composite_attach { composite_attach {
[[Make an object a composite object of another. [[Make an object a composite object of another.
@ -416,7 +416,7 @@ abstract Eo.Base ()
See @.composite_detach, @.composite_part_is. See @.composite_detach, @.composite_part_is.
]] ]]
params { params {
@in comp_obj: Eo.Base; [[the object that will be used to composite the parent.]] @in comp_obj: Efl.Object; [[the object that will be used to composite the parent.]]
} }
return: bool; [[$true if successful. $false otherwise.]] return: bool; [[$true if successful. $false otherwise.]]
} }
@ -428,7 +428,7 @@ abstract Eo.Base ()
See @.composite_attach, @.composite_part_is. See @.composite_attach, @.composite_part_is.
]] ]]
params { params {
@in comp_obj: Eo.Base; [[the object that will be removed from the parent.]] @in comp_obj: Efl.Object; [[the object that will be removed from the parent.]]
} }
return: bool; [[$true if successful. $false otherwise.]] return: bool; [[$true if successful. $false otherwise.]]
} }

2
src/lib/eo/eo_override.eo → src/lib/eo/efl_object_override.eo
View File

@ -1,4 +1,4 @@
abstract Eo.Override () abstract Efl.Object.Override ()
{ {
[[A special class to pass to #eo_super() when using #eo_override() [[A special class to pass to #eo_super() when using #eo_override()

184
src/lib/eo/eo.c
View File

@ -13,7 +13,7 @@
#include "eo_private.h" #include "eo_private.h"
#include "eo_add_fallback.h" #include "eo_add_fallback.h"
#include "eo_override.eo.c" #include "efl_object_override.eo.c"
#define EO_CLASS_IDS_FIRST 1 #define EO_CLASS_IDS_FIRST 1
#define EO_OP_IDS_FIRST 1 #define EO_OP_IDS_FIRST 1
@ -23,7 +23,7 @@ EAPI Eina_Spinlock _eo_class_creation_lock;
EAPI unsigned int _eo_init_generation = 1; EAPI unsigned int _eo_init_generation = 1;
int _eo_log_dom = -1; int _eo_log_dom = -1;
static _Eo_Class **_eo_classes = NULL; static _Efl_Class **_eo_classes = NULL;
static Eo_Id _eo_classes_last_id = 0; static Eo_Id _eo_classes_last_id = 0;
static Eo_Id _eo_classes_alloc = 0; static Eo_Id _eo_classes_alloc = 0;
static int _eo_init_count = 0; static int _eo_init_count = 0;
@ -35,8 +35,8 @@ static size_t _eo_sz = 0;
static size_t _eo_class_sz = 0; static size_t _eo_class_sz = 0;
static void _eo_condtor_reset(_Eo_Object *obj); static void _eo_condtor_reset(_Eo_Object *obj);
static inline void *_eo_data_scope_get(const _Eo_Object *obj, const _Eo_Class *klass); static inline void *_eo_data_scope_get(const _Eo_Object *obj, const _Efl_Class *klass);
static inline void *_eo_data_xref_internal(const char *file, int line, _Eo_Object *obj, const _Eo_Class *klass, const _Eo_Object *ref_obj); static inline void *_eo_data_xref_internal(const char *file, int line, _Eo_Object *obj, const _Efl_Class *klass, const _Eo_Object *ref_obj);
static inline void _eo_data_xunref_internal(_Eo_Object *obj, void *data, const _Eo_Object *ref_obj); static inline void _eo_data_xunref_internal(_Eo_Object *obj, void *data, const _Eo_Object *ref_obj);
/* Start of Dich */ /* Start of Dich */
@ -53,7 +53,7 @@ static inline void _eo_data_xunref_internal(_Eo_Object *obj, void *data, const _
* substraction at compile time. */ * substraction at compile time. */
#define _UNMASK_ID(id) ((id) - MASK_CLASS_TAG) #define _UNMASK_ID(id) ((id) - MASK_CLASS_TAG)
#define ID_CLASS_GET(id) ({ \ #define ID_CLASS_GET(id) ({ \
(_Eo_Class *) (((_UNMASK_ID(id) <= _eo_classes_last_id) && (_UNMASK_ID(id) > 0)) ? \ (_Efl_Class *) (((_UNMASK_ID(id) <= _eo_classes_last_id) && (_UNMASK_ID(id) > 0)) ? \
(_eo_classes[_UNMASK_ID(id) - 1]) : NULL); \ (_eo_classes[_UNMASK_ID(id) - 1]) : NULL); \
}) })
@ -106,10 +106,10 @@ _vtable_func_get(const Eo_Vtable *vtable, Eo_Op op)
} }
/* XXX: Only used for a debug message below. Doesn't matter that it's slow. */ /* XXX: Only used for a debug message below. Doesn't matter that it's slow. */
static const _Eo_Class * static const _Efl_Class *
_eo_op_class_get(Eo_Op op) _eo_op_class_get(Eo_Op op)
{ {
_Eo_Class **itr = _eo_classes; _Efl_Class **itr = _eo_classes;
int mid, max, min; int mid, max, min;
min = 0; min = 0;
@ -130,7 +130,7 @@ _eo_op_class_get(Eo_Op op)
} }
static inline Eina_Bool static inline Eina_Bool
_vtable_func_set(Eo_Vtable *vtable, const _Eo_Class *klass, Eo_Op op, eo_op_func_type func) _vtable_func_set(Eo_Vtable *vtable, const _Efl_Class *klass, Eo_Op op, eo_op_func_type func)
{ {
op_type_funcs *fsrc; op_type_funcs *fsrc;
size_t idx1 = DICH_CHAIN1(op); size_t idx1 = DICH_CHAIN1(op);
@ -139,7 +139,7 @@ _vtable_func_set(Eo_Vtable *vtable, const _Eo_Class *klass, Eo_Op op, eo_op_func
fsrc = &chain1->funcs[DICH_CHAIN_LAST(op)]; fsrc = &chain1->funcs[DICH_CHAIN_LAST(op)];
if (fsrc->src == klass) if (fsrc->src == klass)
{ {
const _Eo_Class *op_kls = _eo_op_class_get(op); const _Efl_Class *op_kls = _eo_op_class_get(op);
ERR("Class '%s': Overriding already set func %p for op %d (%s) with %p.", ERR("Class '%s': Overriding already set func %p for op %d (%s) with %p.",
klass->desc->name, fsrc->func, op, op_kls->desc->name, func); klass->desc->name, fsrc->func, op, op_kls->desc->name, func);
return EINA_FALSE; return EINA_FALSE;
@ -189,18 +189,18 @@ _eo_is_a_class(const Eo *eo_id)
return !!(oid & MASK_CLASS_TAG); return !!(oid & MASK_CLASS_TAG);
} }
static inline _Eo_Class * static inline _Efl_Class *
_eo_class_pointer_get(const Eo_Class *klass_id) _eo_class_pointer_get(const Efl_Class *klass_id)
{ {
#ifdef HAVE_EO_ID #ifdef HAVE_EO_ID
return ID_CLASS_GET((Eo_Id)klass_id); return ID_CLASS_GET((Eo_Id)klass_id);
#else #else
return (_Eo_Class *) klass_id; return (_Efl_Class *) klass_id;
#endif #endif
} }
static const char * static const char *
_eo_op_desc_name_get(const Eo_Op_Description *desc) _eo_op_desc_name_get(const Efl_Op_Description *desc)
{ {
static const char *fct_name = "unknown"; static const char *fct_name = "unknown";
@ -222,9 +222,9 @@ _eo_op_desc_name_get(const Eo_Op_Description *desc)
} }
static inline const op_type_funcs * static inline const op_type_funcs *
_eo_kls_itr_next(const _Eo_Class *orig_kls, const _Eo_Class *cur_klass, Eo_Op op) _eo_kls_itr_next(const _Efl_Class *orig_kls, const _Efl_Class *cur_klass, Eo_Op op)
{ {
const _Eo_Class **kls_itr = NULL; const _Efl_Class **kls_itr = NULL;
/* Find the kls itr. */ /* Find the kls itr. */
kls_itr = orig_kls->mro; kls_itr = orig_kls->mro;
@ -251,11 +251,11 @@ _eo_kls_itr_next(const _Eo_Class *orig_kls, const _Eo_Class *cur_klass, Eo_Op op
/************************************ EO ************************************/ /************************************ EO ************************************/
static const _Eo_Class *_super_class = NULL; static const _Efl_Class *_super_class = NULL;
static Eina_Spinlock _super_class_lock; static Eina_Spinlock _super_class_lock;
EAPI Eo * EAPI Eo *
eo_super(const Eo *obj, const Eo_Class *cur_klass) eo_super(const Eo *obj, const Efl_Class *cur_klass)
{ {
EO_CLASS_POINTER_RETURN_VAL(cur_klass, klass, NULL); EO_CLASS_POINTER_RETURN_VAL(cur_klass, klass, NULL);
@ -269,8 +269,8 @@ eo_super(const Eo *obj, const Eo_Class *cur_klass)
EAPI Eina_Bool EAPI Eina_Bool
_eo_call_resolve(Eo *eo_id, const char *func_name, Eo_Op_Call_Data *call, Eo_Call_Cache *cache, const char *file, int line) _eo_call_resolve(Eo *eo_id, const char *func_name, Eo_Op_Call_Data *call, Eo_Call_Cache *cache, const char *file, int line)
{ {
const _Eo_Class *klass, *inputklass, *main_klass; const _Efl_Class *klass, *inputklass, *main_klass;
const _Eo_Class *cur_klass = NULL; const _Efl_Class *cur_klass = NULL;
_Eo_Object *obj = NULL; _Eo_Object *obj = NULL;
const Eo_Vtable *vtable = NULL; const Eo_Vtable *vtable = NULL;
const op_type_funcs *func; const op_type_funcs *func;
@ -301,9 +301,9 @@ _eo_call_resolve(Eo *eo_id, const char *func_name, Eo_Op_Call_Data *call, Eo_Cal
vtable = obj->vtable; vtable = obj->vtable;
if (_obj_is_override(obj) && cur_klass && if (_obj_is_override(obj) && cur_klass &&
(_eo_class_id_get(cur_klass) == EO_OVERRIDE_CLASS)) (_eo_class_id_get(cur_klass) == EFL_OBJECT_OVERRIDE_CLASS))
{ {
/* Doing a eo_super(obj, EO_OVERRIDE_CLASS) should result in calling /* Doing a eo_super(obj, EFL_OBJECT_OVERRIDE_CLASS) should result in calling
* as if it's a normal class. */ * as if it's a normal class. */
vtable = &klass->vtable; vtable = &klass->vtable;
cur_klass = NULL; cur_klass = NULL;
@ -494,13 +494,13 @@ _eo_api_func_equal(const void *api_func1, const void *api_func2)
/* api_func should be the pointer to the function on all platforms except windows, /* api_func should be the pointer to the function on all platforms except windows,
* in which it should be the the name of the function (string). * in which it should be the the name of the function (string).
*/ */
static inline const Eo_Op_Description * static inline const Efl_Op_Description *
_eo_api_desc_get(const void *api_func, const _Eo_Class *klass, const _Eo_Class **extns) _eo_api_desc_get(const void *api_func, const _Efl_Class *klass, const _Efl_Class **extns)
{ {
const _Eo_Class *cur_klass; const _Efl_Class *cur_klass;
const _Eo_Class **kls_itr = NULL; const _Efl_Class **kls_itr = NULL;
const Eo_Op_Description *op_desc; const Efl_Op_Description *op_desc;
const Eo_Op_Description *op_descs; const Efl_Op_Description *op_descs;
if (klass) if (klass)
{ {
@ -555,13 +555,13 @@ _eo_api_op_id_get(const void *api_func)
/* klass is the klass we are working on. hierarchy_klass is the class whe should /* klass is the klass we are working on. hierarchy_klass is the class whe should
* use when validating. */ * use when validating. */
static Eina_Bool static Eina_Bool
_eo_class_funcs_set(Eo_Vtable *vtable, const Eo_Ops *ops, const _Eo_Class *hierarchy_klass, const _Eo_Class *klass, Eina_Bool override_only) _eo_class_funcs_set(Eo_Vtable *vtable, const Eo_Ops *ops, const _Efl_Class *hierarchy_klass, const _Efl_Class *klass, Eina_Bool override_only)
{ {
unsigned int i; unsigned int i;
int op_id; int op_id;
const void *last_api_func; const void *last_api_func;
const Eo_Op_Description *op_desc; const Efl_Op_Description *op_desc;
const Eo_Op_Description *op_descs; const Efl_Op_Description *op_descs;
op_id = hierarchy_klass->base_id; op_id = hierarchy_klass->base_id;
op_descs = ops->descs; op_descs = ops->descs;
@ -610,7 +610,7 @@ _eo_class_funcs_set(Eo_Vtable *vtable, const Eo_Ops *ops, const _Eo_Class *hiera
} }
else if ((op_desc->op_type == EO_OP_TYPE_REGULAR_OVERRIDE) || (op_desc->op_type == EO_OP_TYPE_CLASS_OVERRIDE)) else if ((op_desc->op_type == EO_OP_TYPE_REGULAR_OVERRIDE) || (op_desc->op_type == EO_OP_TYPE_CLASS_OVERRIDE))
{ {
const Eo_Op_Description *api_desc; const Efl_Op_Description *api_desc;
if (override_only) if (override_only)
{ {
api_desc = _eo_api_desc_get(op_desc->api_func, hierarchy_klass, NULL); api_desc = _eo_api_desc_get(op_desc->api_func, hierarchy_klass, NULL);
@ -649,7 +649,7 @@ _eo_class_funcs_set(Eo_Vtable *vtable, const Eo_Ops *ops, const _Eo_Class *hiera
} }
EAPI Eo * EAPI Eo *
_eo_add_internal_start(const char *file, int line, const Eo_Class *klass_id, Eo *parent_id, Eina_Bool ref EINA_UNUSED, Eina_Bool is_fallback) _eo_add_internal_start(const char *file, int line, const Efl_Class *klass_id, Eo *parent_id, Eina_Bool ref EINA_UNUSED, Eina_Bool is_fallback)
{ {
_Eo_Object *obj; _Eo_Object *obj;
Eo_Stack_Frame *fptr = NULL; Eo_Stack_Frame *fptr = NULL;
@ -700,10 +700,10 @@ _eo_add_internal_start(const char *file, int line, const Eo_Class *klass_id, Eo
eo_ref(eo_id); eo_ref(eo_id);
/* Reference for the parent if is_ref is done in _eo_add_end */ /* Reference for the parent if is_ref is done in _eo_add_end */
eo_parent_set(eo_id, parent_id); efl_parent_set(eo_id, parent_id);
/* eo_id can change here. Freeing is done on the resolved object. */ /* eo_id can change here. Freeing is done on the resolved object. */
eo_id = eo_constructor(eo_id); eo_id = efl_constructor(eo_id);
if (!eo_id) if (!eo_id)
{ {
ERR("Object of class '%s' - Error while constructing object", ERR("Object of class '%s' - Error while constructing object",
@ -711,7 +711,7 @@ _eo_add_internal_start(const char *file, int line, const Eo_Class *klass_id, Eo
/* We have two refs at this point. */ /* We have two refs at this point. */
_eo_unref(obj); _eo_unref(obj);
eo_del((Eo *) obj->header.id); efl_del((Eo *) obj->header.id);
return NULL; return NULL;
} }
else if (eo_id != _eo_obj_id_get(obj)) else if (eo_id != _eo_obj_id_get(obj))
@ -719,7 +719,7 @@ _eo_add_internal_start(const char *file, int line, const Eo_Class *klass_id, Eo
EO_OBJ_POINTER_RETURN_VAL(eo_id, new_obj, NULL); EO_OBJ_POINTER_RETURN_VAL(eo_id, new_obj, NULL);
/* We have two refs at this point. */ /* We have two refs at this point. */
_eo_unref(obj); _eo_unref(obj);
eo_del((Eo *) obj->header.id); efl_del((Eo *) obj->header.id);
_eo_ref(new_obj); _eo_ref(new_obj);
} }
@ -739,7 +739,7 @@ _eo_add_internal_end(Eo *eo_id, Eo *finalized_id)
if (!obj->condtor_done) if (!obj->condtor_done)
{ {
const _Eo_Class *klass = obj->klass; const _Efl_Class *klass = obj->klass;
ERR("Object of class '%s' - Not all of the object constructors have been executed.", ERR("Object of class '%s' - Not all of the object constructors have been executed.",
klass->desc->name); klass->desc->name);
@ -770,17 +770,17 @@ _eo_add_internal_end(Eo *eo_id, Eo *finalized_id)
cleanup: cleanup:
_eo_unref(obj); _eo_unref(obj);
eo_del((Eo *) obj->header.id); efl_del((Eo *) obj->header.id);
return NULL; return NULL;
} }
EAPI Eo * EAPI Eo *
_eo_add_end(Eo *eo_id, Eina_Bool is_ref, Eina_Bool is_fallback) _eo_add_end(Eo *eo_id, Eina_Bool is_ref, Eina_Bool is_fallback)
{ {
Eo *ret = eo_finalize(eo_id); Eo *ret = efl_finalize(eo_id);
ret = _eo_add_internal_end(eo_id, ret); ret = _eo_add_internal_end(eo_id, ret);
if (is_ref && eo_parent_get(eo_id)) if (is_ref && efl_parent_get(eo_id))
{ {
eo_ref(eo_id); eo_ref(eo_id);
} }
@ -795,7 +795,7 @@ _eo_add_end(Eo *eo_id, Eina_Bool is_ref, Eina_Bool is_fallback)
/*****************************************************************************/ /*****************************************************************************/
EAPI const Eo_Class * EAPI const Efl_Class *
eo_class_get(const Eo *eo_id) eo_class_get(const Eo *eo_id)
{ {
if (_eo_is_a_class(eo_id)) if (_eo_is_a_class(eo_id))
@ -810,9 +810,9 @@ eo_class_get(const Eo *eo_id)
} }
EAPI const char * EAPI const char *
eo_class_name_get(const Eo_Class *eo_id) eo_class_name_get(const Efl_Class *eo_id)
{ {
const _Eo_Class *klass; const _Efl_Class *klass;
if (_eo_is_a_class(eo_id)) if (_eo_is_a_class(eo_id))
{ {
@ -836,9 +836,9 @@ _vtable_init(Eo_Vtable *vtable, size_t size)
} }
static void static void
_eo_class_base_op_init(_Eo_Class *klass) _eo_class_base_op_init(_Efl_Class *klass)
{ {
const Eo_Class_Description *desc = klass->desc; const Efl_Class_Description *desc = klass->desc;
klass->base_id = _eo_ops_last_id; klass->base_id = _eo_ops_last_id;
@ -849,9 +849,9 @@ _eo_class_base_op_init(_Eo_Class *klass)
#ifdef EO_DEBUG #ifdef EO_DEBUG
static Eina_Bool static Eina_Bool
_eo_class_mro_has(const _Eo_Class *klass, const _Eo_Class *find) _eo_class_mro_has(const _Efl_Class *klass, const _Efl_Class *find)
{ {
const _Eo_Class **itr; const _Efl_Class **itr;
for (itr = klass->mro ; *itr ; itr++) for (itr = klass->mro ; *itr ; itr++)
{ {
if (*itr == find) if (*itr == find)
@ -892,7 +892,7 @@ _eo_class_list_remove_duplicates(Eina_List* list)
} }
static Eina_List * static Eina_List *
_eo_class_mro_add(Eina_List *mro, const _Eo_Class *klass) _eo_class_mro_add(Eina_List *mro, const _Efl_Class *klass)
{ {
if (!klass) if (!klass)
return mro; return mro;
@ -901,11 +901,11 @@ _eo_class_mro_add(Eina_List *mro, const _Eo_Class *klass)
/* Recursively add MIXINS extensions. */ /* Recursively add MIXINS extensions. */
{ {
const _Eo_Class **extn_itr; const _Efl_Class **extn_itr;
for (extn_itr = klass->extensions ; *extn_itr ; extn_itr++) for (extn_itr = klass->extensions ; *extn_itr ; extn_itr++)
{ {
const _Eo_Class *extn = *extn_itr; const _Efl_Class *extn = *extn_itr;
if (extn->desc->type == EO_CLASS_TYPE_MIXIN) if (extn->desc->type == EO_CLASS_TYPE_MIXIN)
mro = _eo_class_mro_add(mro, extn); mro = _eo_class_mro_add(mro, extn);
} }
@ -917,12 +917,12 @@ _eo_class_mro_add(Eina_List *mro, const _Eo_Class *klass)
} }
static Eina_List * static Eina_List *
_eo_class_mro_init(const Eo_Class_Description *desc, const _Eo_Class *parent, Eina_List *extensions) _eo_class_mro_init(const Efl_Class_Description *desc, const _Efl_Class *parent, Eina_List *extensions)
{ {
Eina_List *mro = NULL; Eina_List *mro = NULL;
Eina_List *extn_itr = NULL; Eina_List *extn_itr = NULL;
Eina_List *extn_pos = NULL; Eina_List *extn_pos = NULL;
const _Eo_Class *extn = NULL; const _Efl_Class *extn = NULL;
/* Add MIXINS extensions. */ /* Add MIXINS extensions. */
EINA_LIST_FOREACH(extensions, extn_itr, extn) EINA_LIST_FOREACH(extensions, extn_itr, extn)
@ -969,7 +969,7 @@ _eo_class_mro_init(const Eo_Class_Description *desc, const _Eo_Class *parent, Ei
} }
static void static void
_eo_class_constructor(_Eo_Class *klass) _eo_class_constructor(_Efl_Class *klass)
{ {
klass->constructed = EINA_TRUE; klass->constructed = EINA_TRUE;
@ -978,7 +978,7 @@ _eo_class_constructor(_Eo_Class *klass)
} }
static void static void
eo_class_free(_Eo_Class *klass) eo_class_free(_Efl_Class *klass)
{ {
void *data; void *data;
@ -1015,7 +1015,7 @@ _eo_classes_release(void)
#ifdef HAVE_MMAP #ifdef HAVE_MMAP
size_t size; size_t size;
size = _eo_classes_alloc * sizeof(_Eo_Class *); size = _eo_classes_alloc * sizeof(_Efl_Class *);
if (_eo_classes) munmap(_eo_classes, size); if (_eo_classes) munmap(_eo_classes, size);
#else #else
free(_eo_classes); free(_eo_classes);
@ -1033,10 +1033,10 @@ _eo_classes_expand(void)
_eo_classes_last_id++; _eo_classes_last_id++;
if (_eo_classes_last_id <= _eo_classes_alloc) return; if (_eo_classes_last_id <= _eo_classes_alloc) return;
psize = _eo_classes_alloc * sizeof(_Eo_Class *); psize = _eo_classes_alloc * sizeof(_Efl_Class *);
#ifdef HAVE_MMAP #ifdef HAVE_MMAP
_eo_classes_alloc += (MEM_PAGE_SIZE / sizeof(_Eo_Class *)); _eo_classes_alloc += (MEM_PAGE_SIZE / sizeof(_Efl_Class *));
newsize = _eo_classes_alloc * sizeof(_Eo_Class *); newsize = _eo_classes_alloc * sizeof(_Efl_Class *);
ptr = mmap(NULL, newsize, PROT_READ | PROT_WRITE, ptr = mmap(NULL, newsize, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANON, -1, 0); MAP_PRIVATE | MAP_ANON, -1, 0);
if (ptr == MAP_FAILED) if (ptr == MAP_FAILED)
@ -1048,7 +1048,7 @@ _eo_classes_expand(void)
if (_eo_classes) munmap(_eo_classes, psize); if (_eo_classes) munmap(_eo_classes, psize);
#else #else
_eo_classes_alloc += 128; _eo_classes_alloc += 128;
newsize = _eo_classes_alloc * sizeof(_Eo_Class *); newsize = _eo_classes_alloc * sizeof(_Efl_Class *);
ptr = realloc(_eo_classes, newsize); ptr = realloc(_eo_classes, newsize);
if (!ptr) if (!ptr)
{ {
@ -1057,13 +1057,13 @@ _eo_classes_expand(void)
} }
#endif #endif
memset(ptr + psize, 0, newsize - psize); memset(ptr + psize, 0, newsize - psize);
_eo_classes = (_Eo_Class **)ptr; _eo_classes = (_Efl_Class **)ptr;
} }
EAPI const Eo_Class * EAPI const Efl_Class *
eo_class_new(const Eo_Class_Description *desc, const Eo_Class *parent_id, ...) eo_class_new(const Efl_Class_Description *desc, const Efl_Class *parent_id, ...)
{ {
_Eo_Class *klass; _Efl_Class *klass;
va_list p_list; va_list p_list;
size_t extn_sz, mro_sz, mixins_sz; size_t extn_sz, mro_sz, mixins_sz;
Eina_List *extn_list, *mro, *mixins; Eina_List *extn_list, *mro, *mixins;
@ -1071,7 +1071,7 @@ eo_class_new(const Eo_Class_Description *desc, const Eo_Class *parent_id, ...)
EINA_SAFETY_ON_NULL_RETURN_VAL(desc, NULL); EINA_SAFETY_ON_NULL_RETURN_VAL(desc, NULL);
EINA_SAFETY_ON_NULL_RETURN_VAL(desc->name, NULL); EINA_SAFETY_ON_NULL_RETURN_VAL(desc->name, NULL);
_Eo_Class *parent = _eo_class_pointer_get(parent_id); _Efl_Class *parent = _eo_class_pointer_get(parent_id);
#ifndef HAVE_EO_ID #ifndef HAVE_EO_ID
if (parent && !EINA_MAGIC_CHECK((Eo_Header *) parent, EO_CLASS_EINA_MAGIC)) if (parent && !EINA_MAGIC_CHECK((Eo_Header *) parent, EO_CLASS_EINA_MAGIC))
{ {
@ -1119,7 +1119,7 @@ eo_class_new(const Eo_Class_Description *desc, const Eo_Class *parent_id, ...)
{ {
DBG("Started building extensions list for class '%s'", desc->name); DBG("Started building extensions list for class '%s'", desc->name);
extn_list = NULL; extn_list = NULL;
const _Eo_Class *extn = NULL; const _Efl_Class *extn = NULL;
const Eo_Id *extn_id = NULL; const Eo_Id *extn_id = NULL;
va_start(p_list, parent_id); va_start(p_list, parent_id);
@ -1127,7 +1127,7 @@ eo_class_new(const Eo_Class_Description *desc, const Eo_Class *parent_id, ...)
extn_id = va_arg(p_list, Eo_Id *); extn_id = va_arg(p_list, Eo_Id *);
while (extn_id) while (extn_id)
{ {
extn = _eo_class_pointer_get((Eo_Class *)extn_id); extn = _eo_class_pointer_get((Efl_Class *)extn_id);
switch (extn->desc->type) switch (extn->desc->type)
{ {
case EO_CLASS_TYPE_REGULAR_NO_INSTANT: case EO_CLASS_TYPE_REGULAR_NO_INSTANT:
@ -1145,7 +1145,7 @@ eo_class_new(const Eo_Class_Description *desc, const Eo_Class *parent_id, ...)
extn_list = _eo_class_list_remove_duplicates(extn_list); extn_list = _eo_class_list_remove_duplicates(extn_list);
extn_sz = sizeof(_Eo_Class *) * (eina_list_count(extn_list) + 1); extn_sz = sizeof(_Efl_Class *) * (eina_list_count(extn_list) + 1);
DBG("Finished building extensions list for class '%s'", desc->name); DBG("Finished building extensions list for class '%s'", desc->name);
} }
@ -1161,7 +1161,7 @@ eo_class_new(const Eo_Class_Description *desc, const Eo_Class *parent_id, ...)
return NULL; return NULL;
} }
mro_sz = sizeof(_Eo_Class *) * (eina_list_count(mro) + 1); mro_sz = sizeof(_Efl_Class *) * (eina_list_count(mro) + 1);
DBG("Finished building MRO list for class '%s'", desc->name); DBG("Finished building MRO list for class '%s'", desc->name);
} }
@ -1169,7 +1169,7 @@ eo_class_new(const Eo_Class_Description *desc, const Eo_Class *parent_id, ...)
/* Prepare mixins list */ /* Prepare mixins list */
{ {
Eina_List *itr; Eina_List *itr;
const _Eo_Class *kls_itr; const _Efl_Class *kls_itr;
DBG("Started building Mixins list for class '%s'", desc->name); DBG("Started building Mixins list for class '%s'", desc->name);
@ -1196,8 +1196,8 @@ eo_class_new(const Eo_Class_Description *desc, const Eo_Class *parent_id, ...)
eina_spinlock_new(&klass->iterators.trash_lock); eina_spinlock_new(&klass->iterators.trash_lock);
klass->parent = parent; klass->parent = parent;
klass->desc = desc; klass->desc = desc;
klass->extensions = (const _Eo_Class **) ((char *) klass + _eo_class_sz); klass->extensions = (const _Efl_Class **) ((char *) klass + _eo_class_sz);
klass->mro = (const _Eo_Class **) ((char *) klass->extensions + extn_sz); klass->mro = (const _Efl_Class **) ((char *) klass->extensions + extn_sz);
klass->extn_data_off = (Eo_Extension_Data_Offset *) ((char *) klass->mro + mro_sz); klass->extn_data_off = (Eo_Extension_Data_Offset *) ((char *) klass->mro + mro_sz);
if (klass->parent) if (klass->parent)
{ {
@ -1218,8 +1218,8 @@ eo_class_new(const Eo_Class_Description *desc, const Eo_Class *parent_id, ...)
/* Copy the extensions and free the list */ /* Copy the extensions and free the list */
{ {
const _Eo_Class *extn = NULL; const _Efl_Class *extn = NULL;
const _Eo_Class **extn_itr = klass->extensions; const _Efl_Class **extn_itr = klass->extensions;
EINA_LIST_FREE(extn_list, extn) EINA_LIST_FREE(extn_list, extn)
{ {
*(extn_itr++) = extn; *(extn_itr++) = extn;
@ -1231,8 +1231,8 @@ eo_class_new(const Eo_Class_Description *desc, const Eo_Class *parent_id, ...)
/* Copy the mro and free the list. */ /* Copy the mro and free the list. */
{ {
const _Eo_Class *kls_itr = NULL; const _Efl_Class *kls_itr = NULL;
const _Eo_Class **mro_itr = klass->mro; const _Efl_Class **mro_itr = klass->mro;
EINA_LIST_FREE(mro, kls_itr) EINA_LIST_FREE(mro, kls_itr)
{ {
*(mro_itr++) = kls_itr; *(mro_itr++) = kls_itr;
@ -1248,7 +1248,7 @@ eo_class_new(const Eo_Class_Description *desc, const Eo_Class *parent_id, ...)
/* Feed the mixins data offsets and free the mixins list. */ /* Feed the mixins data offsets and free the mixins list. */
{ {
const _Eo_Class *kls_itr = NULL; const _Efl_Class *kls_itr = NULL;
Eo_Extension_Data_Offset *extn_data_itr = klass->extn_data_off; Eo_Extension_Data_Offset *extn_data_itr = klass->extn_data_off;
EINA_LIST_FREE(mixins, kls_itr) EINA_LIST_FREE(mixins, kls_itr)
{ {
@ -1275,7 +1275,7 @@ eo_class_new(const Eo_Class_Description *desc, const Eo_Class *parent_id, ...)
/* Flatten the function array */ /* Flatten the function array */
{ {
const _Eo_Class **mro_itr = klass->mro; const _Efl_Class **mro_itr = klass->mro;
for ( ; *mro_itr ; mro_itr++) for ( ; *mro_itr ; mro_itr++)
; ;
@ -1288,11 +1288,11 @@ eo_class_new(const Eo_Class_Description *desc, const Eo_Class *parent_id, ...)
/* Mark which classes we implement */ /* Mark which classes we implement */
{ {
const _Eo_Class **extn_itr; const _Efl_Class **extn_itr;
for (extn_itr = klass->extensions ; *extn_itr ; extn_itr++) for (extn_itr = klass->extensions ; *extn_itr ; extn_itr++)
{ {
const _Eo_Class *extn = *extn_itr; const _Efl_Class *extn = *extn_itr;
/* Set it in the dich. */ /* Set it in the dich. */
_vtable_func_set(&klass->vtable, klass, extn->base_id + _vtable_func_set(&klass->vtable, klass, extn->base_id +
extn->desc->ops.count, _eo_class_isa_func); extn->desc->ops.count, _eo_class_isa_func);
@ -1341,7 +1341,7 @@ EAPI Eina_Bool
eo_override(Eo *eo_id, const Eo_Ops *ops) eo_override(Eo *eo_id, const Eo_Ops *ops)
{ {
EO_OBJ_POINTER_RETURN_VAL(eo_id, obj, EINA_FALSE); EO_OBJ_POINTER_RETURN_VAL(eo_id, obj, EINA_FALSE);
EO_CLASS_POINTER_RETURN_VAL(EO_OVERRIDE_CLASS, klass, EINA_FALSE); EO_CLASS_POINTER_RETURN_VAL(EFL_OBJECT_OVERRIDE_CLASS, klass, EINA_FALSE);
Eo_Vtable *previous = obj->vtable; Eo_Vtable *previous = obj->vtable;
if (!ops) if (!ops)
@ -1377,7 +1377,7 @@ eo_override(Eo *eo_id, const Eo_Ops *ops)
} }
EAPI Eina_Bool EAPI Eina_Bool
eo_isa(const Eo *eo_id, const Eo_Class *klass_id) eo_isa(const Eo *eo_id, const Efl_Class *klass_id)
{ {
EO_OBJ_POINTER_RETURN_VAL(eo_id, obj, EINA_FALSE); EO_OBJ_POINTER_RETURN_VAL(eo_id, obj, EINA_FALSE);
EO_CLASS_POINTER_RETURN_VAL(klass_id, klass, EINA_FALSE); EO_CLASS_POINTER_RETURN_VAL(klass_id, klass, EINA_FALSE);
@ -1496,7 +1496,7 @@ ___eo_ref2_reset(const Eo *obj_id)
EAPI void EAPI void
eo_del_intercept_set(Eo *obj_id, Eo_Del_Intercept del_intercept_func) efl_del_intercept_set(Eo *obj_id, Eo_Del_Intercept del_intercept_func)
{ {
EO_OBJ_POINTER_RETURN(obj_id, obj); EO_OBJ_POINTER_RETURN(obj_id, obj);
@ -1504,7 +1504,7 @@ eo_del_intercept_set(Eo *obj_id, Eo_Del_Intercept del_intercept_func)
} }
EAPI Eo_Del_Intercept EAPI Eo_Del_Intercept
eo_del_intercept_get(const Eo *obj_id) efl_del_intercept_get(const Eo *obj_id)
{ {
EO_OBJ_POINTER_RETURN_VAL(obj_id, obj, NULL); EO_OBJ_POINTER_RETURN_VAL(obj_id, obj, NULL);
@ -1525,7 +1525,7 @@ _eo_condtor_done(Eo *obj_id)
} }
static inline void * static inline void *
_eo_data_scope_safe_get(const _Eo_Object *obj, const _Eo_Class *klass) _eo_data_scope_safe_get(const _Eo_Object *obj, const _Efl_Class *klass)
{ {
if (EINA_LIKELY(klass->desc->data_size > 0)) if (EINA_LIKELY(klass->desc->data_size > 0))
{ {
@ -1536,7 +1536,7 @@ _eo_data_scope_safe_get(const _Eo_Object *obj, const _Eo_Class *klass)
} }
static inline void * static inline void *
_eo_data_scope_get(const _Eo_Object *obj, const _Eo_Class *klass) _eo_data_scope_get(const _Eo_Object *obj, const _Efl_Class *klass)
{ {
if (EINA_LIKELY(klass->desc->type != EO_CLASS_TYPE_MIXIN)) if (EINA_LIKELY(klass->desc->type != EO_CLASS_TYPE_MIXIN))
return ((char *) obj) + klass->data_offset; return ((char *) obj) + klass->data_offset;
@ -1564,7 +1564,7 @@ _eo_data_scope_get(const _Eo_Object *obj, const _Eo_Class *klass)
} }
static inline void * static inline void *
_eo_data_xref_internal(const char *file, int line, _Eo_Object *obj, const _Eo_Class *klass, const _Eo_Object *ref_obj) _eo_data_xref_internal(const char *file, int line, _Eo_Object *obj, const _Efl_Class *klass, const _Eo_Object *ref_obj)
{ {
void *data = NULL; void *data = NULL;
if (klass != NULL) if (klass != NULL)
@ -1592,7 +1592,7 @@ static inline void
_eo_data_xunref_internal(_Eo_Object *obj, void *data, const _Eo_Object *ref_obj) _eo_data_xunref_internal(_Eo_Object *obj, void *data, const _Eo_Object *ref_obj)
{ {
#ifdef EO_DEBUG #ifdef EO_DEBUG
const _Eo_Class *klass = obj->klass; const _Efl_Class *klass = obj->klass;
Eina_Bool in_range = (((char *)data >= (((char *) obj) + _eo_sz)) && Eina_Bool in_range = (((char *)data >= (((char *) obj) + _eo_sz)) &&
((char *)data < (((char *) obj) + klass->obj_size))); ((char *)data < (((char *) obj) + klass->obj_size)));
if (!in_range) if (!in_range)
@ -1634,7 +1634,7 @@ _eo_data_xunref_internal(_Eo_Object *obj, void *data, const _Eo_Object *ref_obj)
} }
EAPI void * EAPI void *
eo_data_scope_get(const Eo *obj_id, const Eo_Class *klass_id) eo_data_scope_get(const Eo *obj_id, const Efl_Class *klass_id)
{ {
void *ret; void *ret;
EO_OBJ_POINTER_RETURN_VAL(obj_id, obj, NULL); EO_OBJ_POINTER_RETURN_VAL(obj_id, obj, NULL);
@ -1661,12 +1661,12 @@ eo_data_scope_get(const Eo *obj_id, const Eo_Class *klass_id)
} }
EAPI void * EAPI void *
eo_data_xref_internal(const char *file, int line, const Eo *obj_id, const Eo_Class *klass_id, const Eo *ref_obj_id) eo_data_xref_internal(const char *file, int line, const Eo *obj_id, const Efl_Class *klass_id, const Eo *ref_obj_id)
{ {
void *ret; void *ret;
EO_OBJ_POINTER_RETURN_VAL(obj_id, obj, NULL); EO_OBJ_POINTER_RETURN_VAL(obj_id, obj, NULL);
EO_OBJ_POINTER_RETURN_VAL(ref_obj_id, ref_obj, NULL); EO_OBJ_POINTER_RETURN_VAL(ref_obj_id, ref_obj, NULL);
_Eo_Class *klass = NULL; _Efl_Class *klass = NULL;
if (klass_id) if (klass_id)
{ {
EO_CLASS_POINTER_RETURN_VAL(klass_id, klass2, NULL); EO_CLASS_POINTER_RETURN_VAL(klass_id, klass2, NULL);
@ -1711,7 +1711,7 @@ eo_init(void)
eina_init(); eina_init();
_eo_sz = EO_ALIGN_SIZE(sizeof(_Eo_Object)); _eo_sz = EO_ALIGN_SIZE(sizeof(_Eo_Object));
_eo_class_sz = EO_ALIGN_SIZE(sizeof(_Eo_Class)); _eo_class_sz = EO_ALIGN_SIZE(sizeof(_Efl_Class));
_eo_classes = NULL; _eo_classes = NULL;
_eo_classes_last_id = EO_CLASS_IDS_FIRST - 1; _eo_classes_last_id = EO_CLASS_IDS_FIRST - 1;
@ -1775,7 +1775,7 @@ EAPI Eina_Bool
eo_shutdown(void) eo_shutdown(void)
{ {
size_t i; size_t i;
_Eo_Class **cls_itr = _eo_classes + _eo_classes_last_id - 1; _Efl_Class **cls_itr = _eo_classes + _eo_classes_last_id - 1;
if (--_eo_init_count > 0) if (--_eo_init_count > 0)
return EINA_TRUE; return EINA_TRUE;

340
src/lib/eo/eo_base_class.c
View File

File diff suppressed because it is too large Load Diff

4
src/lib/eo/eo_class.eo
View File

@ -1,4 +0,0 @@
abstract Eo.Class ()
{
data: null;
}

4
src/lib/eo/eo_class_class.c
View File

@ -4,5 +4,5 @@
#include "Eo.h" #include "Eo.h"
#include "eo_class.eo.c" #include "efl_class.eo.c"
#include "eo_interface.eo.c" #include "efl_interface.eo.c"

36
src/lib/eo/eo_private.h
View File

@ -9,7 +9,7 @@
#define EO_FREED_EINA_MAGIC 0xa186bb32 #define EO_FREED_EINA_MAGIC 0xa186bb32
#define EO_FREED_EINA_MAGIC_STR "Eo - Freed object" #define EO_FREED_EINA_MAGIC_STR "Eo - Freed object"
#define EO_CLASS_EINA_MAGIC 0xa186ba32 #define EO_CLASS_EINA_MAGIC 0xa186ba32
#define EO_CLASS_EINA_MAGIC_STR "Eo Class" #define EO_CLASS_EINA_MAGIC_STR "Efl Class"
#define EO_MAGIC_RETURN_VAL(d, magic, ret) \ #define EO_MAGIC_RETURN_VAL(d, magic, ret) \
do { \ do { \
@ -58,7 +58,7 @@ extern int _eo_log_dom;
#define DBG(...) EINA_LOG_DOM_DBG(_eo_log_dom, __VA_ARGS__) #define DBG(...) EINA_LOG_DOM_DBG(_eo_log_dom, __VA_ARGS__)
typedef uintptr_t Eo_Id; typedef uintptr_t Eo_Id;
typedef struct _Eo_Class _Eo_Class; typedef struct _Efl_Class _Eo_Class;
typedef struct _Eo_Header Eo_Header; typedef struct _Eo_Header Eo_Header;
/* Retrieves the pointer to the object from the id */ /* Retrieves the pointer to the object from the id */
@ -98,7 +98,7 @@ struct _Eo_Object
{ {
Eo_Header header; Eo_Header header;
EINA_INLIST; EINA_INLIST;
const _Eo_Class *klass; const _Efl_Class *klass;
#ifdef EO_DEBUG #ifdef EO_DEBUG
Eina_Inlist *xrefs; Eina_Inlist *xrefs;
Eina_Inlist *data_xrefs; Eina_Inlist *data_xrefs;
@ -129,7 +129,7 @@ typedef void (*eo_op_func_type)(Eo *, void *class_data, va_list *list);
typedef struct typedef struct
{ {
eo_op_func_type func; eo_op_func_type func;
const _Eo_Class *src; const _Efl_Class *src;
} op_type_funcs; } op_type_funcs;
struct _Dich_Chain1 struct _Dich_Chain1
@ -139,23 +139,23 @@ struct _Dich_Chain1
typedef struct typedef struct
{ {
const _Eo_Class *klass; const _Efl_Class *klass;
size_t offset; size_t offset;
} Eo_Extension_Data_Offset; } Eo_Extension_Data_Offset;
struct _Eo_Class struct _Efl_Class
{ {
Eo_Header header; Eo_Header header;
const _Eo_Class *parent; const _Efl_Class *parent;
const Eo_Class_Description *desc; const Efl_Class_Description *desc;
Eo_Vtable vtable; Eo_Vtable vtable;
const _Eo_Class **extensions; const _Efl_Class **extensions;
Eo_Extension_Data_Offset *extn_data_off; Eo_Extension_Data_Offset *extn_data_off;
const _Eo_Class **mro; const _Efl_Class **mro;
/* cached object for faster allocation */ /* cached object for faster allocation */
struct { struct {
@ -200,7 +200,7 @@ Eo *_eo_header_id_get(const Eo_Header *header)
} }
static inline static inline
Eo_Class *_eo_class_id_get(const _Eo_Class *klass) Efl_Class *_eo_class_id_get(const _Eo_Class *klass)
{ {
return _eo_header_id_get((Eo_Header *) klass); return _eo_header_id_get((Eo_Header *) klass);
} }
@ -218,18 +218,18 @@ _eo_condtor_reset(_Eo_Object *obj)
} }
static inline void static inline void
_eo_del_internal(const char *file, int line, _Eo_Object *obj) _efl_del_internal(const char *file, int line, _Eo_Object *obj)
{ {
/* We need that for the event callbacks that may ref/unref. */ /* We need that for the event callbacks that may ref/unref. */
obj->refcount++; obj->refcount++;
const _Eo_Class *klass = obj->klass; const _Efl_Class *klass = obj->klass;
eo_event_callback_call(_eo_obj_id_get(obj), EO_EVENT_DEL, NULL); efl_event_callback_call(_eo_obj_id_get(obj), EFL_EVENT_DEL, NULL);
_eo_condtor_reset(obj); _eo_condtor_reset(obj);
eo_destructor(_eo_obj_id_get(obj)); efl_destructor(_eo_obj_id_get(obj));
if (!obj->condtor_done) if (!obj->condtor_done)
{ {
@ -243,7 +243,7 @@ _eo_del_internal(const char *file, int line, _Eo_Object *obj)
Eo *emb_obj; Eo *emb_obj;
EINA_LIST_FOREACH_SAFE(obj->composite_objects, itr, itr_n, emb_obj) EINA_LIST_FOREACH_SAFE(obj->composite_objects, itr, itr_n, emb_obj)
{ {
eo_composite_detach(_eo_obj_id_get(obj), emb_obj); efl_composite_detach(_eo_obj_id_get(obj), emb_obj);
} }
} }
@ -260,7 +260,7 @@ _obj_is_override(_Eo_Object *obj)
static inline void static inline void
_eo_free(_Eo_Object *obj) _eo_free(_Eo_Object *obj)
{ {
_Eo_Class *klass = (_Eo_Class*) obj->klass; _Efl_Class *klass = (_Eo_Class*) obj->klass;
#ifdef EO_DEBUG #ifdef EO_DEBUG
if (obj->datarefcount) if (obj->datarefcount)
@ -331,7 +331,7 @@ _eo_unref(_Eo_Object *obj)
obj->del_triggered = EINA_TRUE; obj->del_triggered = EINA_TRUE;
_eo_del_internal(__FILE__, __LINE__, obj); _efl_del_internal(__FILE__, __LINE__, obj);
#ifdef EO_DEBUG #ifdef EO_DEBUG
/* If for some reason it's not empty, clear it. */ /* If for some reason it's not empty, clear it. */
while (obj->xrefs) while (obj->xrefs)

8
src/lib/eo/eo_ptr_indirection.h
View File

@ -46,7 +46,7 @@ void _eo_pointer_error(const char *msg);
} while (0) } while (0)
#define EO_CLASS_POINTER_RETURN_VAL(klass_id, klass, ret) \ #define EO_CLASS_POINTER_RETURN_VAL(klass_id, klass, ret) \
_Eo_Class *klass; \ _Efl_Class *klass; \
do { \ do { \
if (!klass_id) return ret; \ if (!klass_id) return ret; \
klass = _eo_class_pointer_get(klass_id); \ klass = _eo_class_pointer_get(klass_id); \
@ -57,7 +57,7 @@ void _eo_pointer_error(const char *msg);
} while (0) } while (0)
#define EO_CLASS_POINTER_RETURN(klass_id, klass) \ #define EO_CLASS_POINTER_RETURN(klass_id, klass) \
_Eo_Class *klass; \ _Efl_Class *klass; \
do { \ do { \
if (!klass_id) return; \ if (!klass_id) return; \
klass = _eo_class_pointer_get(klass_id); \ klass = _eo_class_pointer_get(klass_id); \
@ -96,7 +96,7 @@ void _eo_pointer_error(const char *msg);
} while (0) } while (0)
#define EO_CLASS_POINTER_RETURN_VAL(klass_id, klass, ret) \ #define EO_CLASS_POINTER_RETURN_VAL(klass_id, klass, ret) \
_Eo_Class *klass; \ _Efl_Class *klass; \
do { \ do { \
klass = _eo_class_pointer_get(klass_id); \ klass = _eo_class_pointer_get(klass_id); \
if (!klass) return (ret); \ if (!klass) return (ret); \
@ -104,7 +104,7 @@ void _eo_pointer_error(const char *msg);
} while (0) } while (0)
#define EO_CLASS_POINTER_RETURN(klass_id, klass) \ #define EO_CLASS_POINTER_RETURN(klass_id, klass) \
_Eo_Class *klass; \ _Efl_Class *klass; \
do { \ do { \
klass = _eo_class_pointer_get(klass_id); \ klass = _eo_class_pointer_get(klass_id); \
if (!klass) return; \ if (!klass) return; \