diff --git a/src/Makefile.am b/src/Makefile.am
index 30245e67dc..e277678667 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -6,7 +6,9 @@ BUILT_SOURCES =
EOLIAN_FLAGS = \
-I$(srcdir)/lib/eo \
- -I$(srcdir)/lib/evas/canvas
+ -I$(srcdir)/lib/evas/canvas \
+ -I$(srcdir)/lib/edje
+
DIST_SUBDIRS =
SUBDIRS =
diff --git a/src/Makefile_Edje.am b/src/Makefile_Edje.am
index 2ecd3d449b..c0e261e91e 100644
--- a/src/Makefile_Edje.am
+++ b/src/Makefile_Edje.am
@@ -1,6 +1,21 @@
### Library
+BUILT_SOURCES += \
+ lib/edje/edje.eo.c \
+ lib/edje/edje.eo.h \
+ lib/edje/edje_edit.eo.c \
+ lib/edje/edje_edit.eo.h
+
+
+edjeeolianfilesdir = $(datadir)/eolian/include/edje-@VMAJ@
+edjeeolianfiles_DATA = \
+ lib/edje/edje.eo \
+ lib/edje/edje_edit.eo
+
+EXTRA_DIST += \
+ ${edjeeolianfiles_DATA}
+
lib_LTLIBRARIES += lib/edje/libedje.la
EDJE_COMMON_CPPFLAGS = -I$(top_builddir)/src/lib/efl \
@@ -22,6 +37,10 @@ lib/edje/Edje_Eo.h \
lib/edje/Edje_Legacy.h \
lib/edje/Edje_Edit.h
+nodist_installed_edjemainheaders_DATA = \
+ lib/edje/edje.eo.h \
+ lib/edje/edje_edit.eo.h
+
lib_edje_libedje_la_SOURCES = \
lib/edje/edje_private.h \
lib/edje/edje_container.h \
diff --git a/src/lib/edje/Edje_Eo.h b/src/lib/edje/Edje_Eo.h
index a63c966646..a780fa7c25 100644
--- a/src/lib/edje/Edje_Eo.h
+++ b/src/lib/edje/Edje_Eo.h
@@ -1,3 +1,5 @@
+#include "edje.eo.h"
+#if 0
#define EDJE_OBJ_CLASS edje_object_class_get()
const Eo_Class *edje_object_class_get(void) EINA_CONST;
@@ -297,7 +299,7 @@ enum
*
* @see edje_object_part_text_input_panel_variation_get
*/
-#define edje_obj_part_text_input_panel_variation_get(part, ret) EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_LAYOUT_VARIATION_GET), EO_TYPECHECK(const char *, part), EO_TYPECHECK(int *, ret)
+#define edje_obj_part_text_input_panel_layout_variation_get(part, ret) EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_LAYOUT_VARIATION_GET), EO_TYPECHECK(const char *, part), EO_TYPECHECK(int *, ret)
/**
* @def edje_obj_part_text_input_panel_variation_set
@@ -310,7 +312,7 @@ enum
*
* @see edje_object_part_text_input_panel_variation_get
*/
-#define edje_obj_part_text_input_panel_variation_set(part, variation) EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_LAYOUT_VARIATION_SET), EO_TYPECHECK(const char *, part), EO_TYPECHECK(int, variation)
+#define edje_obj_part_text_input_panel_layout_variation_set(part, variation) EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_LAYOUT_VARIATION_SET), EO_TYPECHECK(const char *, part), EO_TYPECHECK(int, variation)
/**
* @def edje_obj_part_text_autocapital_type_set
@@ -2278,10 +2280,15 @@ enum
*/
#define edje_obj_signal_emit(emission, source) EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_SIGNAL_EMIT), EO_TYPECHECK(const char *, emission), EO_TYPECHECK(const char *, source)
+#endif
/**
* @}
*/
+#include "edje_edit.eo.h"
+#if 0
#define EDJE_EDIT_CLASS edje_edit_class_get()
const Eo_Class *edje_edit_class_get(void) EINA_CONST;
+
+#endif
\ No newline at end of file
diff --git a/src/lib/edje/Edje_Legacy.h b/src/lib/edje/Edje_Legacy.h
index 34bcd83649..818a69052b 100644
--- a/src/lib/edje/Edje_Legacy.h
+++ b/src/lib/edje/Edje_Legacy.h
@@ -188,7 +188,7 @@ EAPI void edje_object_update_hints_set(Evas_Object *obj, Eina_Bool update);
* @param obj A handle to an Edje object.
* @return @c true if does, @c false if it doesn't.
*/
-EAPI Eina_Bool edje_object_update_hints_get(Evas_Object *obj);
+EAPI Eina_Bool edje_object_update_hints_get(const Evas_Object *obj);
/**
* @brief Get the maximum size specified -- as an EDC property -- for a
diff --git a/src/lib/edje/edje.eo b/src/lib/edje/edje.eo
new file mode 100644
index 0000000000..1ec31476a7
--- /dev/null
+++ b/src/lib/edje/edje.eo
@@ -0,0 +1,2507 @@
+class Edje (Evas_Smart_Clipped)
+{
+ legacy_prefix: edje_object;
+ eo_prefix: edje_obj;
+ data: Edje;
+ properties {
+ update_hints {
+ set {
+ /*@
+ @brief Edje will automatically update the size hints on itself.
+
+ By default edje doesn't set size hints on itself. With this function
+ call, it will do so if update is true. Be carefully, it cost a lot to
+ trigger this feature as it will recalc the object every time it make
+ sense to be sure that's its minimal size hint is always accurate. */
+ }
+ get {
+ /*@
+ @brief Wether or not Edje will update size hints on itself.
+
+ @return @c true if does, @c false if it doesn't. */
+ }
+ values {
+ Eina_Bool update; /*@ Wether or not update the size hints. */
+ }
+ }
+ mirrored {
+ set {
+ /*@
+ @brief Set the RTL orientation for this object.
+
+ @since 1.1.0 */
+ }
+ get {
+ /*@
+ @brief Get the RTL orientation for this object.
+
+ You can RTL orientation explicitly with edje_object_mirrored_set.
+
+ @return @c EINA_TRUE if the flag is set or @c EINA_FALSE if not.
+ @since 1.1.0 */
+ }
+ values {
+ Eina_Bool rtl; /*@ new value of flag EINA_TRUE/EINA_FALSE */
+ }
+ }
+ animation {
+ set {
+ /*@
+ @brief Set the object's animation state.
+
+ This function starts or stops an Edje object's animation. The
+ information if it's stopped can be retrieved by
+ edje_object_animation_get().
+
+ @see edje_object_animation_get() */
+ }
+ get {
+ /*@
+ @brief Get the Edje object's animation state.
+
+ @return @c EINA_FALSE on error or if object is not animated;
+ @c EINA_TRUE if animated.
+
+ This function returns if the animation is stopped or not. The
+ animation state is set by edje_object_animation_set().
+
+ @see edje_object_animation_set(). */
+ }
+ values {
+ Eina_Bool on; /*@ The animation state. @c EINA_TRUE to starts or
+ @c EINA_FALSE to stops. */
+ }
+ }
+ play {
+ set {
+ /*@
+ @brief Set the Edje object to playing or paused states.
+
+ This function sets the Edje object @a obj to playing or paused
+ states, depending on the parameter @a play. This has no effect if
+ the object was already at that state.
+
+ @see edje_object_play_get(). */
+ }
+ get {
+ /*@
+ @brief Get the Edje object's state.
+
+ @return @c EINA_FALSE if the object is not connected, its @c delete_me flag
+ is set, or it is at paused state; @c EINA_TRUE if the object is at playing
+ state.
+
+ This function tells if an Edje object is playing or not. This state
+ is set by edje_object_play_set().
+
+ @see edje_object_play_set(). */
+ }
+ values {
+ Eina_Bool play; /*@ Object state (@c EINA_TRUE to playing,
+ @c EINA_FALSE to paused). */
+ }
+ }
+ perspective {
+ set {
+ /*@
+ Set the given perspective object on this Edje object.
+
+ Make the given perspective object be the default perspective for this Edje
+ object.
+
+ There can be only one perspective object per Edje object, and if a
+ previous one was set, it will be removed and the new perspective object
+ will be used.
+
+ An Edje perspective will only affect a part if it doesn't point to another
+ part to be used as perspective.
+
+ @see edje_object_perspective_new()
+ @see edje_object_perspective_get()
+ @see edje_perspective_set() */
+ }
+ get {
+ /*@
+ Get the current perspective used on this Edje object.
+
+ @return The perspective object being used on this Edje object. Or @c NULL
+ if there was none, and on errors.
+
+ @see edje_object_perspective_set() */
+ ps: const;
+ }
+ values {
+ Edje_Perspective *ps; /*@ The perspective object that will be used. */
+ }
+ }
+ file {
+ set {
+ /*@
+ @brief Sets the @b EDJ file (and group within it) to load an Edje
+ object's contents from
+
+ @return @c EINA_TRUE, on success or @c EINA_FALSE, on errors (check
+ edje_object_load_error_get() after this call to get errors causes)
+
+ Edje expects EDJ files, which are theming objects' descriptions and
+ resources packed together in an EET file, to read Edje object
+ definitions from. They usually are created with the @c .edj
+ extension. EDJ files, in turn, are assembled from @b textual object
+ description files, where one describes Edje objects declaratively
+ -- the EDC files (see @ref edcref "the syntax" for those files).
+
+ Those description files were designed so that many Edje object
+ definitions -- also called @b groups (or collections) -- could be
+ packed together in the same EDJ file, so that a whole
+ application's theme could be packed in one file only. This is the
+ reason for the @p group argument.
+
+ Use this function after you instantiate a new Edje object, so that
+ you can "give him life", telling where to get its contents from.
+
+ @see edje_object_add()
+ @see edje_object_file_get()
+ @see edje_object_mmap_set() */
+ return Eina_Bool;
+ }
+ get {
+ /*@
+ @brief Get the file and group name that a given Edje object is bound to
+
+ This gets the EDJ file's path, with the respective group set for
+ the given Edje object. If @a obj is either not an Edje file, or has
+ not had its file/group set previously, by edje_object_file_set(),
+ then both @p file and @p group will be set to @c NULL, indicating
+ an error.
+
+ @see edje_object_file_set()
+
+ @note Use @c NULL pointers on the file/group components you're not
+ interested in: they'll be ignored by the function. */
+ }
+ values {
+ const char *file; /*@ The path to the EDJ file to load @p from */
+ const char *group; /*@ The name of the group, in @p file, which implements an
+ Edje object */
+ }
+ }
+ scale {
+ set {
+ /*@
+ @brief Set the scaling factor for a given Edje object.
+
+ This function sets an @b individual scaling factor on the @a obj
+ Edje object. This property (or Edje's global scaling factor, when
+ applicable), will affect this object's part sizes. If @p scale is
+ not zero, than the individual scaling will @b override any global
+ scaling set, for the object @p obj's parts. Put it back to zero to
+ get the effects of the global scaling again.
+
+ @warning Only parts which, at EDC level, had the @c "scale"
+ property set to @c 1, will be affected by this function. Check the
+ complete @ref edcref "syntax reference" for EDC files.
+
+ @see edje_object_scale_get()
+ @see edje_scale_get() for more details */
+ return Eina_Bool;
+ }
+ get {
+ /*@
+ @brief Get a given Edje object's scaling factor.
+
+ This function returns the @c individual scaling factor set on the
+ @a obj Edje object.
+
+ @see edje_object_scale_set() for more details */
+ }
+ values {
+ double scale; /*@ The scaling factor (the default value is @c 0.0,
+ meaning individual scaling @b not set) */
+ }
+ }
+ mmap {
+ set {
+ /*@
+ @brief Sets the @b EDJ file (and group within it) to load an Edje
+ object's contents from
+
+ @return @c EINA_TRUE, on success or @c EINA_FALSE, on errors (check
+ edje_object_load_error_get() after this call to get errors causes)
+
+ Edje expects EDJ files, which are theming objects' descriptions and
+ resources packed together in an EET file, to read Edje object
+ definitions from. They usually are created with the @c .edj
+ extension. EDJ files, in turn, are assembled from @b textual object
+ description files, where one describes Edje objects declaratively
+ -- the EDC files (see @ref edcref "the syntax" for those files).
+
+ Those description files were designed so that many Edje object
+ definitions -- also called @b groups (or collections) -- could be
+ packed together in the same EDJ file, so that a whole
+ application's theme could be packed in one file only. This is the
+ reason for the @p group argument.
+
+ Use this function after you instantiate a new Edje object, so that
+ you can "give him life", telling where to get its contents from.
+
+ @see edje_object_add()
+ @see edje_object_file_get()
+ @see edje_object_mmap_set()
+ @since 1.8 */
+ return Eina_Bool;
+ }
+ values {
+ const Eina_File *file; /*@ The Eina_File pointing to the EDJ file to load @p from */
+ const char *group; /*@ The name of the group, in @p file, which implements an
+ Edje object */
+ }
+ }
+ text_change_cb {
+ set {
+ /*@
+ @brief Set the object text callback.
+
+ This function sets the callback to be called when the text changes. */
+ }
+ values {
+ Edje_Text_Change_Cb func; /*@ The callback function to handle the text change */
+ void *data; /*@ The data associated to the callback function. */
+ }
+ }
+ part_text_cursor_begin {
+ set {
+ /*@
+ @brief Moves the cursor to the beginning of the text part
+ @see evas_textblock_cursor_paragraph_first */
+ }
+ values {
+ const char *part; /*@ The part name */
+ Edje_Cursor cur; /*@ the edje cursor to work on */
+ }
+ }
+ part_text_cursor_line_end {
+ set {
+ /*@
+ @brief Move the cursor to the end of the line.
+ @see evas_textblock_cursor_line_char_last */
+ }
+ values {
+ const char *part; /*@ The part name */
+ Edje_Cursor cur; /*@ the edje cursor to work on */
+ }
+ }
+ text_class {
+ set {
+ /*@
+ @brief Sets Edje text class.
+
+ @return @c EINA_TRUE, on success or @c EINA_FALSE, on error
+
+ This function sets the text class for the Edje. */
+ return Eina_Bool;
+ }
+ values {
+ const char *text_class; /*@ The text class name */
+ const char *font; /*@ Font name */
+ Evas_Font_Size size; /*@ Font Size */
+ }
+ }
+ part_text_cursor_coord {
+ set {
+ /*@
+ Position the given cursor to a X,Y position.
+
+ This is frequently used with the user cursor.
+
+ @return True on success, false on error. */
+ return Eina_Bool;
+ }
+ values {
+ const char *part; /*@ The part containing the object. */
+ Edje_Cursor cur; /*@ The cursor to adjust. */
+ Evas_Coord x; /*@ X Coordinate. */
+ Evas_Coord y; /*@ Y Coordinate. */
+ }
+ }
+ part_text_cursor_end {
+ set {
+ /*@
+ @brief Moves the cursor to the end of the text part.
+ @see evas_textblock_cursor_paragraph_last */
+ }
+ values {
+ const char *part; /*@ The part name */
+ Edje_Cursor cur; /*@ the edje cursor to work on */
+ }
+ }
+ part_text_escaped {
+ set {
+ /*@
+ @brief Sets the text for an object part, but converts HTML escapes to UTF8
+
+ This converts the given string @p text to UTF8 assuming it contains HTML
+ style escapes like "&" and "©" etc. IF the part is of type TEXT,
+ as opposed to TEXTBLOCK.
+
+ @return @c EINA_TRUE on success, @c EINA_FALSE otherwise
+
+ @since 1.2 */
+ return Eina_Bool;
+ }
+ values {
+ const char *part; /*@ The part name */
+ const char *text; /*@ The text string */
+ }
+ }
+ item_provider {
+ set {
+ /*@
+ @brief Set the function that provides item objects for named items in an edje entry text
+
+ Item objects may be deleted any time by Edje, and will be deleted when the
+ Edje object is deleted (or file is set to a new file). */
+ }
+ values {
+ Edje_Item_Provider_Cb func; /*@ The function to call (or NULL to disable) to get item objects */
+ void *data; /*@ The data pointer to pass to the @p func callback */
+ }
+ }
+ part_text_cursor_line_begin {
+ set {
+ /*@
+ @brief Move the cursor to the beginning of the line.
+ @see evas_textblock_cursor_line_char_first */
+ }
+ values {
+ const char *part; /*@ The part name */
+ Edje_Cursor cur; /*@ the edje cursor to work on */
+ }
+ }
+ message_handler {
+ set {
+ /*@
+ @brief Set an Edje message handler function for a given Edje object.
+
+ For scriptable programs on an Edje object's defining EDC file which
+ send messages with the @c send_message() primitive, one can attach
+ handler functions, to be called in the code which creates
+ that object (see @ref edcref "the syntax" for EDC files).
+
+ This function associates a message handler function and the
+ attached data pointer to the object @p obj.
+
+ @see edje_object_message_send() */
+ }
+ values {
+ Edje_Message_Handler_Cb func; /*@ The function to handle messages @b coming from @p obj */
+ void *data; /*@ Auxiliary data to be passed to @p func */
+ }
+ }
+ size_min {
+ get {
+ /*@
+ @brief Get the minimum size specified -- as an EDC property -- for a
+ given Edje object
+
+ This function retrieves the @p obj object's minimum size values,
+ as declared in its EDC group definition. Minimum size of
+ groups have the following syntax
+ @code
+ collections {
+ group {
+ name: "a_group";
+ min: 100 100;
+ }
+ }
+ @endcode
+
+ where one declares a minimum size of 100 pixels both for width and
+ height. Those are (hint) values which should be respected when the
+ given object/group is to be controlled by a given container object
+ (e.g. an Edje object being "swallowed" into a given @c SWALLOW
+ typed part, as in edje_object_part_swallow()). Check the complete
+ @ref edcref "syntax reference" for EDC files.
+
+ @note If the @c min EDC property was not declared for @p obj, this
+ call will return the value 0, for each axis.
+
+ @note On failure, this function will make all non-@c NULL size
+ pointers' pointed variables be set to zero.
+
+ @see edje_object_size_max_get() */
+ }
+ values {
+ Evas_Coord minw; /*@ Pointer to a variable where to store the minimum width */
+ Evas_Coord minh; /*@ Pointer to a variable where to store the minimum height */
+ }
+ }
+ access_part_list {
+ get {
+ /*@
+ @brief Retrieve a list all accessibility part names
+
+ @return A list all accessibility part names on @p obj
+ @since 1.7.0 */
+ return Eina_List *;
+ }
+ }
+ load_error {
+ get {
+ /*@
+ @brief Gets the (last) file loading error for a given Edje object
+
+ @return The Edje loading error, one of:
+ - #EDJE_LOAD_ERROR_NONE
+ - #EDJE_LOAD_ERROR_GENERIC
+ - #EDJE_LOAD_ERROR_DOES_NOT_EXIST
+ - #EDJE_LOAD_ERROR_PERMISSION_DENIED
+ - #EDJE_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED
+ - #EDJE_LOAD_ERROR_CORRUPT_FILE
+ - #EDJE_LOAD_ERROR_UNKNOWN_FORMAT
+ - #EDJE_LOAD_ERROR_INCOMPATIBLE_FILE
+ - #EDJE_LOAD_ERROR_UNKNOWN_COLLECTION
+ - #EDJE_LOAD_ERROR_RECURSIVE_REFERENCE
+
+ This function is meant to be used after an Edje EDJ file
+ loading, what takes place with the edje_object_file_set()
+ function. If that function does not return @c EINA_TRUE, one should
+ check for the reason of failure with this one.
+
+ @see edje_load_error_str() */
+ return Edje_Load_Error;
+ }
+ }
+ size_max {
+ get {
+ /*@
+ @brief Get the maximum size specified -- as an EDC property -- for a
+ given Edje object
+
+ This function retrieves the @p obj object's maximum size values,
+ as declared in its EDC group definition. Maximum size of
+ groups have the following syntax
+ @code
+ collections {
+ group {
+ name: "a_group";
+ max: 100 100;
+ }
+ }
+ @endcode
+
+ where one declares a maximum size of 100 pixels both for width and
+ height. Those are (hint) values which should be respected when the
+ given object/group is to be controlled by a given container object
+ (e.g. an Edje object being "swallowed" into a given @c SWALLOW
+ typed part, as in edje_object_part_swallow()). Check the complete
+ @ref edcref "syntax reference" for EDC files.
+
+ @note If the @c max EDC property was not declared for @p obj, this
+ call will return the maximum size a given Edje object may have, for
+ each axis.
+
+ @note On failure, this function will make all non-@c NULL size
+ pointers' pointed variables be set to zero.
+
+ @see edje_object_size_min_get() */
+ }
+ values {
+ Evas_Coord maxw; /*@ Pointer to a variable where to store the maximum width */
+ Evas_Coord maxh; /*@ Pointer to a variable where to store the maximum height */
+ }
+ }
+ }
+ methods {
+ part_table_clear {
+ /*@
+ @brief Removes all object from the table.
+
+ @return @c EINA_TRUE clear the table, @c EINA_FALSE on failure
+
+ Removes all object from the table indicated by part, except the
+ internal ones set from the theme. */
+
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The part name */
+ @in Eina_Bool clear; /*@ If set, will delete subobjs on remove */
+ }
+ }
+ part_external_param_type_get {
+ /*@
+ Facility to query the type of the given parameter of the given part.
+
+ @return @c EDJE_EXTERNAL_PARAM_TYPE_MAX on errors, or another value
+ from #Edje_External_Param_Type on success. */
+
+ const;
+ return Edje_External_Param_Type;
+ params {
+ @in const char *part; /*@ The part name */
+ @out const char param; /*@ the parameter name to use. */
+ }
+ }
+ part_text_select_allow_set {
+ /*@
+ @brief Enables selection if the entry is an EXPLICIT selection mode
+ type.
+
+ The default is to @b not allow selection. This function only affects user
+ selection, functions such as edje_object_part_text_select_all() and
+ edje_object_part_text_select_none() are not affected. */
+
+ const;
+ params {
+ @in const char *part; /*@ The part name */
+ @in Eina_Bool allow; /*@ EINA_TRUE to enable, EINA_FALSE otherwise */
+ }
+ }
+ part_state_get {
+ /*@
+ @brief Returns the state of the Edje part.
+
+ @return The part state:\n
+ "default" for the default state\n
+ "" for other states */
+
+ const;
+ return const char *;
+ params {
+ @in const char *part; /*@ The part name */
+ @out double val_ret;
+ }
+ }
+ text_markup_filter_callback_del_full {
+ /*@
+ Delete a function and matching user data from the markup filter list.
+
+ Delete the given @p func filter and @p data user data from the list
+ in @p part.
+ Returns the user data pointer given when added.
+
+ @see edje_object_text_markup_filter_callback_add
+ @see edje_object_text_markup_filter_callback_del
+
+ @return The same data pointer if successful, or NULL otherwise
+ @since 1.2.0 */
+
+ return void *;
+ params {
+ @in const char *part; /*@ The part name */
+ @in Edje_Markup_Filter_Cb func; /*@ The function callback to remove */
+ @in void *data; /*@ The data passed to the callback function */
+ }
+ }
+ part_drag_step_set {
+ /*@
+ @brief Sets the drag step increment.
+
+ Sets the x,y step increments for a dragable object.
+
+ Values for @p dx and @p dy are real numbers that range from 0 to 1,
+ representing the relative size of the dragable area on that axis by which the
+ part will be moved.
+
+ @see edje_object_part_drag_step_get() */
+
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The part name */
+ @in double dx; /*@ The x step amount */
+ @in double dy; /*@ The y step amount */
+ }
+ }
+ part_drag_step_get {
+ /*@
+ @brief Gets the drag step increment values.
+
+ Gets the x and y step increments for the dragable object.
+
+
+ @see edje_object_part_drag_step_set() */
+
+ const;
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The part */
+ @out double dx; /*@ The x step increment pointer */
+ @out double dy; /*@ The y step increment pointer */
+ }
+ }
+ part_text_imf_context_get {
+ /*@
+ @brief Get the input method context in entry.
+
+ If ecore_imf was not available when edje was compiled, this function returns NULL
+ otherwise, the returned pointer is an Ecore_IMF
+
+ @return The input method context (Ecore_IMF_Context *) in entry
+ @since 1.2.0 */
+
+ const;
+ return void *;
+ params {
+ @in const char *part; /*@ The part name */
+ }
+ }
+ part_text_select_begin {
+ /*@
+ @brief Starts selecting at current cursor position */
+
+ const;
+ params {
+ @in const char *part; /*@ The part name */
+ }
+ }
+ part_text_style_user_peek {
+ /*@
+ @brief Return the text of the object part.
+
+ @return The text string
+
+ This function returns the style associated with the textblock part.
+
+ @since 1.2.0 */
+
+ const;
+ return const char *;
+ params {
+ @in const char *part; /*@ The part name */
+ }
+ }
+ signal_callback_del {
+ /*@
+ @brief Remove a signal-triggered callback from an object.
+
+ @return The data pointer
+
+ This function removes a callback, previously attached to the
+ emittion of a signal, from the object @a obj. The parameters @a
+ emission, @a source and @a func must match exactly those passed to
+ a previous call to edje_object_signal_callback_add(). The data
+ pointer that was passed to this call will be returned.
+
+ @see edje_object_signal_callback_add().
+ @see edje_object_signal_callback_del_full(). */
+
+ legacy null;
+ return void *;
+ params {
+ @in const char *emission; /*@ The emission string. */
+ @in const char *source; /*@ The source string. */
+ @in Edje_Signal_Cb func; /*@ The callback function. */
+ @in void *data; /*@ The callback function. */
+ }
+ }
+ part_text_cursor_next {
+ /*@
+ @brief Advances the cursor to the next cursor position.
+ @see evas_textblock_cursor_char_next */
+
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The part name */
+ @in Edje_Cursor cur; /*@ The edje cursor to advance */
+ }
+ }
+ part_text_style_user_push {
+ /*@
+ @brief Set the style of the
+
+ This function sets the style associated with the textblock part.
+
+ @since 1.2.0 */
+
+ params {
+ @in const char *part; /*@ The part name */
+ @in const char *style; /*@ The style to set (textblock conventions). */
+ }
+ }
+ part_text_append {
+ /*@
+ @brief Insert text for an object part.
+
+ This function inserts the text for an object part at the end; It does not
+ move the cursor.
+
+ @since 1.1 */
+
+ params {
+ @in const char *part; /*@ The part name */
+ @in const char *text; /*@ The text string */
+ }
+ }
+ part_geometry_get {
+ /*@
+ @brief Retrieve the geometry of a given Edje part, in a given Edje
+ object's group definition, relative to the object's area
+
+ This function gets the geometry of an Edje part within its
+ group. The @p x and @p y coordinates are relative to the top left
+ corner of the whole @p obj object's area.
+
+ @note Use @c NULL pointers on the geometry components you're not
+ interested in: they'll be ignored by the function.
+
+ @note On failure, this function will make all non-@c NULL geometry
+ pointers' pointed variables be set to zero. */
+
+ const;
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The Edje part's name */
+ @out Evas_Coord x; /*@ A pointer to a variable where to store the part's x
+ coordinate */
+ @out Evas_Coord y; /*@ A pointer to a variable where to store the part's y
+ coordinate */
+ @out Evas_Coord w; /*@ A pointer to a variable where to store the part's width */
+ @out Evas_Coord h; /*@ A pointer to a variable where to store the part's height */
+ }
+ }
+ part_text_input_panel_hide {
+ /*@
+ @brief Hide the input panel (virtual keyboard).
+ @see edje_object_part_text_input_panel_show
+
+ Note that input panel is shown or hidden automatically according to the focus state.
+ This API can be used in the case of manually controlling by using edje_object_part_text_input_panel_enabled_set.
+
+ @since 1.2.0 */
+
+ const;
+ params {
+ @in const char *part; /*@ The part name */
+ }
+ }
+ part_text_item_geometry_get {
+ /*@
+ @brief Return item geometry.
+
+ @return 1 if item exists, 0 if not
+
+ This function return a list of Evas_Textblock_Rectangle item
+ rectangles. */
+
+ const;
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The part name */
+ @in const char *item; /*@ The item name */
+ @out Evas_Coord cx; /*@ Item x return (relative to entry part) */
+ @out Evas_Coord cy; /*@ Item y return (relative to entry part) */
+ @out Evas_Coord cw; /*@ Item width return */
+ @out Evas_Coord ch; /*@ Item height return */
+ }
+ }
+ part_table_unpack {
+ /*@
+ @brief Removes an object from the table.
+
+ @return @c EINA_TRUE object removed, @c EINA_FALSE on failure
+
+ Removes an object from the table indicated by part. */
+
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The part name */
+ @in Evas_Object *child_obj; /*@ The object to pack in */
+ }
+ }
+ part_text_select_abort {
+ /*@
+ @brief Aborts any selection action on a part. */
+
+ const;
+ params {
+ @in const char *part; /*@ The part name */
+ }
+ }
+ text_insert_filter_callback_del_full {
+ /*@
+ Delete a function and matching user data from the filter list.
+
+ Delete the given @p func filter and @p data user data from the list
+ in @p part.
+ Returns the user data pointer given when added.
+
+ @see edje_object_text_insert_filter_callback_add
+ @see edje_object_text_insert_filter_callback_del
+
+ @return The same data pointer if successful, or NULL otherwise */
+
+ return void *;
+ params {
+ @in const char *part; /*@ The part name */
+ @in Edje_Text_Filter_Cb func; /*@ The function callback to remove */
+ @in void *data; /*@ The data passed to the callback function */
+ }
+ }
+ part_text_style_user_pop {
+ /*@
+ @brief Delete the top style form the user style stack.
+
+ @since 1.2.0 */
+
+ params {
+ @in const char *part; /*@ The part name */
+ }
+ }
+ part_text_input_panel_imdata_set {
+ /*@
+ Set the input panel-specific data to deliver to the input panel.
+
+ This API is used by applications to deliver specific data to the input panel.
+ The data format MUST be negotiated by both application and the input panel.
+ The size and format of data are defined by the input panel.
+
+ @since 1.2.0 */
+
+ params {
+ @in const char *part; /*@ The part name */
+ @in const void *data; /*@ The specific data to be set to the input panel. */
+ @in int len; /*@ the length of data, in bytes, to send to the input panel */
+ }
+ }
+ part_text_input_panel_imdata_get {
+ /*@
+ Get the specific data of the current active input panel.
+
+ @since 1.2.0 */
+
+ const;
+ params {
+ @in const char *part; /*@ The part name */
+ @in void *data; /*@ The specific data to be got from the input panel */
+ @in int *len; /*@ The length of data */
+ }
+ }
+ part_text_insert {
+ /*@
+ @brief Insert text for an object part.
+
+ This function inserts the text for an object part just before the
+ cursor position. */
+
+ params {
+ @in const char *part; /*@ The part name */
+ @in const char *text; /*@ The text string */
+ }
+ }
+ part_box_remove_at {
+ /*@
+ @brief Removes an object from the box.
+
+ @return Pointer to the object removed, or @c NULL.
+
+ Removes from the box indicated by part, the object in the position
+ pos.
+
+ @see edje_object_part_box_remove()
+ @see edje_object_part_box_remove_all() */
+
+ return Evas_Object *;
+ params {
+ @in const char *part; /*@ The part name */
+ @in unsigned int pos; /*@ The position index of the object (starts counting from 0) */
+ }
+ }
+ part_text_cursor_copy {
+ /*@
+ @brief Copy the cursor to another cursor. */
+
+ params {
+ @in const char *part; /*@ The part name */
+ @in Edje_Cursor src; /*@ the cursor to copy from */
+ @in Edje_Cursor dst; /*@ the cursor to copy to */
+ }
+ }
+ parts_extends_calc {
+ /*@
+ Calculate the geometry of the region, relative to a given Edje
+ object's area, occupied by all parts in the object
+
+ This function gets the geometry of the rectangle equal to the area
+ required to group all parts in @p obj's group/collection. The @p x
+ and @p y coordinates are relative to the top left corner of the
+ whole @p obj object's area. Parts placed out of the group's
+ boundaries will also be taken in account, so that @p x and @p y
+ may be negative.
+
+ @note Use @c NULL pointers on the geometry components you're not
+ interested in: they'll be ignored by the function.
+
+ @note On failure, this function will make all non-@c NULL geometry
+ pointers' pointed variables be set to zero. */
+
+ return Eina_Bool;
+ params {
+ @out Evas_Coord x; /*@ A pointer to a variable where to store the parts region's
+ x coordinate */
+ @out Evas_Coord y; /*@ A pointer to a variable where to store the parts region's
+ y coordinate */
+ @out Evas_Coord w; /*@ A pointer to a variable where to store the parts region's
+ width */
+ @out Evas_Coord h; /*@ A pointer to a variable where to store the parts region's
+ height */
+ }
+ }
+ part_drag_value_set {
+ /*@
+ @brief Set the dragable object location.
+
+ Places the dragable object at the given location.
+
+ Values for @p dx and @p dy are real numbers that range from 0 to 1,
+ representing the relative position to the dragable area on that axis.
+
+ This value means, for the vertical axis, that 0.0 will be at the top if the
+ first parameter of @c y in the dragable part theme is 1, and at bottom if it
+ is -1.
+
+ For the horizontal axis, 0.0 means left if the first parameter of @c x in the
+ dragable part theme is 1, and right if it is -1.
+
+ @see edje_object_part_drag_value_get() */
+
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The part name */
+ @in double dx; /*@ The x value */
+ @in double dy; /*@ The y value */
+ }
+ }
+ part_drag_value_get {
+ /*@
+ @brief Get the dragable object location.
+
+ Values for @p dx and @p dy are real numbers that range from 0 to 1,
+ representing the relative position to the dragable area on that axis.
+
+ @see edje_object_part_drag_value_set()
+
+ Gets the drag location values. */
+
+ const;
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The part name */
+ @out double dx; /*@ The X value pointer */
+ @out double dy; /*@ The Y value pointer */
+ }
+ }
+ calc_force {
+ /*@
+ @brief Force a Size/Geometry calculation.
+
+ Forces the object @p obj to recalculation layout regardless of
+ freeze/thaw. */
+
+ }
+ part_text_cursor_pos_set {
+ /*@
+ @brief Sets the cursor position to the given value
+
+ @since 1.1.0 */
+
+ params {
+ @in const char *part; /*@ The part name */
+ @in Edje_Cursor cur; /*@ The cursor to move */
+ @in int pos; /*@ the position of the cursor */
+ }
+ }
+ part_text_cursor_pos_get {
+ /*@
+ @brief Retrieves the current position of the cursor
+
+ @return The cursor position
+ @since 1.1.0 */
+
+ const;
+ return int;
+ params {
+ @in const char *part; /*@ The part name */
+ @in Edje_Cursor cur; /*@ The cursor to get the position */
+ }
+ }
+ freeze {
+ /*@
+ @brief Freezes the Edje object.
+
+ @return The frozen state or 0 on Error
+
+ This function puts all changes on hold. Successive freezes will
+ nest, requiring an equal number of thaws.
+
+ @see edje_object_thaw() */
+
+ return int;
+ }
+ part_text_cursor_content_get {
+ /*@
+ @brief Returns the content (char) at the cursor position.
+ @see evas_textblock_cursor_content_get
+
+ You must free the return (if not NULL) after you are done with it.
+
+ @return The character string pointed to (may be a multi-byte utf8 sequence) terminated by a nul byte. */
+
+ const;
+ return char *;
+ params {
+ @in const char *part; /*@ The part name */
+ @in Edje_Cursor cur; /*@ The cursor to use */
+ }
+ }
+ part_text_input_panel_layout_set {
+ /*@
+ @brief Set the layout of the input panel.
+
+ The layout of the input panel or virtual keyboard can make it easier or
+ harder to enter content. This allows you to hint what kind of input you
+ are expecting to enter and thus have the input panel automatically
+ come up with the right mode.
+
+ @since 1.1 */
+
+ params {
+ @in const char *part; /*@ The part name */
+ @in Edje_Input_Panel_Layout layout; /*@ layout type */
+ }
+ }
+ part_text_input_panel_layout_get {
+ /*@
+ @brief Get the layout of the input panel.
+
+ @return Layout type of the input panel
+
+ @see edje_object_part_text_input_panel_layout_set
+ @since 1.1 */
+
+ const;
+ return Edje_Input_Panel_Layout;
+ params {
+ @in const char *part; /*@ The part name */
+ }
+ }
+ part_table_pack {
+ /*@
+ @brief Packs an object into the table.
+
+ @return @c EINA_TRUE object was added, @c EINA_FALSE on failure
+
+ Packs an object into the table indicated by part. */
+
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The part name */
+ @in Evas_Object *child_obj; /*@ The object to pack in */
+ @in unsigned short col; /*@ The column to place it in */
+ @in unsigned short row; /*@ The row to place it in */
+ @in unsigned short colspan; /*@ Columns the child will take */
+ @in unsigned short rowspan; /*@ Rows the child will take */
+ }
+ }
+ part_text_input_panel_language_set {
+ /*@
+ Set the language mode of the input panel.
+
+ This API can be used if you want to show the Alphabet keyboard.
+
+ @since 1.2.0 */
+
+ params {
+ @in const char *part; /*@ The part name */
+ @in Edje_Input_Panel_Lang lang; /*@ the language to be set to the input panel. */
+ }
+ }
+ part_text_input_panel_language_get {
+ /*@
+ Get the language mode of the input panel.
+
+ See @ref edje_object_part_text_input_panel_language_set for more details.
+
+ @return input panel language type
+ @since 1.2.0 */
+
+ const;
+ return Edje_Input_Panel_Lang;
+ params {
+ @in const char *part; /*@ The part name */
+ }
+ }
+ part_table_col_row_size_get {
+ /*@
+ @brief Gets the number of columns and rows the table has.
+
+ @return @c EINA_TRUE get some data, @c EINA_FALSE on failure
+
+ Retrieves the size of the table in number of columns and rows. */
+
+ const;
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The part name */
+ @out int cols; /*@ Pointer where to store number of columns (can be NULL) */
+ @out int rows; /*@ Pointer where to store number of rows (can be NULL) */
+ }
+ }
+ part_external_object_get {
+ /*@
+ @brief Get the object created by this external part.
+
+ Parts of type external creates the part object using information
+ provided by external plugins. It's somehow like "swallow"
+ (edje_object_part_swallow()), but it's all set automatically.
+
+ This function returns the part created by such external plugins and
+ being currently managed by this Edje.
+
+ @note Almost all swallow rules apply: you should not move, resize,
+ hide, show, set the color or clipper of such part. It's a bit
+ more restrictive as one must @b never delete this object!
+
+ @return The externally created object, or NULL if there is none or
+ part is not an external. */
+
+ const;
+ return Evas_Object *;
+ params {
+ @in const char *part; /*@ The part name */
+ }
+ }
+ part_external_content_get {
+ /*@
+ @brief Get an object contained in an part of type EXTERNAL
+
+ The @p content string must not be NULL. Its actual value depends on the
+ code providing the EXTERNAL. */
+
+ const;
+ return Evas_Object *;
+ params {
+ @in const char *part; /*@ The name of the part holding the EXTERNAL */
+ @out const char content; /*@ A string identifying which content from the EXTERNAL to get */
+ }
+ }
+ preload {
+ /*@
+ @brief Preload the images on the Edje Object in the background.
+
+ @return @c EINA_FASLE if obj was not a valid Edje object
+ otherwise @c EINA_TRUE
+
+ This function requests the preload of all data images (on the given
+ object) in the background. The work is queued before being processed
+ (because there might be other pending requests of this type).
+ It emits a signal "preload,done" when finished.
+
+ @note Use @c EINA_TRUE on scenarios where you don't need
+ the image data preloaded anymore. */
+
+ return Eina_Bool;
+ params {
+ @in Eina_Bool cancel; /*@ @c EINA_FALSE will add it the preloading work queue,
+ @c EINA_TRUE will remove it (if it was issued before). */
+ }
+ }
+ part_text_input_panel_enabled_set {
+ /*@
+ @brief Sets the attribute to show the input panel automatically.
+
+ @since 1.1.0 */
+
+ params {
+ @in const char *part; /*@ The part name */
+ @in Eina_Bool enabled; /*@ If true, the input panel is appeared when entry is clicked or has a focus */
+ }
+ }
+ part_text_input_panel_enabled_get {
+ /*@
+ @brief Retrieve the attribute to show the input panel automatically.
+ @see edje_object_part_text_input_panel_enabled_set
+
+ @return EINA_TRUE if it supports or EINA_FALSE otherwise
+ @since 1.1.0 */
+
+ const;
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The part name */
+ }
+ }
+ part_text_select_extend {
+ /*@
+ @brief Extends the current selection to the current cursor position */
+
+ const;
+ params {
+ @in const char *part; /*@ The part name */
+ }
+ }
+ part_box_insert_at {
+ /*@
+ @brief Inserts an object to the box.
+
+ @return @c EINA_TRUE: Successfully added.\n
+ @c EINA_FALSE: An error occurred.
+
+ Adds child to the box indicated by part, in the position given by
+ pos.
+
+ @see edje_object_part_box_append()
+ @see edje_object_part_box_prepend()
+ @see edje_object_part_box_insert_before() */
+
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The part name */
+ @in Evas_Object *child; /*@ The object to insert */
+ @in unsigned int pos; /*@ The position where to insert child */
+ }
+ }
+ part_text_anchor_geometry_get {
+ /*@
+ @brief Return a list of Evas_Textblock_Rectangle anchor rectangles.
+
+ @return The list of anchor rects (const Evas_Textblock_Rectangle
+ *), do not modify! Geometry is relative to entry part.
+
+ This function return a list of Evas_Textblock_Rectangle anchor
+ rectangles. */
+
+ const;
+ return const Eina_List *;
+ params {
+ @in const char *part; /*@ The part name */
+ @in const char *anchor; /*@ The anchor name */
+ }
+ }
+ part_text_cursor_down {
+ /*@
+ @brief Moves the cursor to the char below the current cursor position. */
+
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The part name */
+ @in Edje_Cursor cur; /*@ the edje cursor to work on */
+ }
+ }
+ part_drag_page_set {
+ /*@
+ @brief Sets the page step increments.
+
+ Sets the x,y page step increment values.
+
+ Values for @p dx and @p dy are real numbers that range from 0 to 1,
+ representing the relative size of the dragable area on that axis by which the
+ part will be moved.
+
+ @see edje_object_part_drag_page_get() */
+
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The part name */
+ @in double dx; /*@ The x page step increment */
+ @in double dy; /*@ The y page step increment */
+ }
+ }
+ part_drag_page_get {
+ /*@
+ @brief Gets the page step increments.
+
+ Gets the x,y page step increments for the dragable object.
+
+ @see edje_object_part_drag_page_set() */
+
+ const;
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The part name */
+ @out double dx; /*@ The dx page increment pointer */
+ @out double dy; /*@ The dy page increment pointer */
+ }
+ }
+ part_box_prepend {
+ /*@
+ @brief Prepends an object to the box.
+
+ @return @c EINA_TRUE: Successfully added.\n
+ @c EINA_FALSE: An error occurred.
+
+ Prepends child to the box indicated by part.
+
+ @see edje_object_part_box_append()
+ @see edje_object_part_box_insert_before()
+ @see edje_object_part_box_insert_at() */
+
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The part name */
+ @in Evas_Object *child; /*@ The object to prepend */
+ }
+ }
+ signal_emit {
+ /*@
+ @brief Send/emit an Edje signal to a given Edje object
+
+ This function sends a signal to the object @a obj. An Edje program,
+ at @p obj's EDC specification level, can respond to a signal by
+ having declared matching @c 'signal' and @c 'source' fields on its
+ block (see @ref edcref "the syntax" for EDC files).
+
+ As an example,
+ @code
+ edje_object_signal_emit(obj, "a_signal", "");
+ @endcode
+ would trigger a program which had an EDC declaration block like
+ @code
+ program {
+ name: "a_program";
+ signal: "a_signal";
+ source: "";
+ action: ...
+ }
+ @endcode
+
+ @see edje_object_signal_callback_add() for more on Edje signals. */
+
+ params {
+ @in const char *emission; /*@ The signal's "emission" string */
+ @in const char *source; /*@ The signal's "source" string */
+ }
+ }
+ part_text_input_panel_layout_variation_set {
+ /*@
+ @brief Set the layout variation of the input panel.
+
+ The layout variation of the input panel or virtual keyboard can make it easier or
+ harder to enter content. This allows you to hint what kind of input you
+ are expecting to enter and thus have the input panel automatically
+ come up with the right mode.
+
+ @since 1.8 */
+
+ params {
+ @in const char *part; /*@ The part name */
+ @in int variation; /*@ layout variation type */
+ }
+ }
+ part_text_input_panel_layout_variation_get {
+ /*@
+ @brief Get the layout variation of the input panel.
+
+ @return Layout variation type of the input panel
+
+ @see edje_object_part_text_input_panel_layout_variation_set
+ @since 1.8 */
+
+ const;
+ return int;
+ params {
+ @in const char *part; /*@ The part name */
+ }
+ }
+ message_send {
+ /*@
+ @brief Send an (Edje) message to a given Edje object
+
+ This function sends an Edje message to @p obj and to all of its
+ child objects, if it has any (swallowed objects are one kind of
+ child object). @p type and @p msg @b must be matched accordingly,
+ as documented in #Edje_Message_Type.
+
+ The @p id argument as a form of code and theme defining a common
+ interface on message communication. One should define the same IDs
+ on both code and EDC declaration (see @ref edcref "the syntax" for
+ EDC files), to individualize messages (binding them to a given
+ context).
+
+ The function to handle messages arriving @b from @b obj is set with
+ edje_object_message_handler_set(). */
+
+ params {
+ @in Edje_Message_Type type; /*@ The type of message to send to @p obj */
+ @in int id; /*@ A identification number for the message to be sent */
+ @in void *msg; /*@ The message's body, a struct depending on @p type */
+ }
+ }
+ part_text_select_none {
+ /*@
+ @brief Set the selection to be none.
+
+ This function sets the selection text to be none. */
+
+ const;
+ params {
+ @in const char *part; /*@ The part name */
+ }
+ }
+ part_object_get {
+ /*@
+ @brief Get a handle to the Evas object implementing a given Edje
+ part, in an Edje object.
+
+ @return A pointer to the Evas object implementing the given part,
+ or @c NULL on failure (e.g. the given part doesn't exist)
+
+ This function gets a pointer of the Evas object corresponding to a
+ given part in the @p obj object's group.
+
+ You should @b never modify the state of the returned object (with
+ @c evas_object_move() or @c evas_object_hide() for example),
+ because it's meant to be managed by Edje, solely. You are safe to
+ query information about its current state (with @c
+ evas_object_visible_get() or @c evas_object_color_get() for
+ example), though. */
+
+ const;
+ return const Evas_Object *;
+ params {
+ @in const char *part; /*@ The Edje part's name */
+ }
+ }
+ part_drag_size_set {
+ /*@
+ @brief Set the dragable object size.
+
+ Values for @p dw and @p dh are real numbers that range from 0 to 1,
+ representing the relative size of the dragable area on that axis.
+
+ Sets the size of the dragable object.
+
+ @see edje_object_part_drag_size_get() */
+
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The part name */
+ @in double dw; /*@ The drag width */
+ @in double dh; /*@ The drag height */
+ }
+ }
+ part_drag_size_get {
+ /*@
+ @brief Get the dragable object size.
+
+ Gets the dragable object size.
+
+ @see edje_object_part_drag_size_set() */
+
+ const;
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The part name */
+ @out double dw; /*@ The drag width pointer */
+ @out double dh; /*@ The drag height pointer */
+ }
+ }
+ text_insert_filter_callback_del {
+ /*@
+ Delete a function from the filter list.
+
+ Delete the given @p func filter from the list in @p part. Returns
+ the user data pointer given when added.
+
+ @see edje_object_text_insert_filter_callback_add
+ @see edje_object_text_insert_filter_callback_del_full
+
+ @return The user data pointer if successful, or NULL otherwise */
+
+ return void *;
+ params {
+ @in const char *part; /*@ The part name */
+ @in Edje_Text_Filter_Cb func; /*@ The function callback to remove */
+ }
+ }
+ part_drag_dir_get {
+ /*@
+ @brief Determine dragable directions.
+
+ The dragable directions are defined in the EDC file, inside the @c dragable
+ section, by the attributes @c x and @c y. See the @ref edcref for more
+ information.
+
+ @return #EDJE_DRAG_DIR_NONE: Not dragable\n
+ #EDJE_DRAG_DIR_X: Dragable in X direction\n
+ #EDJE_DRAG_DIR_Y: Dragable in Y direction\n
+ #EDJE_DRAG_DIR_XY: Dragable in X & Y directions */
+
+ const;
+ return Edje_Drag_Dir;
+ params {
+ @in const char *part; /*@ The part name */
+ }
+ }
+ part_text_unescaped_set {
+ /*@
+ @brief Sets the raw (non escaped) text for an object part.
+
+ This funciton will not do escape for you if it is a TEXTBLOCK part, that is,
+ if text contain tags, these tags will not be interpreted/parsed by TEXTBLOCK.
+
+ @see edje_object_part_text_unescaped_get(). */
+
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The part name */
+ @in const char *text_to_escape; /*@ The text string */
+ }
+ }
+ part_text_unescaped_get {
+ /*@
+ @brief Returns the text of the object part, without escaping.
+
+ @return The @b allocated text string without escaping, or NULL on
+ problems.
+
+ This function is the counterpart of
+ edje_object_part_text_unescaped_set(). Please notice that the
+ result is newly allocated memory and should be released with free()
+ when done.
+
+ @see edje_object_part_text_unescaped_set(). */
+
+ const;
+ return char *;
+ params {
+ @in const char *part; /*@ The part name */
+ }
+ }
+ signal_callback_add {
+ /*@
+ @brief Add a callback for an arriving Edje signal, emitted by
+ a given Edje object.
+
+ Edje signals are one of the communication interfaces between
+ @b code and a given Edje object's @b theme. With signals, one can
+ communicate two string values at a time, which are:
+ - "emission" value: the name of the signal, in general
+ - "source" value: a name for the signal's context, in general
+
+ Though there are those common uses for the two strings, one is free
+ to use them however they like.
+
+ This function adds a callback function to a signal emitted by @a obj, to
+ be issued every time an EDC program like the following
+ @code
+ program {
+ name: "emit_example";
+ action: SIGNAL_EMIT "a_signal" "a_source";
+ }
+ @endcode
+ is run, if @p emission and @p source are given those same values,
+ here.
+
+ Signal callback registration is powerful, in the way that @b blobs
+ may be used to match multiple signals at once. All the @c
+ "*?[\" set of @c fnmatch() operators can be used, both for @p
+ emission and @p source.
+
+ Edje has @b internal signals it will emit, automatically, on
+ various actions taking place on group parts. For example, the mouse
+ cursor being moved, pressed, released, etc., over a given part's
+ area, all generate individual signals.
+
+ By using something like
+ @code
+ edje_object_signal_callback_add(obj, "mouse,down,*", "button.*",
+ signal_cb, NULL);
+ @endcode
+ being @c "button.*" the pattern for the names of parts implementing
+ buttons on an interface, you'd be registering for notifications on
+ events of mouse buttons being pressed down on either of those parts
+ (those events all have the @c "mouse,down," common prefix on their
+ names, with a suffix giving the button number). The actual emission
+ and source strings of an event will be passed in as the @a emission
+ and @a source parameters of the callback function (e.g. @c
+ "mouse,down,2" and @c "button.close"), for each of those events.
+
+ @note See @ref edcref "the syntax" for EDC files
+ @see edje_object_signal_emit() on how to emits Edje signals from
+ code to a an object
+ @see edje_object_signal_callback_del_full() */
+
+ params {
+ @in const char *emission; /*@ The signal's "emission" string */
+ @in const char *source; /*@ The signal's "source" string */
+ @in Edje_Signal_Cb func; /*@ The callback function to be executed when the signal is
+ emitted. */
+ @in void *data; /*@ A pointer to data to pass in to @p func. */
+ }
+ }
+ part_text_select_all {
+ /*@
+ @brief Set the selection to be everything.
+
+ This function selects all text of the object of the part. */
+
+ const;
+ params {
+ @in const char *part; /*@ The part name */
+ }
+ }
+ part_text_input_panel_return_key_disabled_set {
+ /*@
+ Set the return key on the input panel to be disabled.
+
+ @since 1.2.0 */
+
+ params {
+ @in const char *part; /*@ The part name */
+ @in Eina_Bool disabled; /*@ The state */
+ }
+ }
+ part_text_input_panel_return_key_disabled_get {
+ /*@
+ Get whether the return key on the input panel should be disabled or not.
+
+ @return EINA_TRUE if it should be disabled
+ @since 1.2.0 */
+
+ const;
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The part name */
+ }
+ }
+ part_text_autocapital_type_set {
+ /*@
+ @brief Set the autocapitalization type on the immodule.
+
+ @since 1.1.0 */
+
+ params {
+ @in const char *part; /*@ The part name */
+ @in Edje_Text_Autocapital_Type autocapital_type; /*@ The type of autocapitalization */
+ }
+ }
+ part_text_autocapital_type_get {
+ /*@
+ @brief Retrieves the autocapitalization type
+
+ @return The autocapitalization type
+ @since 1.1.0 */
+
+ const;
+ return Edje_Text_Autocapital_Type;
+ params {
+ @in const char *part; /*@ The part name */
+ }
+ }
+ part_unswallow {
+ /*@
+ @brief Unswallow an object.
+
+ Causes the edje to regurgitate a previously swallowed object. :)
+
+ @note @p obj_swallow will @b not be deleted or hidden.
+ @note @p obj_swallow may appear shown on the evas depending on its state when
+ it got unswallowed. Make sure you delete it or hide it if you do not want it to. */
+
+ params {
+ @in Evas_Object *obj_swallow; /*@ The swallowed object */
+ }
+ }
+ part_text_prediction_allow_set {
+ /*@
+ @brief Set whether the prediction is allowed or not.
+
+ @since 1.2.0 */
+
+ params {
+ @in const char *part; /*@ The part name */
+ @in Eina_Bool prediction; /*@ If true, the prediction feature is allowed. */
+ }
+ }
+ part_text_prediction_allow_get {
+ /*@
+ @brief Get whether the prediction is allowed or not.
+
+ @return EINA_TRUE if prediction feature is allowed.
+ @since 1.2.0 */
+
+ const;
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The part name */
+ }
+ }
+ data_get {
+ /*@
+ @brief Retrive an EDC data field's value from a given Edje
+ object's group.
+
+ @return The data's value string. Must not be freed.
+
+ This function fetches an EDC data field's value, which is declared
+ on the objects building EDC file, under its group. EDC data
+ blocks are most commonly used to pass arbitrary parameters from an
+ application's theme to its code.
+
+ They look like the following:
+
+ @code
+ collections {
+ group {
+ name: "a_group";
+ data {
+ item: "key1" "value1";
+ item: "key2" "value2";
+ }
+ }
+ }
+ @endcode
+
+ EDC data fields always hold @b strings as values, hence the return
+ type of this function. Check the complete @ref edcref "syntax reference"
+ for EDC files.
+
+ @warning Do not confuse this call with edje_file_data_get(), which
+ queries for a @b global EDC data field on an EDC declaration file.
+
+ @see edje_object_file_set() */
+
+ const;
+ return const char *;
+ params {
+ @in const char *key; /*@ The data field's key string */
+ }
+ }
+ text_markup_filter_callback_add {
+ /*@
+ Add a markup filter function for newly inserted text.
+
+ Whenever text is inserted (not the same as set) into the given @p part,
+ the list of markup filter functions will be called to decide if and how
+ the new text will be accepted.
+ The text parameter in the @p func filter is always markup. It can be
+ modified by the user and it's up to him to free the one passed if he's to
+ change the pointer. If doing so, the newly set text should be malloc'ed,
+ as once all the filters are called Edje will free it.
+ If the text is to be rejected, freeing it and setting the pointer to NULL
+ will make Edje break out of the filter cycle and reject the inserted
+ text.
+ This function is different from edje_object_text_insert_filter_callback_add()
+ in that the text parameter in the @p fucn filter is always markup.
+
+ @warning If you use this function with
+ edje_object_text_insert_filter_callback_add() togehter, all
+ Edje_Text_Filter_Cb functions and Edje_Markup_Filter_Cb functions
+ will be executed, and then filtered text will be inserted.
+
+ @see edje_object_text_markup_filter_callback_del
+ @see edje_object_text_markup_filter_callback_del_full
+ @see edje_object_text_insert_filter_callback_add
+
+ @since 1.2.0 */
+
+ params {
+ @in const char *part; /*@ The part name */
+ @in Edje_Markup_Filter_Cb func; /*@ The callback function that will act as markup filter */
+ @in void *data; /*@ User provided data to pass to the filter function */
+ }
+ }
+ message_signal_process {
+ /*@
+ @brief Process an object's message queue.
+
+ This function goes through the object message queue processing the
+ pending messages for @b this specific Edje object. Normally they'd
+ be processed only at idle time. */
+
+ }
+ part_box_remove {
+ /*@
+ @brief Removes an object from the box.
+
+ @return Pointer to the object removed, or @c NULL.
+
+ Removes child from the box indicated by part.
+
+ @see edje_object_part_box_remove_at()
+ @see edje_object_part_box_remove_all() */
+
+ return Evas_Object *;
+ params {
+ @in const char *part; /*@ The part name */
+ @in Evas_Object *child; /*@ The object to remove */
+ }
+ }
+ thaw {
+ /*@
+ @brief Thaws the Edje object.
+
+ @return The frozen state or 0 if the object is not frozen or on error.
+
+ This function thaws the given Edje object.
+
+ @note: If sucessives freezes were done, an equal number of
+ thaws will be required.
+
+ @see edje_object_freeze() */
+
+ return int;
+ }
+ part_swallow_get {
+ /*@
+ @brief Get the object currently swallowed by a part.
+
+ @return The swallowed object, or NULL if there is none. */
+
+ const;
+ return Evas_Object *;
+ params {
+ @in const char *part; /*@ The part name */
+ }
+ }
+ part_text_imf_context_reset {
+ /*@
+ @brief Reset the input method context if needed.
+
+ This can be necessary in the case where modifying the buffer would confuse on-going input method behavior
+
+ @since 1.2.0 */
+
+ const;
+ params {
+ @in const char *part; /*@ The part name */
+ }
+ }
+ part_text_input_panel_return_key_type_set {
+ /*@
+ Set the "return" key type. This type is used to set string or icon on the "return" key of the input panel.
+
+ An input panel displays the string or icon associated with this type
+
+ @since 1.2.0 */
+
+ params {
+ @in const char *part; /*@ The part name */
+ @in Edje_Input_Panel_Return_Key_Type return_key_type; /*@ The type of "return" key on the input panel */
+ }
+ }
+ part_text_input_panel_return_key_type_get {
+ /*@
+ Get the "return" key type.
+
+ @see edje_object_part_text_input_panel_return_key_type_set() for more details
+
+ @return The type of "return" key on the input panel
+ @since 1.2.0 */
+
+ const;
+ return Edje_Input_Panel_Return_Key_Type;
+ params {
+ @in const char *part; /*@ The part name */
+ }
+ }
+ part_table_child_get {
+ /*@
+ @brief Retrieve a child from a table
+
+ @return The child Evas_Object */
+
+ const;
+ return Evas_Object *;
+ params {
+ @in const char *part; /*@ The part name */
+ @in unsigned int col; /*@ The column of the child to get */
+ @in unsigned int row; /*@ The row of the child to get */
+ }
+ }
+ part_box_insert_before {
+ /*@
+ @brief Adds an object to the box.
+
+ @return @c EINA_TRUE: Successfully added.\n
+ @c EINA_FALSE: An error occurred.
+
+ Inserts child in the box given by part, in the position marked by
+ reference.
+
+ @see edje_object_part_box_append()
+ @see edje_object_part_box_prepend()
+ @see edje_object_part_box_insert_at() */
+
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The part name */
+ @in Evas_Object *child; /*@ The object to insert */
+ @in const Evas_Object *reference; /*@ The object to be used as reference */
+ }
+ }
+ part_external_param_set {
+ /*@
+ @brief Set the parameter for the external part.
+
+ Parts of type external may carry extra properties that have
+ meanings defined by the external plugin. For instance, it may be a
+ string that defines a button label and setting this property will
+ change that label on the fly.
+
+ @note external parts have parameters set when they change
+ states. Those parameters will never be changed by this
+ function. The interpretation of how state_set parameters and
+ param_set will interact is up to the external plugin.
+
+ @note this function will not check if parameter value is valid
+ using #Edje_External_Param_Info minimum, maximum, valid
+ choices and others. However these should be checked by the
+ underlying implementation provided by the external
+ plugin. This is done for performance reasons.
+
+ @return @c EINA_TRUE if everything went fine, @c EINA_FALSE on errors. */
+
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The part name */
+ @in const Edje_External_Param *param; /*@ the parameter details, including its name, type and
+ actual value. This pointer should be valid, and the
+ parameter must exist in
+ #Edje_External_Type::parameters_info, with the exact type,
+ otherwise the operation will fail and @c EINA_FALSE will be
+ returned. */
+ }
+ }
+ part_external_param_get {
+ /*@
+ @brief Get the parameter for the external part.
+
+ Parts of type external may carry extra properties that have
+ meanings defined by the external plugin. For instance, it may be a
+ string that defines a button label. This property can be modified by
+ state parameters, by explicit calls to
+ edje_object_part_external_param_set() or getting the actual object
+ with edje_object_part_external_object_get() and calling native
+ functions.
+
+ This function asks the external plugin what is the current value,
+ independent on how it was set.
+
+ @return @c EINA_TRUE if everything went fine and @p param members
+ are filled with information, @c EINA_FALSE on errors and @p
+ param member values are not set or valid. */
+
+ const;
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The part name */
+ @out Edje_External_Param param; /*@ the parameter details. It is used as both input and
+ output variable. This pointer should be valid, and the
+ parameter must exist in
+ #Edje_External_Type::parameters_info, with the exact type,
+ otherwise the operation will fail and @c EINA_FALSE will be
+ returned. */
+ }
+ }
+ size_min_calc {
+ /*@
+ @brief Calculate the minimum required size for a given Edje object.
+
+ This call works exactly as edje_object_size_min_restricted_calc(),
+ with the last two arguments set to 0. Please refer to its
+ documentation, then. */
+
+ params {
+ @out Evas_Coord minw; /*@ Pointer to a variable where to store the minimum
+ required width */
+ @out Evas_Coord minh; /*@ Pointer to a variable where to store the minimum
+ required height */
+ }
+ }
+ part_box_append {
+ /*@
+ @brief Appends an object to the box.
+
+ @return @c EINA_TRUE: Successfully added.\n
+ @c EINA_FALSE: An error occurred.
+
+ Appends child to the box indicated by part.
+
+ @see edje_object_part_box_prepend()
+ @see edje_object_part_box_insert_before()
+ @see edje_object_part_box_insert_at() */
+
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The part name */
+ @in Evas_Object *child; /*@ The object to append */
+ }
+ }
+ size_min_restricted_calc {
+ /*@
+ @brief Calculate the minimum required size for a given Edje object.
+
+ This call will trigger an internal recalculation of all parts of
+ the @p obj object, in order to return its minimum required
+ dimensions for width and height. The user might choose to @b impose
+ those minimum sizes, making the resulting calculation to get to values
+ equal or bigger than @p restrictedw and @p restrictedh, for width and
+ height, respectively.
+
+ @note At the end of this call, @p obj @b won't be automatically
+ resized to new dimensions, but just return the calculated
+ sizes. The caller is the one up to change its geometry or not.
+
+ @warning Be advised that invisible parts in @p obj @b will be taken
+ into account in this calculation. */
+
+ params {
+ @out Evas_Coord minw; /*@ Pointer to a variable where to store the minimum
+ required width */
+ @out Evas_Coord minh; /*@ Pointer to a variable where to store the minimum
+ required height */
+ @in Evas_Coord restrictedw; /*@ Do not allow object's calculated (minimum) width
+ to be less than this value */
+ @in Evas_Coord restrictedh; /*@ Do not allow object's calculated (minimum)
+ height to be less than this value */
+ }
+ }
+ part_box_remove_all {
+ /*@
+ @brief Removes all elements from the box.
+
+ @return 1: Successfully cleared.\n
+ 0: An error occurred.
+
+ Removes all the external objects from the box indicated by part.
+ Elements created from the theme will not be removed.
+
+ @see edje_object_part_box_remove()
+ @see edje_object_part_box_remove_at() */
+
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The part name */
+ @in Eina_Bool clear; /*@ Delete objects on removal */
+ }
+ }
+ part_drag_page {
+ /*@
+ @brief Pages x,y steps.
+
+ Pages x,y where the increment is defined by
+ edje_object_part_drag_page_set.
+
+ Values for @p dx and @p dy are real numbers that range from 0 to 1.
+
+ @warning Paging is bugged!
+
+ @see edje_object_part_drag_step() */
+
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The part name */
+ @in double dx; /*@ The x step */
+ @in double dy; /*@ The y step */
+ }
+ }
+ part_text_set {
+ /*@
+ @brief Sets the text for an object part
+
+ @return @c EINA_TRUE on success, @c EINA_FALSE otherwise */
+
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The part name */
+ @in const char *text; /*@ The text string */
+ }
+ }
+ part_text_get {
+ /*@
+ @brief Return the text of the object part.
+
+ @return The text string
+
+ This function returns the text associated to the object part.
+
+ @see edje_object_part_text_set(). */
+
+ const;
+ return const char *;
+ params {
+ @in const char *part; /*@ The part name */
+ }
+ }
+ part_text_input_panel_show_on_demand_set {
+ /*@
+ Set the attribute to show the input panel in case of only an user's explicit Mouse Up event.
+ It doesn't request to show the input panel even though it has focus.
+
+ @since 1.9.0 */
+
+ params {
+ @in const char *part; /*@ The part name */
+ @in Eina_Bool ondemand; /*@ If true, the input panel will be shown in case of only Mouse up event. (Focus event will be ignored.) */
+ }
+ }
+ part_text_input_panel_show_on_demand_get {
+ /*@
+ Get the attribute to show the input panel in case of only an user's explicit Mouse Up event.
+
+ @return @c EINA_TRUE if the input panel will be shown in case of only Mouse up event.
+ @since 1.9.0 */
+
+ const;
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The part name */
+ }
+ }
+ part_text_selection_get {
+ /*@
+ @brief Return the selection text of the object part.
+
+ @return The text string
+
+ This function returns selection text of the object part.
+
+ @see edje_object_part_text_select_all()
+ @see edje_object_part_text_select_none() */
+
+ const;
+ return const char *;
+ params {
+ @in const char *part; /*@ The part name */
+ }
+ }
+ part_text_cursor_is_format_get {
+ /*@
+ @brief Returns whether the cursor points to a format.
+ @see evas_textblock_cursor_is_format
+
+ @return EINA_TRUE if it's true, EINA_FALSE otherwise. */
+
+ const;
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The part name */
+ @in Edje_Cursor cur; /*@ The cursor to adjust. */
+ }
+ }
+ color_class_set {
+ /*@
+ @brief Sets the object color class.
+
+ This function sets the color values for an object level color
+ class. This will cause all edje parts in the specified object that
+ have the specified color class to have their colors multiplied by
+ these values.
+
+ The first color is the object, the second is the text outline, and
+ the third is the text shadow. (Note that the second two only apply
+ to text parts).
+
+ Setting color emits a signal "color_class,set" with source being
+ the given color.
+
+ @note unlike Evas, Edje colors are @b not pre-multiplied. That is,
+ half-transparent white is 255 255 255 128. */
+
+ return Eina_Bool;
+ params {
+ @in const char *color_class;
+ @in int r; /*@ Object Red value */
+ @in int g; /*@ Object Green value */
+ @in int b; /*@ Object Blue value */
+ @in int a; /*@ Object Alpha value */
+ @in int r2; /*@ Outline Red value */
+ @in int g2; /*@ Outline Green value */
+ @in int b2; /*@ Outline Blue value */
+ @in int a2; /*@ Outline Alpha value */
+ @in int r3; /*@ Shadow Red value */
+ @in int g3; /*@ Shadow Green value */
+ @in int b3; /*@ Shadow Blue value */
+ @in int a3; /*@ Shadow Alpha value */
+ }
+ }
+ color_class_get {
+ /*@
+ @brief Gets the object color class.
+
+ @return EINA_TRUE if found or EINA_FALSE if not found and all
+ values are zeroed.
+
+ This function gets the color values for an object level color
+ class. If no explicit object color is set, then global values will
+ be used.
+
+ The first color is the object, the second is the text outline, and
+ the third is the text shadow. (Note that the second two only apply
+ to text parts).
+
+ @note unlike Evas, Edje colors are @b not pre-multiplied. That is,
+ half-transparent white is 255 255 255 128. */
+
+ const;
+ return Eina_Bool;
+ params {
+ @in const char *color_class;
+ @out int r; /*@ Object Red value */
+ @out int g; /*@ Object Green value */
+ @out int b; /*@ Object Blue value */
+ @out int a; /*@ Object Alpha value */
+ @out int r2; /*@ Outline Red value */
+ @out int g2; /*@ Outline Green value */
+ @out int b2; /*@ Outline Blue value */
+ @out int a2; /*@ Outline Alpha value */
+ @out int r3; /*@ Shadow Red value */
+ @out int g3; /*@ Shadow Green value */
+ @out int b3; /*@ Shadow Blue value */
+ @out int a3; /*@ Shadow Alpha value */
+ }
+ }
+ part_drag_step {
+ /*@
+ @brief Steps the dragable x,y steps.
+
+ Steps x,y where the step increment is the amount set by
+ edje_object_part_drag_step_set.
+
+ Values for @p dx and @p dy are real numbers that range from 0 to 1.
+
+ @see edje_object_part_drag_page() */
+
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The part name */
+ @in double dx; /*@ The x step */
+ @in double dy; /*@ The y step */
+ }
+ }
+ part_text_cursor_up {
+ /*@
+ @brief Move the cursor to the char above the current cursor position. */
+
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The part name */
+ @in Edje_Cursor cur; /*@ the edje cursor to work on */
+ }
+ }
+ part_text_cursor_geometry_get {
+ /*@
+ @brief Returns the cursor geometry of the part relative to the edje
+ object. */
+
+ const;
+ params {
+ @in const char *part; /*@ The part name */
+ @out Evas_Coord x; /*@ Cursor X position */
+ @out Evas_Coord y; /*@ Cursor Y position */
+ @out Evas_Coord w; /*@ Cursor width */
+ @out Evas_Coord h; /*@ Cursor height */
+ }
+ }
+ part_text_anchor_list_get {
+ /*@
+ @brief Return a list of char anchor names.
+
+ @return The list of anchors (const char *), do not modify!
+
+ This function returns a list of char anchor names. */
+
+ const;
+ return const Eina_List *;
+ params {
+ @in const char *part; /*@ The part name */
+ }
+ }
+ text_insert_filter_callback_add {
+ /*@
+ Add a filter function for newly inserted text.
+
+ Whenever text is inserted (not the same as set) into the given @p part,
+ the list of filter functions will be called to decide if and how the new
+ text will be accepted.
+ There are three types of filters, EDJE_TEXT_FILTER_TEXT,
+ EDJE_TEXT_FILTER_FORMAT and EDJE_TEXT_FILTER_MARKUP.
+ The text parameter in the @p func filter can be modified by the user and
+ it's up to him to free the one passed if he's to change the pointer. If
+ doing so, the newly set text should be malloc'ed, as once all the filters
+ are called Edje will free it.
+ If the text is to be rejected, freeing it and setting the pointer to NULL
+ will make Edje break out of the filter cycle and reject the inserted
+ text.
+
+ @warning This function will be deprecated because of difficulty in use.
+ The type(format, text, or markup) of text should be always
+ checked in the filter function for correct filtering.
+ Please use edje_object_text_markup_filter_callback_add() instead. There
+ is no need to check the type of text in the filter function
+ because the text is always markup.
+ @warning If you use this function with
+ edje_object_text_markup_filter_callback_add() together, all
+ Edje_Text_Filter_Cb functions and Edje_Markup_Filter_Cb functions
+ will be executed, and then filtered text will be inserted.
+
+ @see edje_object_text_insert_filter_callback_del
+ @see edje_object_text_insert_filter_callback_del_full
+ @see edje_object_text_markup_filter_callback_add */
+
+ params {
+ @in const char *part; /*@ The part name */
+ @in Edje_Text_Filter_Cb func; /*@ The callback function that will act as filter */
+ @in void *data; /*@ User provided data to pass to the filter function */
+ }
+ }
+ part_text_input_panel_show {
+ /*@
+ @brief Show the input panel (virtual keyboard) based on the input panel property such as layout, autocapital types, and so on.
+
+ Note that input panel is shown or hidden automatically according to the focus state.
+ This API can be used in the case of manually controlling by using edje_object_part_text_input_panel_enabled_set.
+
+ @since 1.2.0 */
+
+ const;
+ params {
+ @in const char *part; /*@ The part name */
+ }
+ }
+ part_exists {
+ /*@
+ @brief Check if an Edje part exists in a given Edje object's group
+ definition.
+
+ @return @c EINA_TRUE, if the Edje part exists in @p obj's group or
+ @c EINA_FALSE, otherwise (and on errors)
+
+ This function returns if a given part exists in the Edje group
+ bound to object @p obj (with edje_object_file_set()).
+
+ This call is useful, for example, when one could expect or not a
+ given GUI element, depending on the @b theme applied to @p obj. */
+
+ const;
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The part's name to check for existence in @p obj's
+ group */
+ }
+ }
+ text_markup_filter_callback_del {
+ /*@
+ Delete a function from the markup filter list.
+
+ Delete the given @p func filter from the list in @p part. Returns
+ the user data pointer given when added.
+
+ @see edje_object_text_markup_filter_callback_add
+ @see edje_object_text_markup_filter_callback_del_full
+
+ @return The user data pointer if successful, or NULL otherwise
+ @since 1.2.0 */
+
+ return void *;
+ params {
+ @in const char *part; /*@ The part name */
+ @in Edje_Markup_Filter_Cb func; /*@ The function callback to remove */
+ }
+ }
+ part_text_cursor_is_visible_format_get {
+ /*@
+ @brief Return true if the cursor points to a visible format
+ For example \\t, \\n, item and etc.
+ @see evas_textblock_cursor_format_is_visible_get */
+
+ const;
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The part name */
+ @in Edje_Cursor cur; /*@ The cursor to adjust. */
+ }
+ }
+ part_text_user_insert {
+ /*@
+ @brief This function inserts text as if the user has inserted it.
+
+ This means it actually registers as a change and emits signals, triggers
+ callbacks as appropriate.
+
+ @since 1.2.0 */
+
+ const;
+ params {
+ @in const char *part; /*@ The part name */
+ @in const char *text; /*@ The text string */
+ }
+ }
+ part_text_cursor_prev {
+ /*@
+ @brief Moves the cursor to the previous char
+ @see evas_textblock_cursor_char_prev */
+
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The part name */
+ @in Edje_Cursor cur; /*@ the edje cursor to work on */
+ }
+ }
+ part_text_item_list_get {
+ /*@
+ @brief Return a list of char item names.
+
+ @return The list of items (const char *), do not modify!
+
+ This function returns a list of char item names. */
+
+ const;
+ return const Eina_List *;
+ params {
+ @in const char *part; /*@ The part name */
+ }
+ }
+ part_swallow {
+ /*@
+ @brief "Swallows" an object into one of the Edje object @c SWALLOW
+ parts.
+
+ Swallowing an object into an Edje object is, for a given part of
+ type @c SWALLOW in the EDC group which gave life to @a obj, to set
+ an external object to be controlled by @a obj, being displayed
+ exactly over that part's region inside the whole Edje object's
+ viewport.
+
+ From this point on, @a obj will have total control over @a
+ obj_swallow's geometry and visibility. For instance, if @a obj is
+ visible, as in @c evas_object_show(), the swallowed object will be
+ visible too -- if the given @c SWALLOW part it's in is also
+ visible. Other actions on @a obj will also reflect on the swallowed
+ object as well (e.g. resizing, moving, raising/lowering, etc.).
+
+ Finally, all internal changes to @a part, specifically, will
+ reflect on the displaying of @a obj_swallow, for example state
+ changes leading to different visibility states, geometries,
+ positions, etc.
+
+ If an object has already been swallowed into this part, then it
+ will first be unswallowed (as in edje_object_part_unswallow())
+ before the new object is swallowed.
+
+ @note @a obj @b won't delete the swallowed object once it is
+ deleted -- @a obj_swallow will get to an unparented state again.
+
+ For more details on EDC @c SWALLOW parts, see @ref edcref "syntax
+ reference". */
+
+ return Eina_Bool;
+ params {
+ @in const char *part; /*@ The swallow part's name */
+ @in Evas_Object *obj_swallow; /*@ The object to occupy that part */
+ }
+ }
+ }
+ implements {
+ Eo_Base::constructor;
+ Eo_Base::destructor;
+ Eo_Base::dbg_info_get;
+ Evas_Smart::hide;
+ Evas_Smart::calculate;
+ Evas_Smart::show;
+ Evas_Smart::move;
+ Evas_Smart::add;
+ Evas_Smart::del;
+ Evas_Smart::resize;
+ }
+}
diff --git a/src/lib/edje/edje_calc.c b/src/lib/edje/edje_calc.c
index 00c25db3ce..073827c69c 100644
--- a/src/lib/edje/edje_calc.c
+++ b/src/lib/edje/edje_calc.c
@@ -635,17 +635,17 @@ _edje_part_description_apply(Edje *ed, Edje_Real_Part *ep, const char *d1, doubl
void
_edje_recalc(Edje *ed)
{
- if ((ed->freeze > 0) || (_edje_freeze_val > 0))
+ if ((ed->freeze > 0) || (_edje_util_freeze_val > 0))
{
ed->recalc = EINA_TRUE;
if (!ed->calc_only)
{
- if (_edje_freeze_val > 0)
+ if (_edje_util_freeze_val > 0)
{
if (!ed->freeze_calc)
{
- _edje_freeze_calc_count++;
- _edje_freeze_calc_list = eina_list_append(_edje_freeze_calc_list, ed);
+ _edje_util_freeze_calc_count++;
+ _edje_util_freeze_calc_list = eina_list_append(_edje_util_freeze_calc_list, ed);
ed->freeze_calc = EINA_TRUE;
}
}
diff --git a/src/lib/edje/edje_callbacks.c b/src/lib/edje/edje_callbacks.c
index 5ea7efbd05..a30ff7738a 100644
--- a/src/lib/edje/edje_callbacks.c
+++ b/src/lib/edje/edje_callbacks.c
@@ -108,7 +108,7 @@ _edje_mouse_down_signal_cb(void *data, Eo *obj, const Eo_Event_Description *desc
ignored = rp->part->ignore_flags & ev->event_flags;
_edje_ref(ed);
- _edje_freeze(ed);
+ _edje_util_freeze(ed);
if ((!ev->event_flags) || (!ignored))
{
@@ -154,7 +154,7 @@ _edje_mouse_down_signal_cb(void *data, Eo *obj, const Eo_Event_Description *desc
rp->still_in = EINA_TRUE;
}
// _edje_recalc_do(ed);
- _edje_thaw(ed);
+ _edje_util_thaw(ed);
_edje_unref(ed);
return EO_CALLBACK_CONTINUE;
@@ -178,7 +178,7 @@ _edje_mouse_up_signal_cb(void *data, Eo *obj, const Eo_Event_Description *desc E
ignored = rp->part->ignore_flags & ev->event_flags;
_edje_ref(ed);
- _edje_freeze(ed);
+ _edje_util_freeze(ed);
if ((!ev->event_flags) || (!ignored))
{
@@ -228,7 +228,7 @@ _edje_mouse_up_signal_cb(void *data, Eo *obj, const Eo_Event_Description *desc E
rp->still_in = EINA_FALSE;
// _edje_recalc_do(ed);
- _edje_thaw(ed);
+ _edje_util_thaw(ed);
_edje_unref(ed);
return EO_CALLBACK_CONTINUE;
@@ -285,7 +285,7 @@ _edje_mouse_move_signal_cb(void *data, Eo *obj, const Eo_Event_Description *desc
rp->still_in = EINA_TRUE;
}
}
- _edje_freeze(ed);
+ _edje_util_freeze(ed);
if (rp->drag)
{
if (rp->drag->down.count > 0)
@@ -328,7 +328,7 @@ _edje_mouse_move_signal_cb(void *data, Eo *obj, const Eo_Event_Description *desc
}
}
_edje_unref(ed);
- _edje_thaw(ed);
+ _edje_util_thaw(ed);
return EO_CALLBACK_CONTINUE;
}
@@ -376,7 +376,7 @@ _edje_timer_cb(void *data EINA_UNUSED)
ed = eina_list_data_get(animl);
_edje_block(ed);
- _edje_freeze(ed);
+ _edje_util_freeze(ed);
animl = eina_list_remove(animl, eina_list_data_get(animl));
if ((!ed->paused) && (!ed->delete_me))
{
@@ -423,7 +423,7 @@ _edje_timer_cb(void *data EINA_UNUSED)
}
break_prog:
_edje_unblock(ed);
- _edje_thaw(ed);
+ _edje_util_thaw(ed);
_edje_unref(ed);
}
if (_edje_anim_count > 0) return ECORE_CALLBACK_RENEW;
diff --git a/src/lib/edje/edje_edit.c b/src/lib/edje/edje_edit.c
index 7f3d9dafed..834391928b 100644
--- a/src/lib/edje/edje_edit.c
+++ b/src/lib/edje/edje_edit.c
@@ -150,10 +150,9 @@ _edje_edit_data_clean(Edje_Edit *eed)
eed->script_need_recompile = EINA_FALSE;
}
-static void
-_edje_edit_smart_del(Eo *obj, void *_pd, va_list *list EINA_UNUSED)
+EOLIAN static void
+_edje_edit_evas_smart_del(Eo *obj, Edje_Edit *eed)
{
- Edje_Edit *eed = _pd;
_edje_edit_data_clean(eed);
eo_do_super(obj, MY_CLASS, evas_obj_smart_del());
@@ -167,19 +166,16 @@ _edje_edit_program_script_free(Program_Script *ps)
free(ps);
}
-static void
-_edje_edit_smart_file_set(Eo *obj, void *_pd, va_list *list)
+EOLIAN static Eina_Bool
+_edje_edit_edje_file_set(Eo *obj, Edje_Edit *eed, const char *file, const char *group)
{
- const char *file = va_arg(*list, const char *);
- const char *group= va_arg(*list, const char *);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- Edje_Edit *eed = _pd;
+ Eina_Bool ret;
Eet_File *ef;
char **keys, buf[64];
int count, i;
int len = strlen("edje/scripts/embryo/source/");
- if (ret) *ret = EINA_FALSE;
+ ret = EINA_FALSE;
_edje_edit_data_clean(eed);
@@ -199,7 +195,7 @@ _edje_edit_smart_file_set(Eo *obj, void *_pd, va_list *list)
Eina_Bool int_ret = EINA_FALSE;
eo_do_super(obj, MY_CLASS, edje_obj_file_set(file, group, &int_ret));
if (!int_ret)
- return;
+ return ret;
eed->program_scripts = eina_hash_int32_new((Eina_Free_Cb)_edje_edit_program_script_free);
@@ -226,7 +222,9 @@ _edje_edit_smart_file_set(Eo *obj, void *_pd, va_list *list)
if (keys) free(keys);
eet_close(ef);
- if (ret) *ret = EINA_TRUE;
+ ret = EINA_TRUE;
+
+ return ret;
}
EAPI Evas_Object *
@@ -238,21 +236,21 @@ edje_edit_object_add(Evas *evas)
return e;
}
-static void
-_edje_edit_constructor(Eo *obj, void *class_data, va_list *list EINA_UNUSED)
+EOLIAN static void
+_edje_edit_eo_base_constructor(Eo *obj, Edje_Edit *eed)
{
- Edje_Edit *eed = class_data;
eed->base = eo_data_ref(obj, EDJE_OBJ_CLASS);
eo_do_super(obj, MY_CLASS, eo_constructor());
}
-static void
-_edje_edit_destructor(Eo *obj, void *class_data, va_list *list EINA_UNUSED)
+EOLIAN static void
+_edje_edit_eo_base_destructor(Eo *obj, Edje_Edit *class_data EINA_UNUSED)
{
eo_do_super(obj, MY_CLASS, eo_destructor());
eo_data_unref(obj, class_data);
}
+
/* End of Edje_Edit smart stuff */
static Edje_Part_Description_Common *
@@ -8347,30 +8345,4 @@ edje_edit_print_internal_status(Evas_Object *obj)
*/
}
-static void
-_edje_edit_class_constructor(Eo_Class *klass)
-{
- const Eo_Op_Func_Description func_desc[] = {
- EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _edje_edit_constructor),
- EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_DESTRUCTOR), _edje_edit_destructor),
- EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_DEL), _edje_edit_smart_del),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_FILE_SET), _edje_edit_smart_file_set),
- EO_OP_FUNC_SENTINEL
- };
-
- eo_class_funcs_set(klass, func_desc);
-}
-
-static const Eo_Class_Description edje_edit_class_desc = {
- EO_VERSION,
- "Edje_Edit",
- EO_CLASS_TYPE_REGULAR,
- EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0),
- NULL,
- sizeof(Edje_Edit),
- _edje_edit_class_constructor,
- NULL
-};
-
-EO_DEFINE_CLASS(edje_edit_class_get, &edje_edit_class_desc, EDJE_OBJ_CLASS, NULL);
-
+#include "edje_edit.eo.c"
\ No newline at end of file
diff --git a/src/lib/edje/edje_edit.eo b/src/lib/edje/edje_edit.eo
new file mode 100644
index 0000000000..7dece71cec
--- /dev/null
+++ b/src/lib/edje/edje_edit.eo
@@ -0,0 +1,10 @@
+class Edje_Edit (Edje)
+{
+ data: Edje_Edit;
+ implements {
+ Eo_Base::constructor;
+ Eo_Base::destructor;
+ Evas_Smart::del;
+ Edje::file::set;
+ }
+}
\ No newline at end of file
diff --git a/src/lib/edje/edje_embryo.c b/src/lib/edje/edje_embryo.c
index cc5eedacdd..15e9710994 100644
--- a/src/lib/edje/edje_embryo.c
+++ b/src/lib/edje/edje_embryo.c
@@ -1493,7 +1493,7 @@ _edje_embryo_fn_send_message(Embryo_Program *ep, Embryo_Cell *params)
switch (type)
{
case EDJE_MESSAGE_NONE:
- _edje_message_send(ed, EDJE_QUEUE_APP, type, id, NULL);
+ _edje_util_message_send(ed, EDJE_QUEUE_APP, type, id, NULL);
break;
case EDJE_MESSAGE_SIGNAL:
break;
@@ -1514,7 +1514,7 @@ _edje_embryo_fn_send_message(Embryo_Program *ep, Embryo_Cell *params)
embryo_data_string_get(ep, cptr, s);
emsg = alloca(sizeof(Edje_Message_String));
emsg->str = s;
- _edje_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
+ _edje_util_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
}
}
break;
@@ -1526,7 +1526,7 @@ _edje_embryo_fn_send_message(Embryo_Program *ep, Embryo_Cell *params)
ptr = embryo_data_address_get(ep, params[3]);
if (ptr) emsg->val = (int)*ptr;
else emsg->val = 0;
- _edje_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
+ _edje_util_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
}
break;
case EDJE_MESSAGE_FLOAT:
@@ -1543,7 +1543,7 @@ _edje_embryo_fn_send_message(Embryo_Program *ep, Embryo_Cell *params)
}
else
emsg->val = 0.0;
- _edje_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
+ _edje_util_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
}
break;
case EDJE_MESSAGE_STRING_SET:
@@ -1570,7 +1570,7 @@ _edje_embryo_fn_send_message(Embryo_Program *ep, Embryo_Cell *params)
emsg->str[i - 3] = s;
}
}
- _edje_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
+ _edje_util_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
}
break;
case EDJE_MESSAGE_INT_SET:
@@ -1586,7 +1586,7 @@ _edje_embryo_fn_send_message(Embryo_Program *ep, Embryo_Cell *params)
if (ptr) emsg->val[i - 3] = (int)*ptr;
else emsg->val[i - 3] = 0;
}
- _edje_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
+ _edje_util_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
}
break;
case EDJE_MESSAGE_FLOAT_SET:
@@ -1609,7 +1609,7 @@ _edje_embryo_fn_send_message(Embryo_Program *ep, Embryo_Cell *params)
else
emsg->val[i - 3] = 0.0;
}
- _edje_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
+ _edje_util_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
}
break;
case EDJE_MESSAGE_STRING_INT:
@@ -1632,7 +1632,7 @@ _edje_embryo_fn_send_message(Embryo_Program *ep, Embryo_Cell *params)
ptr = embryo_data_address_get(ep, params[4]);
if (ptr) emsg->val = (int)*ptr;
else emsg->val = 0;
- _edje_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
+ _edje_util_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
}
}
break;
@@ -1662,7 +1662,7 @@ _edje_embryo_fn_send_message(Embryo_Program *ep, Embryo_Cell *params)
}
else
emsg->val = 0.0;
- _edje_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
+ _edje_util_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
}
}
break;
@@ -1691,7 +1691,7 @@ _edje_embryo_fn_send_message(Embryo_Program *ep, Embryo_Cell *params)
if (ptr) emsg->val[i - 4] = (int)*ptr;
else emsg->val[i - 4] = 0;
}
- _edje_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
+ _edje_util_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
}
}
break;
@@ -1727,7 +1727,7 @@ _edje_embryo_fn_send_message(Embryo_Program *ep, Embryo_Cell *params)
else
emsg->val[i - 4] = 0.0;
}
- _edje_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
+ _edje_util_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
}
}
break;
diff --git a/src/lib/edje/edje_external.c b/src/lib/edje/edje_external.c
index 28c0cabb06..94a6bb086e 100644
--- a/src/lib/edje/edje_external.c
+++ b/src/lib/edje/edje_external.c
@@ -23,25 +23,12 @@ edje_external_param_type_str(Edje_External_Param_Type type)
}
}
-EAPI Evas_Object *
-edje_object_part_external_object_get(const Evas_Object *obj, const char *part)
+EOLIAN Evas_Object*
+_edje_part_external_object_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part)
{
- if (!obj) return NULL;
- Evas_Object *ret = NULL;
- eo_do((Eo *)obj, edje_obj_part_external_object_get(part, &ret));
- return ret;
-}
-
-void
-_part_external_object_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Evas_Object **ret = va_arg(*list, Evas_Object **);
- Edje *ed = (Edje *)_pd;
Edje_Real_Part *rp;
- *ret = NULL;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return NULL;
/* Need to recalc before providing the object. */
_edje_recalc_do(ed);
@@ -50,179 +37,117 @@ _part_external_object_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
if (!rp)
{
ERR("no part '%s'", part);
- return;
+ return NULL;
}
if (rp->part->type != EDJE_PART_TYPE_EXTERNAL)
{
ERR("cannot get external object of a part '%s' that is not EXTERNAL",
rp->part->name);
- return;
+ return NULL;
}
if ((rp->type != EDJE_RP_TYPE_SWALLOW) ||
- (!rp->typedata.swallow)) return;
- *ret = rp->typedata.swallow->swallowed_object;
+ (!rp->typedata.swallow)) return NULL;
+
+ return rp->typedata.swallow->swallowed_object;
}
-EAPI Eina_Bool
-edje_object_part_external_param_set(Evas_Object *obj, const char *part, const Edje_External_Param *param)
+EOLIAN Eina_Bool
+_edje_part_external_param_set(Eo *obj, Edje *ed, const char *part, const Edje_External_Param *param)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do(obj, edje_obj_part_external_param_set(part, param, &ret));
- return ret;
-}
-
-void
-_part_external_param_set(Eo *obj, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- const Edje_External_Param *param = va_arg(*list, const Edje_External_Param *);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- if (ret) *ret = EINA_FALSE;
-
- Edje *ed = _pd;
Edje_Real_Part *rp;
- if ((!param) || (!param->name)) return;
+ if ((!param) || (!param->name)) return EINA_FALSE;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return EINA_FALSE;
rp = _edje_real_part_recursive_get(&ed, (char *)part);
if (!rp)
{
ERR("no part '%s'", part);
- return;
+ return EINA_FALSE;
}
if (_edje_external_param_set(obj, rp, param))
- if (ret) *ret = EINA_TRUE;
+ return EINA_TRUE;
+ return EINA_FALSE;
}
-EAPI Eina_Bool
-edje_object_part_external_param_get(const Evas_Object *obj, const char *part, Edje_External_Param *param)
+EOLIAN Eina_Bool
+_edje_part_external_param_get(Eo *obj, Edje *ed, const char *part, Edje_External_Param *param)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do((Eo *)obj, edje_obj_part_external_param_get(part, param, &ret));
- return ret;
-}
-
-void
-_part_external_param_get(Eo *obj, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Edje_External_Param *param = va_arg(*list, Edje_External_Param *);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- *ret = EINA_FALSE;
-
- Edje *ed = _pd;
Edje_Real_Part *rp;
- if ((!param) || (!param->name)) return;
+ if ((!param) || (!param->name)) return EINA_FALSE;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return EINA_FALSE;
rp = _edje_real_part_recursive_get(&ed, (char *)part);
if (!rp)
{
ERR("no part '%s'", part);
- return;
+ return EINA_FALSE;
}
- *ret = _edje_external_param_get(obj, rp, param);
+ return _edje_external_param_get(obj, rp, param);
}
-
-
-EAPI Evas_Object *
-edje_object_part_external_content_get(const Evas_Object *obj, const char *part, const char *content)
+EOLIAN Evas_Object*
+_edje_part_external_content_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part, const char *content)
{
- if (!obj) return NULL;
- Evas_Object *ret = NULL;
- eo_do((Eo *)obj, edje_obj_part_external_content_get(part, content, &ret));
- return ret;
-}
-
-void
-_part_external_content_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- const char *content = va_arg(*list, const char *);
- Evas_Object **ret = va_arg(*list, Evas_Object **);
- *ret = NULL;
-
- Edje *ed = _pd;
Edje_Real_Part *rp;
- if (!content) return;
+ if (!content) return NULL;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return NULL;
rp = _edje_real_part_recursive_get(&ed, (char *)part);
if (!rp)
{
ERR("no part '%s'", part);
- return;
+ return NULL;
}
if ((rp->type != EDJE_RP_TYPE_SWALLOW) ||
- (!rp->typedata.swallow)) return;
- *ret = _edje_external_content_get(rp->typedata.swallow->swallowed_object, content);
+ (!rp->typedata.swallow)) return NULL;
+
+ return _edje_external_content_get(rp->typedata.swallow->swallowed_object, content);
}
-EAPI Edje_External_Param_Type
-edje_object_part_external_param_type_get(const Evas_Object *obj, const char *part, const char *param)
+EOLIAN Edje_External_Param_Type
+_edje_part_external_param_type_get(Eo *obj, Edje *ed, const char *part, const char *param)
{
- if (!obj) return EDJE_EXTERNAL_PARAM_TYPE_MAX;
- Edje_External_Param_Type ret = EDJE_EXTERNAL_PARAM_TYPE_MAX;
- eo_do((Eo *)obj, edje_obj_part_external_param_type_get(part, param, &ret));
- return ret;
-}
-
-void
-_part_external_param_type_get(Eo *obj, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- const char *param = va_arg(*list, const char *);
- Edje_External_Param_Type *ret = va_arg(*list, Edje_External_Param_Type *);
- *ret = EDJE_EXTERNAL_PARAM_TYPE_MAX;
-
- Edje *ed = _pd;
Edje_Real_Part *rp;
Edje_External_Type *type;
Edje_External_Param_Info *info;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return EDJE_EXTERNAL_PARAM_TYPE_MAX;
rp = _edje_real_part_recursive_get(&ed, (char *)part);
if (!rp)
{
ERR("no part '%s'", part);
- return;
+ return EDJE_EXTERNAL_PARAM_TYPE_MAX;
}
if ((rp->type != EDJE_RP_TYPE_SWALLOW) ||
- (!rp->typedata.swallow)) return;
+ (!rp->typedata.swallow)) return EDJE_EXTERNAL_PARAM_TYPE_MAX;
type = evas_object_data_get(rp->typedata.swallow->swallowed_object, "Edje_External_Type");
if (!type)
{
ERR("no external type for object %p", obj);
- return;
+ return EDJE_EXTERNAL_PARAM_TYPE_MAX;
}
if (!type->parameters_info)
{
ERR("no parameters information for external type '%s'",
type->module_name);
- return;
+ return EDJE_EXTERNAL_PARAM_TYPE_MAX;
}
for (info = type->parameters_info; info->name; info++)
- if (strcmp(info->name, param) == 0)
- {
- *ret = info->type;
- return;
- }
+ if (strcmp(info->name, param) == 0) return info->type;;
ERR("no parameter '%s' external type '%s'", param, type->module_name);
-}
+ return EDJE_EXTERNAL_PARAM_TYPE_MAX;
+}
EAPI Eina_Bool
edje_external_type_register(const char *type_name, const Edje_External_Type *type_info)
diff --git a/src/lib/edje/edje_load.c b/src/lib/edje/edje_load.c
index 9dbeec3cc2..51a21a9b68 100644
--- a/src/lib/edje/edje_load.c
+++ b/src/lib/edje/edje_load.c
@@ -72,58 +72,17 @@ static int _sort_defined_boxes(const void *a, const void *b);
/************************** API Routines **************************/
-EAPI Eina_Bool
-edje_object_file_set(Evas_Object *obj, const char *file, const char *group)
+EOLIAN void
+_edje_file_get(Eo *obj EINA_UNUSED, Edje *ed, const char **file, const char **group)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
-
- eo_do(obj, edje_obj_file_set(file, group, &ret));
- return ret;
-}
-
-EAPI Eina_Bool
-edje_object_mmap_set(Evas_Object *obj, const Eina_File *file, const char *group)
-{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
-
- eo_do(obj, edje_obj_mmap_set(file, group, &ret));
- return ret;
-}
-
-EAPI void
-edje_object_file_get(const Evas_Object *obj, const char **file, const char **group)
-{
- if (!obj) return;
- eo_do((Eo *)obj, edje_obj_file_get(file, group));
-}
-
-void
-_file_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char **file = va_arg(*list, const char **);
- const char **group = va_arg(*list, const char **);
- const Edje *ed = _pd;
if (file) *file = ed->path;
if (group) *group = ed->group;
}
-EAPI Edje_Load_Error
-edje_object_load_error_get(const Evas_Object *obj)
+EOLIAN Edje_Load_Error
+_edje_load_error_get(Eo *obj EINA_UNUSED, Edje *ed)
{
- if (!obj) return EDJE_LOAD_ERROR_NONE;
- Edje_Load_Error ret = EDJE_LOAD_ERROR_NONE;
- eo_do((Eo *)obj, edje_obj_load_error_get(&ret));
- return ret;
-}
-
-void
-_load_error_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- Edje_Load_Error *ret = va_arg(*list, Edje_Load_Error *);
- const Edje *ed = _pd;
- *ret = ed->load_error;
+ return ed->load_error;
}
EAPI const char *
@@ -798,7 +757,7 @@ _edje_object_file_set_internal(Evas_Object *obj, const Eina_File *file, const ch
_edje_ref(ed);
_edje_block(ed);
- _edje_freeze(ed);
+ _edje_util_freeze(ed);
// if (ed->collection->script) _edje_embryo_script_init(ed);
_edje_var_init(ed);
for (i = 0; i < ed->table_parts_size; i++)
@@ -1097,7 +1056,7 @@ _edje_object_file_set_internal(Evas_Object *obj, const Eina_File *file, const ch
edje_object_signal_emit(obj, "edje,state,ltr", "edje");
_edje_recalc(ed);
- _edje_thaw(ed);
+ _edje_util_thaw(ed);
_edje_unblock(ed);
_edje_unref(ed);
ed->load_error = EDJE_LOAD_ERROR_NONE;
@@ -1153,7 +1112,7 @@ on_error:
eina_list_free(externals);
eina_list_free(sources);
eina_array_flush(&parts);
- _edje_thaw(ed);
+ _edje_util_thaw(ed);
_edje_unblock(ed);
_edje_unref(ed);
_edje_file_del(ed);
@@ -1291,9 +1250,9 @@ _edje_file_del(Edje *ed)
if (tev) evas_event_freeze(tev);
if (ed->freeze_calc)
{
- _edje_freeze_calc_list = eina_list_remove(_edje_freeze_calc_list, ed);
+ _edje_util_freeze_calc_list = eina_list_remove(_edje_util_freeze_calc_list, ed);
ed->freeze_calc = EINA_FALSE;
- _edje_freeze_calc_count--;
+ _edje_util_freeze_calc_count--;
}
_edje_entry_shutdown(ed);
_edje_message_del(ed);
@@ -2004,6 +1963,6 @@ _cb_signal_repeat(void *data, Evas_Object *obj, const char *sig, const char *sou
emsg.src = alias ? alias : new_src;
emsg.data = NULL;
if (ed_parent)
- _edje_message_send(ed_parent, EDJE_QUEUE_SCRIPT,
+ _edje_util_message_send(ed_parent, EDJE_QUEUE_SCRIPT,
EDJE_MESSAGE_SIGNAL, 0, &emsg);
-}
+}
\ No newline at end of file
diff --git a/src/lib/edje/edje_lua2.c b/src/lib/edje/edje_lua2.c
index 1418bba40f..0cc7f0483a 100644
--- a/src/lib/edje/edje_lua2.c
+++ b/src/lib/edje/edje_lua2.c
@@ -976,7 +976,7 @@ _elua_messagesend(lua_State *L) // Stack usage [-2, +2, ev] plus [-2, +2] for e
if (!type) return 0;
if (!strcmp(type, "none"))
{
- _edje_message_send(ed, EDJE_QUEUE_APP, EDJE_MESSAGE_NONE, id, NULL);
+ _edje_util_message_send(ed, EDJE_QUEUE_APP, EDJE_MESSAGE_NONE, id, NULL);
}
else if (!strcmp(type, "sig"))
{
@@ -990,7 +990,7 @@ _elua_messagesend(lua_State *L) // Stack usage [-2, +2, ev] plus [-2, +2] for e
const char *str = luaL_checkstring(L, 3); // Stack usage [-0, +0, v]
emsg = alloca(sizeof(Edje_Message_String));
emsg->str = (char *)str;
- _edje_message_send(ed, EDJE_QUEUE_APP, EDJE_MESSAGE_STRING, id, emsg);
+ _edje_util_message_send(ed, EDJE_QUEUE_APP, EDJE_MESSAGE_STRING, id, emsg);
}
else if (!strcmp(type, "int"))
{
@@ -998,7 +998,7 @@ _elua_messagesend(lua_State *L) // Stack usage [-2, +2, ev] plus [-2, +2] for e
int val = luaL_checkinteger(L, 3); // Stack usage [-0, +0, v]
emsg = alloca(sizeof(Edje_Message_Int));
emsg->val = val;
- _edje_message_send(ed, EDJE_QUEUE_APP, EDJE_MESSAGE_INT, id, emsg);
+ _edje_util_message_send(ed, EDJE_QUEUE_APP, EDJE_MESSAGE_INT, id, emsg);
}
else if (!strcmp(type, "float"))
{
@@ -1006,7 +1006,7 @@ _elua_messagesend(lua_State *L) // Stack usage [-2, +2, ev] plus [-2, +2] for e
float val = luaL_checknumber(L, 3); // Stack usage [-0, +0, v]
emsg = alloca(sizeof(Edje_Message_Float));
emsg->val = val;
- _edje_message_send(ed, EDJE_QUEUE_APP, EDJE_MESSAGE_FLOAT, id, emsg);
+ _edje_util_message_send(ed, EDJE_QUEUE_APP, EDJE_MESSAGE_FLOAT, id, emsg);
}
else if (!strcmp(type, "strset"))
{
@@ -1029,7 +1029,7 @@ _elua_messagesend(lua_State *L) // Stack usage [-2, +2, ev] plus [-2, +2] for e
lua_pop(L, 1); // Stack usage [-n, +0, -]
emsg->str[i - 1] = (char *)str;
}
- _edje_message_send(ed, EDJE_QUEUE_APP, EDJE_MESSAGE_STRING_SET, id, emsg);
+ _edje_util_message_send(ed, EDJE_QUEUE_APP, EDJE_MESSAGE_STRING_SET, id, emsg);
}
else if (!strcmp(type, "intset"))
{
@@ -1050,7 +1050,7 @@ _elua_messagesend(lua_State *L) // Stack usage [-2, +2, ev] plus [-2, +2] for e
emsg->val[i - 1] = lua_tointeger(L, -1); // Stack usage [-0, +0, -]
lua_pop(L, 1); // Stack usage [-n, +0, -]
}
- _edje_message_send(ed, EDJE_QUEUE_APP, EDJE_MESSAGE_INT_SET, id, emsg);
+ _edje_util_message_send(ed, EDJE_QUEUE_APP, EDJE_MESSAGE_INT_SET, id, emsg);
}
else if (!strcmp(type, "floatset"))
{
@@ -1071,7 +1071,7 @@ _elua_messagesend(lua_State *L) // Stack usage [-2, +2, ev] plus [-2, +2] for e
emsg->val[i - 1] = lua_tonumber(L, -1); // Stack usage [-0, +0, -]
lua_pop(L, 1); // Stack usage [-n, +0, -]
}
- _edje_message_send(ed, EDJE_QUEUE_APP, EDJE_MESSAGE_FLOAT_SET, id, emsg);
+ _edje_util_message_send(ed, EDJE_QUEUE_APP, EDJE_MESSAGE_FLOAT_SET, id, emsg);
}
else if (!strcmp(type, "strint"))
{
@@ -1080,7 +1080,7 @@ _elua_messagesend(lua_State *L) // Stack usage [-2, +2, ev] plus [-2, +2] for e
emsg = alloca(sizeof(Edje_Message_String_Int));
emsg->str = (char *)str;
emsg->val = luaL_checkinteger(L, 4); // Stack usage [-0, +0, v]
- _edje_message_send(ed, EDJE_QUEUE_APP, EDJE_MESSAGE_STRING_INT, id, emsg);
+ _edje_util_message_send(ed, EDJE_QUEUE_APP, EDJE_MESSAGE_STRING_INT, id, emsg);
}
else if (!strcmp(type, "strfloat"))
{
@@ -1089,7 +1089,7 @@ _elua_messagesend(lua_State *L) // Stack usage [-2, +2, ev] plus [-2, +2] for e
emsg = alloca(sizeof(Edje_Message_String_Float));
emsg->str = (char *)str;
emsg->val = luaL_checknumber(L, 4); // Stack usage [-0, +0, v]
- _edje_message_send(ed, EDJE_QUEUE_APP, EDJE_MESSAGE_STRING_FLOAT, id, emsg);
+ _edje_util_message_send(ed, EDJE_QUEUE_APP, EDJE_MESSAGE_STRING_FLOAT, id, emsg);
}
else if (!strcmp(type, "strintset"))
{
@@ -1113,7 +1113,7 @@ _elua_messagesend(lua_State *L) // Stack usage [-2, +2, ev] plus [-2, +2] for e
emsg->val[i - 1] = lua_tointeger(L, -1); // Stack usage [-0, +0, -]
lua_pop(L, 1); // Stack usage [-n, +0, -]
}
- _edje_message_send(ed, EDJE_QUEUE_APP, EDJE_MESSAGE_STRING_INT_SET, id, emsg);
+ _edje_util_message_send(ed, EDJE_QUEUE_APP, EDJE_MESSAGE_STRING_INT_SET, id, emsg);
}
else if (!strcmp(type, "strfloatset"))
{
@@ -1137,7 +1137,7 @@ _elua_messagesend(lua_State *L) // Stack usage [-2, +2, ev] plus [-2, +2] for e
emsg->val[i - 1] = lua_tonumber(L, -1); // Stack usage [-0, +0, -]
lua_pop(L, 1); // Stack usage [-n, +0, -]
}
- _edje_message_send(ed, EDJE_QUEUE_APP, EDJE_MESSAGE_STRING_FLOAT_SET, id, emsg);
+ _edje_util_message_send(ed, EDJE_QUEUE_APP, EDJE_MESSAGE_STRING_FLOAT_SET, id, emsg);
}
return 0;
}
diff --git a/src/lib/edje/edje_message_queue.c b/src/lib/edje/edje_message_queue.c
index ce10d24e1b..b90f12df73 100644
--- a/src/lib/edje/edje_message_queue.c
+++ b/src/lib/edje/edje_message_queue.c
@@ -31,58 +31,28 @@ _edje_object_message_popornot_send(Evas_Object *obj, Edje_Message_Type type, int
}
}
-EAPI void
-edje_object_message_send(Evas_Object *obj, Edje_Message_Type type, int id, void *msg)
+EOLIAN void
+_edje_message_send(Eo *obj, Edje *_pd EINA_UNUSED, Edje_Message_Type type, int id, void *msg)
{
- if (!obj) return;
- eo_do(obj, edje_obj_message_send(type, id, msg));
-}
-
-void
-_message_send(Eo *obj, void *_pd EINA_UNUSED, va_list *list)
-{
- Edje_Message_Type type = va_arg(*list, Edje_Message_Type);
- int id = va_arg(*list, int);
- void *msg = va_arg(*list, void *);
_edje_object_message_popornot_send(obj, type, id, msg, EINA_FALSE);
}
-
-EAPI void
-edje_object_message_handler_set(Evas_Object *obj, Edje_Message_Handler_Cb func, void *data)
+EOLIAN void
+_edje_message_handler_set(Eo *obj EINA_UNUSED, Edje *ed, Edje_Message_Handler_Cb func, void *data)
{
- if (!obj) return;
- eo_do(obj, edje_obj_message_handler_set(func, data));
-}
-
-void
-_message_handler_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- Edje_Message_Handler_Cb func = va_arg(*list, Edje_Message_Handler_Cb);
- void *data = va_arg(*list, void *);
- Edje *ed = _pd;
_edje_message_cb_set(ed, func, data);
}
-EAPI void
-edje_object_message_signal_process(Evas_Object *obj)
-{
- if (!obj) return;
- eo_do(obj, edje_obj_message_signal_process());
-}
-
-void
-_message_signal_process(Eo *obj EINA_UNUSED, void *_pd, va_list *list EINA_UNUSED)
+EOLIAN void
+_edje_message_signal_process(Eo *obj EINA_UNUSED, Edje *ed)
{
Eina_List *l, *ln, *tmpq = NULL;
- Edje *ed;
Edje *lookup_ed;
Eina_List *lg;
Edje_Message *em;
Eina_List *groups = NULL;
int gotos = 0;
- ed = _pd;
if (!ed) return;
groups = ed->groups;
@@ -548,7 +518,7 @@ _edje_message_propornot_send(Edje *ed, Edje_Queue queue, Edje_Message_Type type,
}
void
-_edje_message_send(Edje *ed, Edje_Queue queue, Edje_Message_Type type, int id, void *emsg)
+_edje_util_message_send(Edje *ed, Edje_Queue queue, Edje_Message_Type type, int id, void *emsg)
{
_edje_message_propornot_send(ed, queue, type, id, emsg, EINA_FALSE);
}
@@ -887,4 +857,4 @@ _edje_message_del(Edje *ed)
}
if (ed->message.num <= 0) return;
}
-}
+}
\ No newline at end of file
diff --git a/src/lib/edje/edje_private.h b/src/lib/edje/edje_private.h
index c5b0ef22e7..4dc03af6e7 100644
--- a/src/lib/edje/edje_private.h
+++ b/src/lib/edje/edje_private.h
@@ -1941,9 +1941,9 @@ extern Eina_List *_edje_edjes;
extern char *_edje_fontset_append;
extern FLOAT_T _edje_scale;
-extern int _edje_freeze_val;
-extern int _edje_freeze_calc_count;
-extern Eina_List *_edje_freeze_calc_list;
+extern int _edje_util_freeze_val;
+extern int _edje_util_freeze_calc_count;
+extern Eina_List *_edje_util_freeze_calc_list;
extern Eina_Bool _edje_password_show_last;
extern FLOAT_T _edje_password_show_last_timeout;
@@ -2078,8 +2078,8 @@ void _edje_text_class_members_free(void);
void _edje_text_class_hash_free(void);
Edje *_edje_fetch(const Evas_Object *obj) EINA_PURE;
-int _edje_freeze(Edje *ed);
-int _edje_thaw(Edje *ed);
+int _edje_util_freeze(Edje *ed);
+int _edje_util_thaw(Edje *ed);
int _edje_block(Edje *ed);
int _edje_unblock(Edje *ed);
int _edje_block_break(Edje *ed);
@@ -2175,7 +2175,7 @@ void _edje_message_cb_set (Edje *ed, void (*func) (void *data,
Edje_Message *_edje_message_new (Edje *ed, Edje_Queue queue, Edje_Message_Type type, int id);
void _edje_message_free (Edje_Message *em);
void _edje_message_propornot_send (Edje *ed, Edje_Queue queue, Edje_Message_Type type, int id, void *emsg, Eina_Bool prop);
-void _edje_message_send (Edje *ed, Edje_Queue queue, Edje_Message_Type type, int id, void *emsg);
+void _edje_util_message_send (Edje *ed, Edje_Queue queue, Edje_Message_Type type, int id, void *emsg);
void _edje_message_parameters_push (Edje_Message *em);
void _edje_message_process (Edje_Message *em);
void _edje_message_queue_process (void);
diff --git a/src/lib/edje/edje_program.c b/src/lib/edje/edje_program.c
index d2fab353cf..1a2126c5ad 100644
--- a/src/lib/edje/edje_program.c
+++ b/src/lib/edje/edje_program.c
@@ -51,25 +51,11 @@ edje_object_propagate_callback_add(Evas_Object *obj, void (*func) (void *data, E
eina_stringshare_del(src);
}
-EAPI void
-edje_object_signal_callback_add(Evas_Object *obj, const char *emission, const char *source, void (*func) (void *data, Evas_Object *o, const char *emission, const char *source), void *data)
+EOLIAN void
+_edje_signal_callback_add(Eo *obj EINA_UNUSED, Edje *ed, const char *emission, const char *source, Edje_Signal_Cb func, void *data)
{
- if (!obj) return;
- eo_do(obj, edje_obj_signal_callback_add(emission, source, (Edje_Signal_Cb)func, data));
-}
-
-void
-_signal_callback_add(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *emission = va_arg(*list, const char *);
- const char *source = va_arg(*list, const char *);
- Edje_Signal_Cb func = va_arg(*list, Edje_Signal_Cb);
- void *data = va_arg(*list, void *);
-
- Edje *ed = _pd;
-
if ((!emission) || (!source) || (!func)) return;
- ed = _pd;
+
if (!ed) return;
if (ed->delete_me) return;
@@ -96,21 +82,12 @@ edje_object_signal_callback_del(Evas_Object *obj, const char *emission, const ch
return ret;
}
-void
-_signal_callback_del(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+EOLIAN void*
+_edje_signal_callback_del(Eo *obj EINA_UNUSED, Edje *ed, const char *emission, const char *source, Edje_Signal_Cb func, void *data)
{
- const char *emission = va_arg(*list, const char *);
- const char *source = va_arg(*list, const char *);
- Edje_Signal_Cb func = va_arg(*list, Edje_Signal_Cb);
- void *data = va_arg(*list, void *);
- void **ret = va_arg(*list, void **);
- Edje *ed = _pd;
-
- if (ret) *ret = NULL;
-
- if ((!emission) || (!source) || (!func)) return;
- if (!ed) return;
- if (ed->delete_me) return;
+ if ((!emission) || (!source) || (!func)) return NULL;
+ if (!ed) return NULL;
+ if (ed->delete_me) return NULL;
emission = eina_stringshare_add(emission);
source = eina_stringshare_add(source);
@@ -121,6 +98,8 @@ _signal_callback_del(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
eina_stringshare_del(emission);
eina_stringshare_del(source);
+
+ return NULL;
}
EAPI void *
@@ -132,42 +111,19 @@ edje_object_signal_callback_del_full(Evas_Object *obj, const char *emission, con
return ret;
}
-EAPI void
-edje_object_signal_emit(Evas_Object *obj, const char *emission, const char *source)
+EOLIAN void
+_edje_signal_emit(Eo *obj EINA_UNUSED, Edje *ed, const char *emission, const char *source)
{
- if (!obj) return;
- if (!eo_isa(obj, EDJE_OBJ_CLASS)) return;
- eo_do(obj, edje_obj_signal_emit(emission, source));
-}
-
-void
-_signal_emit(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *emission = va_arg(*list, const char *);
- const char *source = va_arg(*list, const char *);
- Edje *ed;
-
if ((!emission) || (!source)) return;
- ed = _pd;
if (!ed) return;
if (ed->delete_me) return;
_edje_emit(ed, (char *)emission, (char *)source);
}
/* FIXDOC: Verify/Expand */
-EAPI void
-edje_object_play_set(Evas_Object *obj, Eina_Bool play)
+EOLIAN void
+_edje_play_set(Eo *obj EINA_UNUSED, Edje *ed, Eina_Bool play)
{
- if (!obj) return;
- eo_do(obj, edje_obj_play_set(play));
-}
-
-void
-_play_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- Eina_Bool play = va_arg(*list, int);
-
- Edje *ed = _pd;
double t;
Eina_List *l;
Edje_Running_Program *runp;
@@ -202,41 +158,20 @@ _play_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
}
}
-EAPI Eina_Bool
-edje_object_play_get(const Evas_Object *obj)
+EOLIAN Eina_Bool
+_edje_play_get(Eo *obj EINA_UNUSED, Edje *ed)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do((Eo *)obj, edje_obj_play_get(&ret));
- return ret;
-}
+ if (!ed) return EINA_FALSE;
+ if (ed->delete_me) return EINA_FALSE;
+ if (ed->paused) return EINA_FALSE;
-void
-_play_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- const Edje *ed = _pd;
- *ret = EINA_FALSE;
-
- if (!ed) return;
- if (ed->delete_me) return;
- if (ed->paused) return;
- *ret = EINA_TRUE;
+ return EINA_TRUE;
}
/* FIXDOC: Verify/Expand */
-EAPI void
-edje_object_animation_set(Evas_Object *obj, Eina_Bool on)
+EOLIAN void
+_edje_animation_set(Eo *obj, Edje *ed, Eina_Bool on)
{
- if (!obj) return;
- eo_do(obj, edje_obj_animation_set(on));
-}
-
-void
-_animation_set(Eo *obj, void *_pd, va_list *list)
-{
- Eina_Bool on = va_arg(*list, int);
- Edje *ed = _pd;
Eina_List *l;
unsigned int i;
@@ -244,7 +179,7 @@ _animation_set(Eo *obj, void *_pd, va_list *list)
if (ed->delete_me) return;
_edje_block(ed);
ed->no_anim = !on;
- _edje_freeze(ed);
+ _edje_util_freeze(ed);
if (!on)
{
Eina_List *newl = NULL;
@@ -288,31 +223,18 @@ break_prog:
edje_object_animation_set(rp->typedata.swallow->swallowed_object, on);
}
- _edje_thaw(ed);
+ _edje_util_thaw(ed);
_edje_unblock(ed);
}
-
-EAPI Eina_Bool
-edje_object_animation_get(const Evas_Object *obj)
+EOLIAN Eina_Bool
+_edje_animation_get(Eo *obj EINA_UNUSED, Edje *ed)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do((Eo *)obj, edje_obj_animation_get(&ret));
- return ret;
-}
+ if (!ed) return EINA_FALSE;
+ if (ed->delete_me) return EINA_FALSE;
+ if (ed->no_anim) return EINA_FALSE;
-void
-_animation_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- const Edje *ed = _pd;
- *ret = EINA_FALSE;
-
- if (!ed) return;
- if (ed->delete_me) return;
- if (ed->no_anim) return;
- *ret = EINA_TRUE;
+ return EINA_TRUE;
}
/* Private Routines */
@@ -330,7 +252,7 @@ _edje_program_run_iterate(Edje_Running_Program *runp, double tim)
if (ed->delete_me) return EINA_FALSE;
_edje_block(ed);
_edje_ref(ed);
- _edje_freeze(ed);
+ _edje_util_freeze(ed);
t = FROM_DOUBLE(tim - runp->start_time);
total = runp->program->tween.time;
t = DIV(t, total);
@@ -404,7 +326,7 @@ _edje_program_run_iterate(Edje_Running_Program *runp, double tim)
}
}
}
- _edje_thaw(ed);
+ _edje_util_thaw(ed);
_edje_unref(ed);
if (!ed->walking_actions) free(runp);
_edje_unblock(ed);
@@ -412,7 +334,7 @@ _edje_program_run_iterate(Edje_Running_Program *runp, double tim)
}
break_prog:
_edje_recalc(ed);
- _edje_thaw(ed);
+ _edje_util_thaw(ed);
_edje_unref(ed);
_edje_unblock(ed);
return EINA_TRUE;
@@ -428,7 +350,7 @@ _edje_program_end(Edje *ed, Edje_Running_Program *runp)
if (ed->delete_me) return;
_edje_ref(ed);
- _edje_freeze(ed);
+ _edje_util_freeze(ed);
EINA_LIST_FOREACH(runp->program->targets, l, pt)
{
Edje_Real_Part *rp;
@@ -468,7 +390,7 @@ _edje_program_end(Edje *ed, Edje_Running_Program *runp)
}
}
// _edje_emit(ed, "program,stop", pname);
- _edje_thaw(ed);
+ _edje_util_thaw(ed);
_edje_unref(ed);
if (free_runp) free(runp);
}
@@ -540,7 +462,7 @@ _edje_program_run(Edje *ed, Edje_Program *pr, Eina_Bool force, const char *ssig,
recursions++;
_edje_block(ed);
_edje_ref(ed);
- _edje_freeze(ed);
+ _edje_util_freeze(ed);
switch (pr->action)
{
case EDJE_ACTION_TYPE_STATE_SET:
@@ -1003,7 +925,7 @@ low_mem_current:
}
}
break_prog:
- _edje_thaw(ed);
+ _edje_util_thaw(ed);
_edje_unref(ed);
recursions--;
if (recursions == 0) recursion_limit = 0;
@@ -1176,9 +1098,9 @@ end:
if (broadcast)
edje_object_message_send(ed->obj, EDJE_MESSAGE_SIGNAL, 0, &emsg);
else
- _edje_message_send(ed, EDJE_QUEUE_SCRIPT, EDJE_MESSAGE_SIGNAL, 0, &emsg);
+ _edje_util_message_send(ed, EDJE_QUEUE_SCRIPT, EDJE_MESSAGE_SIGNAL, 0, &emsg);
/* old send code - use api now
- _edje_message_send(ed, EDJE_QUEUE_SCRIPT, EDJE_MESSAGE_SIGNAL, 0, &emsg);
+ _edje_util_message_send(ed, EDJE_QUEUE_SCRIPT, EDJE_MESSAGE_SIGNAL, 0, &emsg);
EINA_LIST_FOREACH(ed->subobjs, l, obj)
{
Edje *ed2;
@@ -1186,7 +1108,7 @@ end:
ed2 = _edje_fetch(obj);
if (!ed2) continue;
if (ed2->delete_me) continue;
- _edje_message_send(ed2, EDJE_QUEUE_SCRIPT, EDJE_MESSAGE_SIGNAL, 0, &emsg);
+ _edje_util_message_send(ed2, EDJE_QUEUE_SCRIPT, EDJE_MESSAGE_SIGNAL, 0, &emsg);
}
*/
if (emsg.data && (--(emsg.data->ref) == 0))
@@ -1237,7 +1159,7 @@ _edje_emit_handle(Edje *ed, const char *sig, const char *src,
// printf("EDJE EMIT: (%p) signal: \"%s\" source: \"%s\"\n", ed, sig, src);
_edje_block(ed);
_edje_ref(ed);
- _edje_freeze(ed);
+ _edje_util_freeze(ed);
if (ed->collection && ed->L)
_edje_lua2_script_func_signal(ed, sig, src);
@@ -1390,7 +1312,7 @@ _edje_emit_handle(Edje *ed, const char *sig, const char *src,
}
}
break_prog:
- _edje_thaw(ed);
+ _edje_util_thaw(ed);
_edje_unref(ed);
_edje_unblock(ed);
}
@@ -1417,7 +1339,7 @@ _edje_emit_cb(Edje *ed, const char *sig, const char *src, Edje_Message_Signal_Da
if (!ed->callbacks || !ed->callbacks->matches) return;
_edje_ref(ed);
- _edje_freeze(ed);
+ _edje_util_freeze(ed);
_edje_block(ed);
ed->walking_callbacks++;
@@ -1472,7 +1394,7 @@ break_prog:
ed->callbacks->matches->matches_count);
_edje_unblock(ed);
- _edje_thaw(ed);
+ _edje_util_thaw(ed);
_edje_unref(ed);
}
diff --git a/src/lib/edje/edje_smart.c b/src/lib/edje/edje_smart.c
index b14ba16b94..536356edb7 100644
--- a/src/lib/edje/edje_smart.c
+++ b/src/lib/edje/edje_smart.c
@@ -2,8 +2,6 @@
#include
-EAPI Eo_Op EDJE_OBJ_BASE_ID = EO_NOOP;
-
#ifdef MY_CLASS
# undef MY_CLASS
#endif
@@ -26,10 +24,9 @@ edje_object_add(Evas *evas)
return e;
}
-static void
-_edje_smart_constructor(Eo *obj, void *class_data, va_list *list EINA_UNUSED)
+EOLIAN static void
+_edje_eo_base_constructor(Eo *obj, Edje *ed)
{
- Edje *ed = class_data;
ed->base = eo_data_ref(obj, EVAS_OBJ_SMART_CLIPPED_CLASS);
eo_do_super(obj, MY_CLASS, eo_constructor());
@@ -37,17 +34,16 @@ _edje_smart_constructor(Eo *obj, void *class_data, va_list *list EINA_UNUSED)
_edje_lib_ref();
}
-static void
-_edje_smart_destructor(Eo *obj, void *class_data, va_list *list EINA_UNUSED)
+EOLIAN static void
+_edje_eo_base_destructor(Eo *obj, Edje *class_data EINA_UNUSED)
{
eo_do_super(obj, MY_CLASS, eo_destructor());
eo_data_unref(obj, class_data);
}
-static void
-_dbg_info_get(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list)
+EOLIAN static void
+_edje_eo_base_dbg_info_get(Eo *eo_obj, Edje *_pd EINA_UNUSED, Eo_Dbg_Info *root)
{
- Eo_Dbg_Info *root = (Eo_Dbg_Info *) va_arg(*list, Eo_Dbg_Info *);
eo_do_super(eo_obj, MY_CLASS, eo_dbg_info_get(root));
Eo_Dbg_Info *group = EO_DBG_INFO_LIST_APPEND(root, MY_CLASS_NAME);
@@ -76,10 +72,9 @@ _edje_color_class_free(void *data)
/* Private Routines */
-static void
-_edje_smart_add(Eo *obj, void *_pd, va_list *list EINA_UNUSED)
+EOLIAN static void
+_edje_evas_smart_add(Eo *obj, Edje *ed)
{
- Edje *ed = _pd;
Evas *tev = evas_object_evas_get(obj);
evas_event_freeze(tev);
@@ -119,11 +114,9 @@ _edje_smart_add(Eo *obj, void *_pd, va_list *list EINA_UNUSED)
evas_event_thaw_eval(tev);
}
-static void
-_edje_smart_del(Eo *obj, void *_pd, va_list *list EINA_UNUSED)
+EOLIAN static void
+_edje_evas_smart_del(Eo *obj, Edje *ed)
{
- Edje *ed = _pd;
-
_edje_block_violate(ed);
ed->delete_me = 1;
_edje_edjes = eina_list_remove(_edje_edjes, obj);
@@ -145,12 +138,9 @@ _edje_smart_del(Eo *obj, void *_pd, va_list *list EINA_UNUSED)
_edje_lib_unref();
}
-static void
-_edje_smart_move(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+EOLIAN static void
+_edje_evas_smart_move(Eo *obj EINA_UNUSED, Edje *ed, Evas_Coord x, Evas_Coord y)
{
- Evas_Coord x = va_arg(*list, Evas_Coord);
- Evas_Coord y = va_arg(*list, Evas_Coord);
- Edje *ed = _pd;
unsigned int i;
if ((ed->x == x) && (ed->y == y)) return;
@@ -243,13 +233,9 @@ _edje_limit_get(Edje *ed, Edje_Limit **limits, unsigned int length, Evas_Coord s
}
}
-static void
-_edje_smart_resize(Eo *obj EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list)
+EOLIAN static void
+_edje_evas_smart_resize(Eo *obj EINA_UNUSED, Edje *ed, Evas_Coord w, Evas_Coord h)
{
- Evas_Coord w = va_arg(*list, Evas_Coord);
- Evas_Coord h = va_arg(*list, Evas_Coord);
- Edje *ed = _pd;
-
if ((w == ed->w) && (h == ed->h)) return;
if (ed->collection)
{
@@ -283,11 +269,9 @@ _edje_smart_resize(Eo *obj EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list)
_edje_emit(ed, "resize", NULL);
}
-static void
-_edje_smart_show(Eo *obj, void *_pd, va_list *list EINA_UNUSED)
+EOLIAN static void
+_edje_evas_smart_show(Eo *obj, Edje *ed)
{
- Edje *ed = _pd;
-
eo_do_super(obj, MY_CLASS, evas_obj_smart_show());
if (evas_object_visible_get(obj)) return;
if (_edje_script_only(ed))
@@ -303,11 +287,9 @@ _edje_smart_show(Eo *obj, void *_pd, va_list *list EINA_UNUSED)
_edje_emit(ed, "show", NULL);
}
-static void
-_edje_smart_hide(Eo *obj, void *_pd, va_list *list EINA_UNUSED)
+EOLIAN static void
+_edje_evas_smart_hide(Eo *obj, Edje *ed)
{
- Edje *ed = _pd;
-
eo_do_super(obj, MY_CLASS, evas_obj_smart_hide());
if (!evas_object_visible_get(obj)) return;
if (_edje_script_only(ed))
@@ -323,23 +305,20 @@ _edje_smart_hide(Eo *obj, void *_pd, va_list *list EINA_UNUSED)
_edje_emit(ed, "hide", NULL);
}
-static void
-_edje_smart_calculate(Eo *obj EINA_UNUSED, void *_pd, va_list *list EINA_UNUSED)
+EOLIAN static void
+_edje_evas_smart_calculate(Eo *obj EINA_UNUSED, Edje *ed)
{
- Edje *ed = _pd;
_edje_recalc_do(ed);
}
-static void
-_edje_smart_file_set(Eo *obj, void *_pd EINA_UNUSED, va_list *list)
+EOLIAN static Eina_Bool
+_edje_file_set(Eo *obj, Edje *_pd EINA_UNUSED, const char *file, const char *group)
{
- const char *file = va_arg(*list, const char *);
- const char *group = va_arg(*list, const char *);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
+ Eina_Bool ret;
Eina_File *f = NULL;
Eina_Array *nested;
- if (ret) *ret = EINA_FALSE;
+ ret = EINA_FALSE;
if (file)
{
@@ -350,356 +329,38 @@ _edje_smart_file_set(Eo *obj, void *_pd EINA_UNUSED, va_list *list)
ed = _edje_fetch(obj);
ed->load_error = EDJE_LOAD_ERROR_DOES_NOT_EXIST;
- return ;
+ return ret;
}
}
nested = eina_array_new(8);
if (_edje_object_file_set_internal(obj, f, group, NULL, NULL, nested))
- if (ret) *ret = EINA_TRUE;
+ ret = EINA_TRUE;
eina_array_free(nested);
eina_file_close(f);
_edje_object_orientation_inform(obj);
+
+ return ret;
}
-static void
-_edje_smart_mmap_set(Eo *obj, void *_pd EINA_UNUSED, va_list *list)
+EOLIAN static Eina_Bool
+_edje_mmap_set(Eo *obj, Edje *_pd EINA_UNUSED, const Eina_File *f, const char *group)
{
- const Eina_File *f = va_arg(*list, Eina_File *);
- const char *group = va_arg(*list, const char *);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
+ Eina_Bool ret;
Eina_Array *nested;
- if (ret) *ret = EINA_FALSE;
+ ret = EINA_FALSE;
nested = eina_array_new(8);
if (_edje_object_file_set_internal(obj, f, group, NULL, NULL, nested))
- if (ret) *ret = EINA_TRUE;
+ ret = EINA_TRUE;
eina_array_free(nested);
_edje_object_orientation_inform(obj);
+
+ return ret;
}
-static void
-_edje_smart_class_constructor(Eo_Class *klass)
-{
- const Eo_Op_Func_Description func_desc[] = {
- EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _edje_smart_constructor),
- EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_DESTRUCTOR), _edje_smart_destructor),
- EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_DBG_INFO_GET), _dbg_info_get),
- EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_ADD), _edje_smart_add),
- EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_DEL), _edje_smart_del),
- EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_MOVE), _edje_smart_move),
- EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_SHOW), _edje_smart_show),
- EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_HIDE), _edje_smart_hide),
- EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_RESIZE), _edje_smart_resize),
- EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_CALCULATE), _edje_smart_calculate),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_SCALE_SET), _scale_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_SCALE_GET), _scale_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_MIRRORED_GET), _mirrored_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_MIRRORED_SET), _mirrored_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_DATA_GET), _data_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_FREEZE), _freeze),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_THAW), _thaw),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_COLOR_CLASS_SET), _color_class_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_COLOR_CLASS_GET), _color_class_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_TEXT_CLASS_SET), _text_class_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_EXISTS), _part_exists),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_OBJECT_GET), _part_object_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_GEOMETRY_GET), _part_geometry_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_ITEM_PROVIDER_SET), _item_provider_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_TEXT_CHANGE_CB_SET), _text_change_cb_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_STYLE_USER_PUSH), _part_text_style_user_push),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_STYLE_USER_POP), _part_text_style_user_pop),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_STYLE_USER_PEEK), _part_text_style_user_peek),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_SET), _part_text_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_GET), _part_text_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_ESCAPED_SET), _part_text_escaped_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_UNESCAPED_SET), _part_text_unescaped_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_UNESCAPED_GET), _part_text_unescaped_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_SELECTION_GET), _part_text_selection_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_SELECT_NONE), _part_text_select_none),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_SELECT_ALL), _part_text_select_all),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_INSERT), _part_text_insert),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_APPEND), _part_text_append),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_ANCHOR_LIST_GET), _part_text_anchor_list_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_ANCHOR_GEOMETRY_GET), _part_text_anchor_geometry_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_ITEM_LIST_GET), _part_text_item_list_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_ITEM_GEOMETRY_GET), _part_text_item_geometry_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_CURSOR_GEOMETRY_GET), _part_text_cursor_geometry_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_USER_INSERT), _part_text_user_insert),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_SELECT_ALLOW_SET), _part_text_select_allow_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_SELECT_ABORT), _part_text_select_abort),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_SELECT_BEGIN), _part_text_select_begin),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_SELECT_EXTEND), _part_text_select_extend),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_IMF_CONTEXT_GET), _part_text_imf_context_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_CURSOR_NEXT), _part_text_cursor_next),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_CURSOR_PREV), _part_text_cursor_prev),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_CURSOR_UP), _part_text_cursor_up),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_CURSOR_DOWN), _part_text_cursor_down),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_CURSOR_BEGIN_SET), _part_text_cursor_begin_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_CURSOR_END_SET), _part_text_cursor_end_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_CURSOR_COPY), _part_text_cursor_copy),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_CURSOR_LINE_BEGIN_SET), _part_text_cursor_line_begin_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_CURSOR_LINE_END_SET), _part_text_cursor_line_end_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_CURSOR_COORD_SET), _part_text_cursor_coord_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_CURSOR_IS_FORMAT_GET), _part_text_cursor_is_format_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_CURSOR_IS_VISIBLE_FORMAT_GET), _part_text_cursor_is_visible_format_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_CURSOR_CONTENT_GET), _part_text_cursor_content_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_CURSOR_POS_SET), _part_text_cursor_pos_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_CURSOR_POS_GET), _part_text_cursor_pos_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_IMF_CONTEXT_RESET), _part_text_imf_context_reset),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_LAYOUT_SET), _part_text_input_panel_layout_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_LAYOUT_GET), _part_text_input_panel_layout_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_LAYOUT_VARIATION_SET), _part_text_input_panel_layout_variation_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_LAYOUT_VARIATION_GET), _part_text_input_panel_layout_variation_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_AUTOCAPITAL_TYPE_SET), _part_text_autocapital_type_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_AUTOCAPITAL_TYPE_GET), _part_text_autocapital_type_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_PREDICTION_ALLOW_SET), _part_text_prediction_allow_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_PREDICTION_ALLOW_GET), _part_text_prediction_allow_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_ENABLED_SET), _part_text_input_panel_enabled_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_ENABLED_GET), _part_text_input_panel_enabled_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_SHOW), _part_text_input_panel_show),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_HIDE), _part_text_input_panel_hide),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_LANGUAGE_SET), _part_text_input_panel_language_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_LANGUAGE_GET), _part_text_input_panel_language_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_IMDATA_SET), _part_text_input_panel_imdata_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_IMDATA_GET), _part_text_input_panel_imdata_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_RETURN_KEY_TYPE_SET), _part_text_input_panel_return_key_type_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_RETURN_KEY_TYPE_GET), _part_text_input_panel_return_key_type_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_RETURN_KEY_DISABLED_SET), _part_text_input_panel_return_key_disabled_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_RETURN_KEY_DISABLED_GET), _part_text_input_panel_return_key_disabled_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_SHOW_ON_DEMAND_SET), _part_text_input_panel_show_on_demand_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_SHOW_ON_DEMAND_GET), _part_text_input_panel_show_on_demand_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_TEXT_INSERT_FILTER_CALLBACK_ADD), _text_insert_filter_callback_add),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_TEXT_INSERT_FILTER_CALLBACK_DEL), _text_insert_filter_callback_del),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_TEXT_INSERT_FILTER_CALLBACK_DEL_FULL), _text_insert_filter_callback_del_full),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_TEXT_MARKUP_FILTER_CALLBACK_ADD), _text_markup_filter_callback_add),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_TEXT_MARKUP_FILTER_CALLBACK_DEL), _text_markup_filter_callback_del),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_TEXT_MARKUP_FILTER_CALLBACK_DEL_FULL), _text_markup_filter_callback_del_full),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_SWALLOW), _part_swallow),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_UNSWALLOW), _part_unswallow),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_SWALLOW_GET), _part_swallow_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_SIZE_MIN_GET), _size_min_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_SIZE_MAX_GET), _size_max_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_CALC_FORCE), _calc_force),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_SIZE_MIN_CALC), _size_min_calc),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PARTS_EXTENDS_CALC), _parts_extends_calc),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_SIZE_MIN_RESTRICTED_CALC), _size_min_restricted_calc),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_STATE_GET), _part_state_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_DRAG_DIR_GET), _part_drag_dir_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_DRAG_VALUE_SET), _part_drag_value_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_DRAG_VALUE_GET), _part_drag_value_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_DRAG_SIZE_SET), _part_drag_size_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_DRAG_SIZE_GET), _part_drag_size_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_DRAG_STEP_SET), _part_drag_step_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_DRAG_STEP_GET), _part_drag_step_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_DRAG_PAGE_SET), _part_drag_page_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_DRAG_PAGE_GET), _part_drag_page_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_DRAG_STEP), _part_drag_step),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_DRAG_PAGE), _part_drag_page),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_BOX_APPEND), _part_box_append),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_BOX_PREPEND), _part_box_prepend),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_BOX_INSERT_BEFORE), _part_box_insert_before),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_BOX_INSERT_AT), _part_box_insert_at),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_BOX_REMOVE), _part_box_remove),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_BOX_REMOVE_AT), _part_box_remove_at),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_BOX_REMOVE_ALL), _part_box_remove_all),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_ACCESS_PART_LIST_GET), _access_part_list_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TABLE_CHILD_GET), _part_table_child_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TABLE_PACK), _part_table_pack),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TABLE_UNPACK), _part_table_unpack),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TABLE_COL_ROW_SIZE_GET), _part_table_col_row_size_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_TABLE_CLEAR), _part_table_clear),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PERSPECTIVE_SET), _perspective_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PERSPECTIVE_GET), _perspective_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PRELOAD), _preload),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_UPDATE_HINTS_SET), _update_hints_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_UPDATE_HINTS_GET), _update_hints_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_EXTERNAL_OBJECT_GET), _part_external_object_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_EXTERNAL_PARAM_SET), _part_external_param_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_EXTERNAL_PARAM_GET), _part_external_param_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_EXTERNAL_CONTENT_GET), _part_external_content_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PART_EXTERNAL_PARAM_TYPE_GET), _part_external_param_type_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_FILE_SET), _edje_smart_file_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_MMAP_SET), _edje_smart_mmap_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_FILE_GET), _file_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_LOAD_ERROR_GET), _load_error_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_MESSAGE_SEND), _message_send),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_MESSAGE_HANDLER_SET), _message_handler_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_MESSAGE_SIGNAL_PROCESS), _message_signal_process),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_SIGNAL_CALLBACK_ADD), _signal_callback_add),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_SIGNAL_CALLBACK_DEL), _signal_callback_del),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_SIGNAL_EMIT), _signal_emit),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PLAY_SET), _play_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_PLAY_GET), _play_get),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_ANIMATION_SET), _animation_set),
- EO_OP_FUNC(EDJE_OBJ_ID(EDJE_OBJ_SUB_ID_ANIMATION_GET), _animation_get),
- EO_OP_FUNC_SENTINEL
- };
-
- eo_class_funcs_set(klass, func_desc);
-
- evas_smart_legacy_type_register(MY_CLASS_NAME_LEGACY, klass);
-}
-
-static const Eo_Op_Description op_desc[] = {
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_SCALE_SET, "Set the scaling factor for a given Edje object."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_SCALE_GET, "Get a given Edje object's scaling factor."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_MIRRORED_GET, "Get the RTL orientation for this object."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_MIRRORED_SET, "Set the RTL orientation for this object."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_DATA_GET, "Retrive an EDC data field's value from a given Edje"),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_FREEZE, "Freezes the Edje object."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_THAW, "Thaws the Edje object."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_COLOR_CLASS_SET, "Sets the object color class."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_COLOR_CLASS_GET, "Gets the object color class."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_TEXT_CLASS_SET, "Sets Edje text class."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_EXISTS, "Check if an Edje part exists in a given Edje object's group"),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_OBJECT_GET, "Get a handle to the Evas object implementing a given Edje"),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_GEOMETRY_GET, "Retrieve the geometry of a given Edje part, in a given Edje"),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_ITEM_PROVIDER_SET, "Set the function that provides item objects for named items in an edje entry text"),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_TEXT_CHANGE_CB_SET, "Set the object text callback."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_STYLE_USER_PUSH, "Set the style of the"),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_STYLE_USER_POP, "Delete the top style form the user style stack."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_STYLE_USER_PEEK, "Return the text of the object part."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_SET, "Sets the text for an object part"),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_GET, "Return the text of the object part."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_ESCAPED_SET, "Sets the text for an object part, but converts HTML escapes to UTF8"),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_UNESCAPED_SET, "Sets the raw (non escaped) text for an object part."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_UNESCAPED_GET, "Returns the text of the object part, without escaping."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_SELECTION_GET, "Return the selection text of the object part."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_SELECT_NONE, "Set the selection to be none."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_SELECT_ALL, "Set the selection to be everything."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_INSERT, "Insert text for an object part."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_APPEND, "Insert text for an object part."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_ANCHOR_LIST_GET, "Return a list of char anchor names."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_ANCHOR_GEOMETRY_GET, "Return a list of Evas_Textblock_Rectangle anchor rectangles."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_ITEM_LIST_GET, "Return a list of char item names."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_ITEM_GEOMETRY_GET, "Return item geometry."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_CURSOR_GEOMETRY_GET, "Returns the cursor geometry of the part relative to the edje"),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_USER_INSERT, "This function inserts text as if the user has inserted it."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_SELECT_ALLOW_SET, "Enables selection if the entry is an EXPLICIT selection mode"),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_SELECT_ABORT, "Aborts any selection action on a part."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_SELECT_BEGIN, "Starts selecting at current cursor position"),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_SELECT_EXTEND, "Extends the current selection to the current cursor position"),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_IMF_CONTEXT_GET, "Get the input method context in entry."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_CURSOR_NEXT, "Advances the cursor to the next cursor position."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_CURSOR_PREV, "Moves the cursor to the previous char"),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_CURSOR_UP, "Move the cursor to the char above the current cursor position."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_CURSOR_DOWN, "Moves the cursor to the char below the current cursor position."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_CURSOR_BEGIN_SET, "Moves the cursor to the beginning of the text part"),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_CURSOR_END_SET, "Moves the cursor to the end of the text part."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_CURSOR_COPY, "Copy the cursor to another cursor."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_CURSOR_LINE_BEGIN_SET, "Move the cursor to the beginning of the line."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_CURSOR_LINE_END_SET, "Move the cursor to the end of the line."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_CURSOR_COORD_SET, "Position the given cursor to a X,Y position."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_CURSOR_IS_FORMAT_GET, "Returns whether the cursor points to a format."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_CURSOR_IS_VISIBLE_FORMAT_GET, "Return true if the cursor points to a visible format"),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_CURSOR_CONTENT_GET, "Returns the content (char) at the cursor position."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_CURSOR_POS_SET, "Sets the cursor position to the given value"),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_CURSOR_POS_GET, "Retrieves the current position of the cursor"),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_IMF_CONTEXT_RESET, "Reset the input method context if needed."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_LAYOUT_SET, "Set the layout of the input panel."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_LAYOUT_GET, "Get the layout of the input panel."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_LAYOUT_VARIATION_SET, "Set the variation of the input panel."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_LAYOUT_VARIATION_GET, "Get the variation of the input panel."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_AUTOCAPITAL_TYPE_SET, "Set the autocapitalization type on the immodule."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_AUTOCAPITAL_TYPE_GET, "Retrieves the autocapitalization type"),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_PREDICTION_ALLOW_SET, "Set whether the prediction is allowed or not."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_PREDICTION_ALLOW_GET, "Get whether the prediction is allowed or not."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_ENABLED_SET, "Sets the attribute to show the input panel automatically."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_ENABLED_GET, "Retrieve the attribute to show the input panel automatically."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_SHOW, "Show the input panel (virtual keyboard) based on the input panel property such as layout, autocapital types, and so on."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_HIDE, "Hide the input panel (virtual keyboard)."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_LANGUAGE_SET, "Set the language mode of the input panel."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_LANGUAGE_GET, "Get the language mode of the input panel."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_IMDATA_SET, "Set the input panel-specific data to deliver to the input panel."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_IMDATA_GET, "Get the specific data of the current active input panel."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_RETURN_KEY_TYPE_SET, "Set the return key type. This type is used to set string or icon on the return key of the input panel."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_RETURN_KEY_TYPE_GET, "Get the return key type."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_RETURN_KEY_DISABLED_SET, "Set the return key on the input panel to be disabled."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_RETURN_KEY_DISABLED_GET, "Get whether the return key on the input panel should be disabled or not."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_SHOW_ON_DEMAND_SET, "Set the attribute to show the input panel in case of only an user's explicit Mouse Up event."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TEXT_INPUT_PANEL_SHOW_ON_DEMAND_GET, "Get the attribute to show the input panel in case of only an user's explicit Mouse Up event."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_TEXT_INSERT_FILTER_CALLBACK_ADD, "Add a filter function for newly inserted text."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_TEXT_INSERT_FILTER_CALLBACK_DEL, "Delete a function from the filter list."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_TEXT_INSERT_FILTER_CALLBACK_DEL_FULL, "Delete a function and matching user data from the filter list."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_TEXT_MARKUP_FILTER_CALLBACK_ADD, "Add a markup filter function for newly inserted text."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_TEXT_MARKUP_FILTER_CALLBACK_DEL, "Delete a function from the markup filter list."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_TEXT_MARKUP_FILTER_CALLBACK_DEL_FULL, "Delete a function and matching user data from the markup filter list."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_SWALLOW, "Swallows an object into one of the Edje object @c SWALLOW"),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_UNSWALLOW, "Unswallow an object."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_SWALLOW_GET, "Get the object currently swallowed by a part."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_SIZE_MIN_GET, "Get the minimum size specified -- as an EDC property -- for a"),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_SIZE_MAX_GET, "Get the maximum size specified -- as an EDC property -- for a"),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_CALC_FORCE, "Force a Size/Geometry calculation."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_SIZE_MIN_CALC, "Calculate the minimum required size for a given Edje object."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PARTS_EXTENDS_CALC, "Calculate the geometry of the region, relative to a given Edje"),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_SIZE_MIN_RESTRICTED_CALC, "Calculate the minimum required size for a given Edje object."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_STATE_GET, "Returns the state of the Edje part."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_DRAG_DIR_GET, "Determine dragable directions."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_DRAG_VALUE_SET, "Set the dragable object location."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_DRAG_VALUE_GET, "Get the dragable object location."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_DRAG_SIZE_SET, "Set the dragable object size."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_DRAG_SIZE_GET, "Get the dragable object size."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_DRAG_STEP_SET, "Sets the drag step increment."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_DRAG_STEP_GET, "Gets the drag step increment values."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_DRAG_PAGE_SET, "Sets the page step increments."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_DRAG_PAGE_GET, "Gets the page step increments."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_DRAG_STEP, "Steps the dragable x,y steps."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_DRAG_PAGE, "Pages x,y steps."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_BOX_APPEND, "Appends an object to the box."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_BOX_PREPEND, "Prepends an object to the box."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_BOX_INSERT_BEFORE, "Adds an object to the box."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_BOX_INSERT_AT, "Inserts an object to the box."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_BOX_REMOVE, "Removes an object from the box."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_BOX_REMOVE_AT, "Removes an object from the box."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_BOX_REMOVE_ALL, "Removes all elements from the box."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_ACCESS_PART_LIST_GET, "Retrieve a list all accessibility part names"),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TABLE_CHILD_GET, "Retrieve a child from a table"),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TABLE_PACK, "Packs an object into the table."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TABLE_UNPACK, "Removes an object from the table."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TABLE_COL_ROW_SIZE_GET, "Gets the number of columns and rows the table has."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_TABLE_CLEAR, "Removes all object from the table."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PERSPECTIVE_SET, "Set the given perspective object on this Edje object."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PERSPECTIVE_GET, "Get the current perspective used on this Edje object."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PRELOAD, "Preload the images on the Edje Object in the background."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_UPDATE_HINTS_SET, "Edje will automatically update the size hints on itself."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_UPDATE_HINTS_GET, "Wether or not Edje will update size hints on itself."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_EXTERNAL_OBJECT_GET, "Get the object created by this external part."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_EXTERNAL_PARAM_SET, "Set the parameter for the external part."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_EXTERNAL_PARAM_GET, "Get the parameter for the external part."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_EXTERNAL_CONTENT_GET, "Get an object contained in an part of type EXTERNAL"),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PART_EXTERNAL_PARAM_TYPE_GET, "Facility to query the type of the given parameter of the given part."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_FILE_SET, "Sets the @b EDJ file (and group within it) to load an Edje"),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_MMAP_SET, "Sets the @b EDJ file (and group within it) to load an Edje"),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_FILE_GET, "Get the file and group name that a given Edje object is bound to"),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_LOAD_ERROR_GET, "Gets the (last) file loading error for a given Edje object"),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_MESSAGE_SEND, "Send an (Edje) message to a given Edje object"),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_MESSAGE_HANDLER_SET, "Set an Edje message handler function for a given Edje object."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_MESSAGE_SIGNAL_PROCESS, "Process an object's message queue."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_SIGNAL_CALLBACK_ADD, "Add a callback for an arriving Edje signal, emitted by"),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_SIGNAL_CALLBACK_DEL, "Remove a signal-triggered callback from an object."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_SIGNAL_EMIT, "Send/emit an Edje signal to a given Edje object"),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PLAY_SET, "Set the Edje object to playing or paused states."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_PLAY_GET, "Get the Edje object's state."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_ANIMATION_SET, "Set the object's animation state."),
- EO_OP_DESCRIPTION(EDJE_OBJ_SUB_ID_ANIMATION_GET, "Get the Edje object's animation state."),
- EO_OP_DESCRIPTION_SENTINEL
-};
-
-static const Eo_Class_Description edje_smart_class_desc = {
- EO_VERSION,
- MY_CLASS_NAME,
- EO_CLASS_TYPE_REGULAR,
- EO_CLASS_DESCRIPTION_OPS(&EDJE_OBJ_BASE_ID, op_desc, EDJE_OBJ_SUB_ID_LAST),
- NULL,
- sizeof(Edje),
- _edje_smart_class_constructor,
- NULL
-};
-
-EO_DEFINE_CLASS(edje_object_class_get, &edje_smart_class_desc, EVAS_OBJ_SMART_CLIPPED_CLASS, NULL);
-
+#include "edje.eo.c"
\ No newline at end of file
diff --git a/src/lib/edje/edje_util.c b/src/lib/edje/edje_util.c
index 8819f40a3f..3a1c91bd13 100644
--- a/src/lib/edje/edje_util.c
+++ b/src/lib/edje/edje_util.c
@@ -24,9 +24,9 @@ char *_edje_fontset_append = NULL;
FLOAT_T _edje_scale = ZERO;
Eina_Bool _edje_password_show_last = EINA_FALSE;
double _edje_password_show_last_timeout = 0;
-int _edje_freeze_val = 0;
-int _edje_freeze_calc_count = 0;
-Eina_List *_edje_freeze_calc_list = NULL;
+int _edje_util_freeze_val = 0;
+int _edje_util_freeze_calc_count = 0;
+Eina_List *_edje_util_freeze_calc_list = NULL;
typedef struct _Edje_List_Foreach_Data Edje_List_Foreach_Data;
struct _Edje_List_Foreach_Data
@@ -236,7 +236,7 @@ EAPI void
edje_freeze(void)
{
#ifdef FASTFREEZE
- _edje_freeze_val++;
+ _edje_util_freeze_val++;
#else
// FIXME: could just have a global freeze instead of per object
// above i tried.. but this broke some things. notable e17's menus. why?
@@ -250,7 +250,7 @@ edje_freeze(void)
#ifdef FASTFREEZE
static void
-_edje_thaw_edje(Edje *ed)
+_edje_util_thaw_edje(Edje *ed)
{
unsigned int i;
@@ -267,7 +267,7 @@ _edje_thaw_edje(Edje *ed)
Edje *ed2;
ed2 = _edje_fetch(rp->typedata.swallow->swallowed_object);
- if (ed2) _edje_thaw_edje(ed2);
+ if (ed2) _edje_util_thaw_edje(ed2);
}
}
if ((ed->recalc) && (ed->freeze <= 0)) _edje_recalc_do(ed);
@@ -278,16 +278,16 @@ EAPI void
edje_thaw(void)
{
#ifdef FASTFREEZE
- if (!_edje_freeze_val) return;
- _edje_freeze_val--;
- if ((_edje_freeze_val == 0) && (_edje_freeze_calc_count > 0))
+ if (!_edje_util_freeze_val) return;
+ _edje_util_freeze_val--;
+ if ((_edje_util_freeze_val == 0) && (_edje_util_freeze_calc_count > 0))
{
Edje *ed;
- _edje_freeze_calc_count = 0;
- EINA_LIST_FREE(_edje_freeze_calc_list, ed)
+ _edje_util_freeze_calc_count = 0;
+ EINA_LIST_FREE(_edje_util_freeze_calc_list, ed)
{
- _edje_thaw_edje(ed);
+ _edje_util_thaw_edje(ed);
ed->freeze_calc = EINA_FALSE;
}
}
@@ -349,29 +349,15 @@ edje_password_show_last_timeout_set(double password_show_last_timeout)
_edje_password_show_last_timeout = password_show_last_timeout;
}
-EAPI Eina_Bool
-edje_object_scale_set(Evas_Object *obj, double scale)
+EOLIAN Eina_Bool
+_edje_scale_set(Eo *obj, Edje *ed, double scale)
{
- if (!eo_isa(obj, EDJE_OBJ_CLASS)) return EINA_FALSE;
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do(obj, edje_obj_scale_set(scale, &ret));
- return ret;
-}
-
-void
-_scale_set(Eo *obj, void *_pd, va_list *list)
-{
- double scale = va_arg(*list, double);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- if (ret) *ret = EINA_TRUE;
- Edje *ed, *ged;
+ Edje *ged;
Evas_Object *o;
Eina_List *l;
unsigned int i;
- ed = _pd;
- if (ed->scale == scale) return;
+ if (ed->scale == scale) return EINA_TRUE;
ed->scale = FROM_DOUBLE(scale);
EINA_LIST_FOREACH(ed->groups, l, ged)
edje_object_scale_set(ged->obj, scale);
@@ -387,40 +373,20 @@ _scale_set(Eo *obj, void *_pd, va_list *list)
}
}
edje_object_calc_force(obj);
+
+ return EINA_TRUE;
}
-EAPI double
-edje_object_scale_get(const Evas_Object *obj)
+EOLIAN double
+_edje_scale_get(Eo *obj EINA_UNUSED, Edje *ed)
{
- if (!obj) return 0.0;
- double ret = 0.0;
- eo_do((Eo *)obj, edje_obj_scale_get(&ret));
- return ret;
+ return TO_DOUBLE(ed->scale);
}
-void
-_scale_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+EOLIAN Eina_Bool
+_edje_mirrored_get(Eo *obj EINA_UNUSED, Edje *ed)
{
- double *ret = va_arg(*list, double *);
- const Edje *ed = _pd;
- *ret = TO_DOUBLE(ed->scale);
-}
-
-EAPI Eina_Bool
-edje_object_mirrored_get(const Evas_Object *obj)
-{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do((Eo *)obj, edje_obj_mirrored_get(&ret));
- return ret;
-}
-
-void
-_mirrored_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- const Edje *ed = _pd;
- *ret = ed->is_rtl;
+ return ed->is_rtl;
}
void
@@ -433,19 +399,9 @@ _edje_object_orientation_inform(Evas_Object *obj)
edje_object_signal_emit(obj, "edje,state,ltr", "edje");
}
-EAPI void
-edje_object_mirrored_set(Evas_Object *obj, Eina_Bool rtl)
+EOLIAN void
+_edje_mirrored_set(Eo *obj, Edje *ed, Eina_Bool rtl)
{
- if (!obj) return;
- eo_do(obj, edje_obj_mirrored_set(rtl));
-}
-
-void
-_mirrored_set(Eo *obj, void *_pd, va_list *list)
-{
- Eina_Bool rtl = va_arg(*list, int);
-
- Edje *ed = _pd;
unsigned int i;
if (ed->is_rtl == rtl) return;
@@ -471,49 +427,22 @@ _mirrored_set(Eo *obj, void *_pd, va_list *list)
return;
}
-EAPI const char *
-edje_object_data_get(const Evas_Object *obj, const char *key)
+EOLIAN const char*
+_edje_data_get(Eo *obj EINA_UNUSED, Edje *ed, const char *key)
{
- if (!obj) return NULL;
- const char *ret = NULL;
- eo_do((Eo *)obj, edje_obj_data_get(key, &ret));
- return ret;
-}
-
-void
-_data_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *key = va_arg(*list, const char *);
- const char **ret = va_arg(*list, const char **);
- *ret = NULL;
-
- const Edje *ed = _pd;
-
if ((!ed) || (!key))
- return;
- if (!ed->collection) return;
- if (!ed->collection->data) return;
- *ret = edje_string_get(eina_hash_find(ed->collection->data, key));
+ return NULL;
+ if (!ed->collection) return NULL;
+ if (!ed->collection->data) return NULL;
+
+ return edje_string_get(eina_hash_find(ed->collection->data, key));
}
-EAPI int
-edje_object_freeze(Evas_Object *obj)
+EOLIAN int
+_edje_freeze(Eo *obj EINA_UNUSED, Edje *ed)
{
- if (!obj) return 0;
- int ret = 0;
- eo_do(obj, edje_obj_freeze(&ret));
- return ret;
-}
-
-void
-_freeze(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- int *ret = va_arg(*list, int *);
-
- Edje *ed = _pd;
unsigned int i;
- if (ret) *ret = 0;
for (i = 0; i < ed->table_parts_size; i++)
{
Edje_Real_Part *rp;
@@ -524,27 +453,14 @@ _freeze(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
(rp->typedata.swallow->swallowed_object))
edje_object_freeze(rp->typedata.swallow->swallowed_object);
}
- int int_ret = _edje_freeze(ed);
- if (ret) *ret = int_ret;
+ return _edje_util_freeze(ed);
}
-EAPI int
-edje_object_thaw(Evas_Object *obj)
+EOLIAN int
+_edje_thaw(Eo *obj EINA_UNUSED, Edje *ed)
{
- if (!obj) return 0;
- int ret;
- eo_do(obj, edje_obj_thaw(&ret));
- return ret;
-}
-
-void
-_thaw(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- int *ret = va_arg(*list, int *);
- Edje *ed = _pd;
unsigned int i;
- if (ret) *ret = 0;
for (i = 0; i < ed->table_parts_size; i++)
{
Edje_Real_Part *rp;
@@ -556,8 +472,7 @@ _thaw(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
(rp->typedata.swallow->swallowed_object))
edje_object_thaw(rp->typedata.swallow->swallowed_object);
}
- int int_ret = _edje_thaw(ed);
- if (ret) *ret = int_ret;
+ return _edje_util_thaw(ed);
}
EAPI Eina_Bool
@@ -719,39 +634,13 @@ _edje_color_class_list_foreach(const Eina_Hash *hash EINA_UNUSED, const void *ke
return EINA_TRUE;
}
-EAPI Eina_Bool
-edje_object_color_class_set(Evas_Object *obj, const char *color_class, int r, int g, int b, int a, int r2, int g2, int b2, int a2, int r3, int g3, int b3, int a3)
+EOLIAN Eina_Bool
+_edje_color_class_set(Eo *obj EINA_UNUSED, Edje *ed, const char *color_class, int r, int g, int b, int a, int r2, int g2, int b2, int a2, int r3, int g3, int b3, int a3)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do(obj, edje_obj_color_class_set(color_class, r, g, b, a, r2, g2, b2, a2, r3, g3, b3, a3, &ret));
- return ret;
-}
-
-void
-_color_class_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *color_class = va_arg(*list, const char *);
- int r = va_arg(*list, int);
- int g = va_arg(*list, int);
- int b = va_arg(*list, int);
- int a = va_arg(*list, int);
- int r2 = va_arg(*list, int);
- int g2 = va_arg(*list, int);
- int b2 = va_arg(*list, int);
- int a2 = va_arg(*list, int);
- int r3 = va_arg(*list, int);
- int g3 = va_arg(*list, int);
- int b3 = va_arg(*list, int);
- int a3 = va_arg(*list, int);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- if (ret) *ret = EINA_FALSE;
-
- Edje *ed = _pd;
Edje_Color_Class *cc;
unsigned int i;
- if ((!ed) || (!color_class)) return;
+ if ((!ed) || (!color_class)) return EINA_FALSE;
if (r < 0) r = 0;
else if (r > 255) r = 255;
if (g < 0) g = 0;
@@ -770,19 +659,18 @@ _color_class_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
(cc->r3 == r3) && (cc->g3 == g3) &&
(cc->b3 == b3) && (cc->a3 == a3))
{
- if (ret) *ret = EINA_TRUE;
- return;
+ return EINA_TRUE;
}
goto update_color_class;
}
color_class = eina_stringshare_add(color_class);
- if (!color_class) return;
+ if (!color_class) return EINA_FALSE;
cc = malloc(sizeof(Edje_Color_Class));
if (!cc)
{
eina_stringshare_del(color_class);
- return;
+ return EINA_FALSE;
}
cc->name = color_class;
eina_hash_direct_add(ed->color_classes, cc->name, cc);
@@ -822,38 +710,13 @@ update_color_class:
_edje_recalc(ed);
_edje_emit(ed, "color_class,set", color_class);
- if (ret) *ret = EINA_TRUE;
+
+ return EINA_TRUE;
}
-EAPI Eina_Bool
-edje_object_color_class_get(const Evas_Object *obj, const char *color_class, int *r, int *g, int *b, int *a, int *r2, int *g2, int *b2, int *a2, int *r3, int *g3, int *b3, int *a3)
+EOLIAN Eina_Bool
+_edje_color_class_get(Eo *obj EINA_UNUSED, Edje *ed, const char *color_class, int *r, int *g, int *b, int *a, int *r2, int *g2, int *b2, int *a2, int *r3, int *g3, int *b3, int *a3)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do((Eo *)obj, edje_obj_color_class_get(color_class, r, g, b, a, r2, g2, b2, a2, r3, g3, b3, a3, &ret));
- return ret;
-}
-
-void
-_color_class_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *color_class = va_arg(*list, const char *);
- int *r = va_arg(*list, int *);
- int *g = va_arg(*list, int *);
- int *b = va_arg(*list, int *);
- int *a = va_arg(*list, int *);
- int *r2 = va_arg(*list, int *);
- int *g2 = va_arg(*list, int *);
- int *b2 = va_arg(*list, int *);
- int *a2 = va_arg(*list, int *);
- int *r3 = va_arg(*list, int *);
- int *g3 = va_arg(*list, int *);
- int *b3 = va_arg(*list, int *);
- int *a3 = va_arg(*list, int *);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- if (ret) *ret = EINA_FALSE;
-
- const Edje *ed = _pd;
Edje_Color_Class *cc = _edje_color_class_find(ed, color_class);
if (cc)
@@ -865,8 +728,7 @@ _color_class_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
S(r3, g3, b3, a3);
#undef S
#undef X
- if (ret) *ret = EINA_TRUE;
- return;
+ return EINA_TRUE;
}
else
{
@@ -877,8 +739,10 @@ _color_class_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
S(r3, g3, b3, a3);
#undef S
#undef X
- return;
+ return EINA_FALSE;
}
+
+ return EINA_FALSE;
}
void
@@ -1029,30 +893,14 @@ _edje_text_class_list_foreach(const Eina_Hash *hash EINA_UNUSED, const void *key
return EINA_TRUE;
}
-EAPI Eina_Bool
-edje_object_text_class_set(Evas_Object *obj, const char *text_class, const char *font, Evas_Font_Size size)
+EOLIAN Eina_Bool
+_edje_text_class_set(Eo *obj EINA_UNUSED, Edje *ed, const char *text_class, const char *font, Evas_Font_Size size)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do(obj, edje_obj_text_class_set(text_class, font, size, &ret));
- return ret;
-}
-
-void
-_text_class_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *text_class = va_arg(*list, const char *);
- const char *font = va_arg(*list, const char *);
- Evas_Font_Size size = va_arg(*list, Evas_Font_Size);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
-
- Edje *ed = _pd;
Eina_List *l;
Edje_Text_Class *tc = NULL;
unsigned int i;
- if (ret) *ret = EINA_FALSE;
- if ((!ed) || (!text_class)) return;
+ if ((!ed) || (!text_class)) return EINA_FALSE;
/* for each text_class in the edje */
EINA_LIST_FOREACH(ed->text_classes, l, tc)
@@ -1064,8 +912,7 @@ _text_class_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
((tc->font == font) ||
(tc->font && font && !strcmp(tc->font, font))))
{
- if (ret) *ret = EINA_TRUE;
- return;
+ return EINA_TRUE;
}
/* Update new text class properties */
@@ -1079,12 +926,12 @@ _text_class_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
{
/* No matches, create a new text class */
tc = calloc(1, sizeof(Edje_Text_Class));
- if (!tc) return;
+ if (!tc) return EINA_FALSE;
tc->name = eina_stringshare_add(text_class);
if (!tc->name)
{
free(tc);
- return;
+ return EINA_FALSE;
}
tc->font = eina_stringshare_add(font);
tc->size = size;
@@ -1113,83 +960,41 @@ _text_class_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
_edje_textblock_styles_cache_free(ed, text_class);
_edje_textblock_style_all_update(ed);
_edje_recalc(ed);
- if (ret) *ret = EINA_TRUE;
+
+ return EINA_TRUE;
}
-EAPI Eina_Bool
-edje_object_part_exists(const Evas_Object *obj, const char *part)
+EOLIAN Eina_Bool
+_edje_part_exists(Eo *obj EINA_UNUSED, Edje *ed, const char *part)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do((Eo *)obj, edje_obj_part_exists(part, &ret));
- return ret;
-}
-
-void
-_part_exists(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- *ret = EINA_FALSE;
-
- Edje *ed = _pd;
Edje_Real_Part *rp;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return EINA_FALSE;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
- *ret = EINA_TRUE;
+ if (!rp) return EINA_FALSE;
+
+ return EINA_TRUE;
}
-EAPI const Evas_Object *
-edje_object_part_object_get(const Evas_Object *obj, const char *part)
+EOLIAN const Evas_Object*
+_edje_part_object_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part)
{
- if (!obj) return NULL;
- const Evas_Object *ret = NULL;
- eo_do((Eo *)obj, edje_obj_part_object_get(part, &ret));
- return ret;
-}
-
-void
-_part_object_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- const Evas_Object **ret = va_arg(*list, const Evas_Object **);
- *ret = NULL;
- Edje *ed = (Edje *)_pd;
Edje_Real_Part *rp;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return NULL;
/* Need to recalc before providing the object. */
_edje_recalc_do(ed);
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
- *ret = rp->object;
+ if (!rp) return NULL;
+
+ return rp->object;
}
-EAPI Eina_Bool
-edje_object_part_geometry_get(const Evas_Object *obj, const char *part, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h )
+EOLIAN Eina_Bool
+_edje_part_geometry_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do((Eo *)obj, edje_obj_part_geometry_get(part, x, y, w, h, &ret));
- return ret;
-}
-
-void
-_part_geometry_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Evas_Coord *x = va_arg(*list, Evas_Coord *);
- Evas_Coord *y = va_arg(*list, Evas_Coord *);
- Evas_Coord *w = va_arg(*list, Evas_Coord *);
- Evas_Coord *h = va_arg(*list, Evas_Coord *);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- if (ret) *ret = EINA_FALSE;
-
- Edje *ed = (Edje *)_pd;
Edje_Real_Part *rp;
if ((!ed) || (!part))
@@ -1198,7 +1003,7 @@ _part_geometry_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
if (y) *y = 0;
if (w) *w = 0;
if (h) *h = 0;
- return;
+ return EINA_FALSE;
}
/* Need to recalc before providing the object. */
@@ -1211,46 +1016,27 @@ _part_geometry_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
if (y) *y = 0;
if (w) *w = 0;
if (h) *h = 0;
- return;
+ return EINA_FALSE;
}
if (x) *x = rp->x;
if (y) *y = rp->y;
if (w) *w = rp->w;
if (h) *h = rp->h;
- if (ret) *ret = EINA_TRUE;
+
+ return EINA_TRUE;
}
-EAPI void
-edje_object_item_provider_set(Evas_Object *obj, Edje_Item_Provider_Cb func, void *data)
+EOLIAN void
+_edje_item_provider_set(Eo *obj EINA_UNUSED, Edje *ed, Edje_Item_Provider_Cb func, void *data)
{
- if (!obj) return;
- eo_do(obj, edje_obj_item_provider_set(func, data));
-}
-
-void
-_item_provider_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- Edje_Item_Provider_Cb func = va_arg(*list, Edje_Item_Provider_Cb);
- void *data = va_arg(*list, void *);
- Edje *ed = _pd;
ed->item_provider.func = func;
ed->item_provider.data = data;
}
/* FIXDOC: New Function */
-EAPI void
-edje_object_text_change_cb_set(Evas_Object *obj, Edje_Text_Change_Cb func, void *data)
+EOLIAN void
+_edje_text_change_cb_set(Eo *obj EINA_UNUSED, Edje *ed, Edje_Text_Change_Cb func, void *data)
{
- if (!obj) return;
- eo_do(obj, edje_obj_text_change_cb_set(func, data));
-}
-
-void
-_text_change_cb_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- Edje_Text_Change_Cb func = va_arg(*list, Edje_Text_Change_Cb);
- void *data = va_arg(*list, void *);
- Edje *ed = _pd;
unsigned int i;
ed->text_change.func = func;
@@ -1337,20 +1123,9 @@ _edje_object_part_text_raw_append(Edje *ed, Evas_Object *obj, Edje_Real_Part *rp
return EINA_TRUE;
}
-EAPI void
-edje_object_part_text_style_user_push(Evas_Object *obj, const char *part,
- const char *style)
+EOLIAN void
+_edje_part_text_style_user_push(Eo *obj EINA_UNUSED, Edje *ed, const char *part, const char *style)
{
- if (!obj) return;
- eo_do(obj, edje_obj_part_text_style_user_push(part, style));
-}
-
-void
-_part_text_style_user_push(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- const char *style = va_arg(*list, const char *);
- Edje *ed = _pd;
Edje_Real_Part *rp;
Evas_Textblock_Style *ts;
@@ -1370,18 +1145,9 @@ _part_text_style_user_push(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
_edje_recalc(ed);
}
-EAPI void
-edje_object_part_text_style_user_pop(Evas_Object *obj, const char *part)
+EOLIAN void
+_edje_part_text_style_user_pop(Eo *obj EINA_UNUSED, Edje *ed, const char *part)
{
- if (!obj) return;
- eo_do(obj, edje_obj_part_text_style_user_pop(part));
-}
-
-void
-_part_text_style_user_pop(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Edje *ed = _pd;
Edje_Real_Part *rp;
if ((!ed) || (!part)) return;
@@ -1397,33 +1163,22 @@ _part_text_style_user_pop(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
_edje_recalc(ed);
}
-EAPI const char *
-edje_object_part_text_style_user_peek(const Evas_Object *obj, const char *part)
+EOLIAN const char*
+_edje_part_text_style_user_peek(Eo *obj EINA_UNUSED, Edje *ed, const char *part)
{
- if (!obj) return NULL;
- const char *ret = NULL;
- eo_do((Eo *)obj, edje_obj_part_text_style_user_peek(part, &ret));
- return ret;
-}
-
-void
-_part_text_style_user_peek(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- const char **ret = va_arg(*list, const char **);
- if (ret) *ret = NULL;
- Edje *ed = _pd;
Edje_Real_Part *rp;
const Evas_Textblock_Style *ts;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return NULL;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
- if (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK) return;
+ if (!rp) return NULL;
+ if (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK) return NULL;
ts = evas_object_textblock_style_user_peek(rp->object);
if (ts)
- if (ret) *ret = evas_textblock_style_get(ts);
+ return evas_textblock_style_get(ts);
+
+ return NULL;
}
static void
@@ -1452,117 +1207,72 @@ _edje_user_define_string(Edje *ed, const char *part, const char *raw_text)
eud->u.string.text = raw_text;
}
-EAPI Eina_Bool
-edje_object_part_text_set(Evas_Object *obj, const char *part, const char *text)
+EOLIAN Eina_Bool
+_edje_part_text_set(Eo *obj, Edje *ed, const char *part, const char *text)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do(obj, edje_obj_part_text_set(part, text, &ret));
- return ret;
-}
-
-void
-_part_text_set(Eo *obj, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- const char *text = va_arg(*list, const char *);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- if (ret) *ret = EINA_FALSE;
- Edje *ed = _pd;
Edje_Real_Part *rp;
- Eina_Bool r;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return EINA_FALSE;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
+ if (!rp) return EINA_FALSE;
if ((rp->part->type != EDJE_PART_TYPE_TEXT) &&
- (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK)) return;
+ (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK)) return EINA_FALSE;
if ((rp->type != EDJE_RP_TYPE_TEXT) ||
(!rp->typedata.text))
{
- if (ret) *ret = EINA_TRUE;
- return;
+ return EINA_TRUE;
}
- r = _edje_object_part_text_raw_set(ed, obj, rp, part, text);
+ return _edje_object_part_text_raw_set(ed, obj, rp, part, text);
_edje_user_define_string(ed, part, rp->typedata.text->text);
- if (ret) *ret = r;
}
-EAPI const char *
-edje_object_part_text_get(const Evas_Object *obj, const char *part)
+EOLIAN const char*
+_edje_part_text_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part)
{
- if (!obj) return NULL;
- const char *ret = NULL;
- eo_do((Eo *)obj, edje_obj_part_text_get(part, &ret));
- return ret;
-}
-
-void
-_part_text_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- const char **ret = va_arg(*list, const char **);
- *ret = NULL;
- Edje *ed = (Edje *)_pd;
Edje_Real_Part *rp;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return NULL;
/* Need to recalc before providing the object. */
_edje_recalc_do(ed);
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
+ if (!rp) return NULL;
if ((rp->type != EDJE_RP_TYPE_TEXT) ||
- (!rp->typedata.text)) return;
+ (!rp->typedata.text)) return NULL;
if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
{
- *ret = _edje_entry_text_get(rp);
- return;
+ return _edje_entry_text_get(rp);
}
else
{
if (rp->part->type == EDJE_PART_TYPE_TEXT)
{
- *ret = rp->typedata.text->text;
- return;
+ return rp->typedata.text->text;
}
if (rp->part->type == EDJE_PART_TYPE_TEXTBLOCK)
{
- *ret = evas_object_textblock_text_markup_get(rp->object);
- return;
+ return evas_object_textblock_text_markup_get(rp->object);
}
}
+
+ return NULL;
}
-EAPI Eina_Bool
-edje_object_part_text_escaped_set(Evas_Object *obj, const char *part, const char *text)
+EOLIAN Eina_Bool
+_edje_part_text_escaped_set(Eo *obj, Edje *ed, const char *part, const char *text)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do(obj, edje_obj_part_text_escaped_set(part, text, &ret));
- return ret;
-}
-
-void
-_part_text_escaped_set(Eo *obj, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- const char *text = va_arg(*list, const char *);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- if (ret) *ret = EINA_FALSE;
- Edje *ed = _pd;
Edje_Real_Part *rp;
Eina_Bool int_ret;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return EINA_FALSE;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
+ if (!rp) return EINA_FALSE;
if ((rp->type != EDJE_RP_TYPE_TEXT) ||
- (!rp->typedata.text)) return;
+ (!rp->typedata.text)) return EINA_FALSE;
if (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK &&
rp->part->type != EDJE_PART_TYPE_TEXT)
- return;
+ return EINA_FALSE;
if ((rp->part->type == EDJE_PART_TYPE_TEXT) && (text))
{
Eina_Strbuf *sbuf;
@@ -1616,14 +1326,13 @@ _part_text_escaped_set(Eo *obj, void *_pd, va_list *list)
int_ret = _edje_object_part_text_raw_set(ed, obj, rp, part, eina_strbuf_string_get(sbuf));
_edje_user_define_string(ed, part, rp->typedata.text->text);
eina_strbuf_free(sbuf);
- if (ret) *ret = int_ret;
- return;
+ return int_ret;
}
int_ret = _edje_object_part_text_raw_set(ed, obj, rp, part, text);
_edje_user_define_string(ed, part, rp->typedata.text->text);
- if (ret) *ret = int_ret;
-}
+ return int_ret;
+}
char *
_edje_text_escape(const char *text)
@@ -1733,31 +1442,17 @@ _edje_text_unescape(const char *text)
return ret;
}
-EAPI Eina_Bool
-edje_object_part_text_unescaped_set(Evas_Object *obj, const char *part, const char *text_to_escape)
+EOLIAN Eina_Bool
+_edje_part_text_unescaped_set(Eo *obj, Edje *ed, const char *part, const char *text_to_escape)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do(obj, edje_obj_part_text_unescaped_set(part, text_to_escape, &ret));
- return ret;
-}
-
-void
-_part_text_unescaped_set(Eo *obj, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- const char *text_to_escape = va_arg(*list, const char *);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- Edje *ed = _pd;
Edje_Real_Part *rp;
Eina_Bool int_ret = EINA_FALSE;
- if (ret) *ret = EINA_FALSE;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return EINA_FALSE;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
+ if (!rp) return EINA_FALSE;
if ((rp->type != EDJE_RP_TYPE_TEXT) ||
- (!rp->typedata.text)) return;
+ (!rp->typedata.text)) return EINA_FALSE;
if (rp->part->type == EDJE_PART_TYPE_TEXT)
int_ret = _edje_object_part_text_raw_set(ed, obj, rp, part, text_to_escape);
else if (rp->part->type == EDJE_PART_TYPE_TEXTBLOCK)
@@ -1768,95 +1463,62 @@ _part_text_unescaped_set(Eo *obj, void *_pd, va_list *list)
free(text);
}
_edje_user_define_string(ed, part, rp->typedata.text->text);
- if (ret) *ret = int_ret;
+
+ return int_ret;
}
-EAPI char *
-edje_object_part_text_unescaped_get(const Evas_Object *obj, const char *part)
+EOLIAN char*
+_edje_part_text_unescaped_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part)
{
- if (!obj) return NULL;
- char *ret = NULL;
- eo_do((Eo *)obj, edje_obj_part_text_unescaped_get(part, &ret));
- return ret;
-}
-
-void
-_part_text_unescaped_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- char **ret = va_arg(*list, char **);
- Edje *ed = (Edje *)_pd;
Edje_Real_Part *rp;
- *ret = NULL;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return NULL;
/* Need to recalc before providing the object. */
_edje_recalc_do(ed);
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
+ if (!rp) return NULL;
if ((rp->type != EDJE_RP_TYPE_TEXT) ||
- (!rp->typedata.text)) return;
+ (!rp->typedata.text)) return NULL;
if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
{
const char *t = _edje_entry_text_get(rp);
- *ret = _edje_text_unescape(t);
- return;
+ return _edje_text_unescape(t);
}
else
{
if (rp->part->type == EDJE_PART_TYPE_TEXT)
{
- *ret = strdup(rp->typedata.text->text);
- return;
+ return strdup(rp->typedata.text->text);
}
if (rp->part->type == EDJE_PART_TYPE_TEXTBLOCK)
{
const char *t = evas_object_textblock_text_markup_get(rp->object);
- *ret = _edje_text_unescape(t);
- return;
+ return _edje_text_unescape(t);
}
}
+
+ return NULL;
}
-EAPI const char *
-edje_object_part_text_selection_get(const Evas_Object *obj, const char *part)
+EOLIAN const char*
+_edje_part_text_selection_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part)
{
- if (!obj) return NULL;
- const char* ret = NULL;
- eo_do((Eo *)obj, edje_obj_part_text_selection_get(part, &ret));
- return ret;
-}
-
-void
-_part_text_selection_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- const char **ret = va_arg(*list, const char **);
- Edje *ed = _pd;
Edje_Real_Part *rp;
- *ret = NULL;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return NULL;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
+ if (!rp) return NULL;
if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
- *ret = _edje_entry_selection_get(rp);
+ return _edje_entry_selection_get(rp);
+
+ return NULL;
}
-EAPI void
-edje_object_part_text_select_none(const Evas_Object *obj, const char *part)
+EOLIAN void
+_edje_part_text_select_none(Eo *obj EINA_UNUSED, Edje *ed, const char *part)
{
- if (!obj) return;
- eo_do((Eo *)obj, edje_obj_part_text_select_none(part));
-}
-
-void
-_part_text_select_none(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Edje *ed = _pd;
Edje_Real_Part *rp;
if ((!ed) || (!part)) return;
@@ -1866,18 +1528,9 @@ _part_text_select_none(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
_edje_entry_select_none(rp);
}
-EAPI void
-edje_object_part_text_select_all(const Evas_Object *obj, const char *part)
+EOLIAN void
+_edje_part_text_select_all(Eo *obj EINA_UNUSED, Edje *ed, const char *part)
{
- if (!obj) return;
- eo_do((Eo *)obj, edje_obj_part_text_select_all(part));
-}
-
-void
-_part_text_select_all(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Edje *ed = _pd;
Edje_Real_Part *rp;
if ((!ed) || (!part)) return;
@@ -1887,19 +1540,9 @@ _part_text_select_all(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
_edje_entry_select_all(rp);
}
-EAPI void
-edje_object_part_text_insert(Evas_Object *obj, const char *part, const char *text)
+EOLIAN void
+_edje_part_text_insert(Eo *obj, Edje *ed, const char *part, const char *text)
{
- if (!obj) return;
- eo_do(obj, edje_obj_part_text_insert(part, text));
-}
-
-void
-_part_text_insert(Eo *obj, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- const char *text = va_arg(*list, const char *);
- Edje *ed = _pd;
Edje_Real_Part *rp;
if ((!ed) || (!part)) return;
@@ -1919,19 +1562,9 @@ _part_text_insert(Eo *obj, void *_pd, va_list *list)
ed->text_change.func(ed->text_change.data, obj, part);
}
-EAPI void
-edje_object_part_text_append(Evas_Object *obj, const char *part, const char *text)
+EOLIAN void
+_edje_part_text_append(Eo *obj, Edje *ed, const char *part, const char *text)
{
- if (!obj) return;
- eo_do(obj, edje_obj_part_text_append(part, text));
-}
-
-void
-_part_text_append(Eo *obj, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- const char *text = va_arg(*list, const char *);
- Edje *ed = _pd;
Edje_Real_Part *rp;
if ((!ed) || (!part)) return;
@@ -1950,131 +1583,67 @@ _part_text_append(Eo *obj, void *_pd, va_list *list)
ed->text_change.func(ed->text_change.data, obj, part);
}
-EAPI const Eina_List *
-edje_object_part_text_anchor_list_get(const Evas_Object *obj, const char *part)
+EOLIAN const Eina_List*
+_edje_part_text_anchor_list_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part)
{
- if (!obj) return NULL;
- const Eina_List *ret = NULL;
- eo_do((Eo *)obj, edje_obj_part_text_anchor_list_get(part, &ret));
- return ret;
-}
-
-void
-_part_text_anchor_list_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- const Eina_List **ret = va_arg(*list, const Eina_List **);
- Edje *ed = _pd;
Edje_Real_Part *rp;
- *ret = NULL;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return NULL;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
+ if (!rp) return NULL;
if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
- *ret = _edje_entry_anchors_list(rp);
+ return _edje_entry_anchors_list(rp);
+
+ return NULL;
}
-EAPI const Eina_List *
-edje_object_part_text_anchor_geometry_get(const Evas_Object *obj, const char *part, const char *anchor)
+EOLIAN const Eina_List*
+_edje_part_text_anchor_geometry_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part, const char *anchor)
{
- if (!obj) return NULL;
- const Eina_List *ret = NULL;
- eo_do((Eo *)obj, edje_obj_part_text_anchor_geometry_get(part, anchor, &ret));
- return ret;
-}
-
-void
-_part_text_anchor_geometry_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- const char *anchor = va_arg(*list, const char *);
- const Eina_List **ret = va_arg(*list, const Eina_List **);
- Edje *ed = _pd;
Edje_Real_Part *rp;
- *ret = NULL;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return NULL;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
+ if (!rp) return NULL;
if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
- *ret = _edje_entry_anchor_geometry_get(rp, anchor);
+ return _edje_entry_anchor_geometry_get(rp, anchor);
+
+ return NULL;
}
-EAPI const Eina_List *
-edje_object_part_text_item_list_get(const Evas_Object *obj, const char *part)
+EOLIAN const Eina_List*
+_edje_part_text_item_list_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part)
{
- if (!obj) return NULL;
- const Eina_List *ret = NULL;
- eo_do((Eo *)obj, edje_obj_part_text_item_list_get(part, &ret));
- return ret;
-}
-
-void
-_part_text_item_list_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- const Eina_List **ret = va_arg(*list, const Eina_List **);
- Edje *ed = _pd;
Edje_Real_Part *rp;
- *ret = NULL;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return NULL;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
+ if (!rp) return NULL;
if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
- *ret = _edje_entry_items_list(rp);
+ return _edje_entry_items_list(rp);
+
+ return NULL;
}
-EAPI Eina_Bool
-edje_object_part_text_item_geometry_get(const Evas_Object *obj, const char *part, const char *item, Evas_Coord *cx, Evas_Coord *cy, Evas_Coord *cw, Evas_Coord *ch)
+EOLIAN Eina_Bool
+_edje_part_text_item_geometry_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part, const char *item, Evas_Coord *cx, Evas_Coord *cy, Evas_Coord *cw, Evas_Coord *ch)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do((Eo *)obj, edje_obj_part_text_item_geometry_get(part, item, cx, cy, cw, ch, &ret));
- return ret;
-}
-
-void
-_part_text_item_geometry_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- const char *item = va_arg(*list, const char *);
- Evas_Coord *cx = va_arg(*list, Evas_Coord *);
- Evas_Coord *cy = va_arg(*list, Evas_Coord *);
- Evas_Coord *cw = va_arg(*list, Evas_Coord *);
- Evas_Coord *ch = va_arg(*list, Evas_Coord *);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- Edje *ed = _pd;
Edje_Real_Part *rp;
- if (ret) *ret = EINA_FALSE;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return EINA_FALSE;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
+ if (!rp) return EINA_FALSE;
if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
{
- Eina_Bool int_ret = _edje_entry_item_geometry_get(rp, item, cx, cy, cw, ch);
- if (ret) *ret = int_ret;
+ return _edje_entry_item_geometry_get(rp, item, cx, cy, cw, ch);
}
+
+ return EINA_FALSE;
}
-EAPI void
-edje_object_part_text_cursor_geometry_get(const Evas_Object *obj, const char *part, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h)
+EOLIAN void
+_edje_part_text_cursor_geometry_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h)
{
- if (!obj) return;
- eo_do((Eo *)obj, edje_obj_part_text_cursor_geometry_get(part, x, y, w, h));
-}
-
-void
-_part_text_cursor_geometry_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Evas_Coord *x = va_arg(*list, Evas_Coord *);
- Evas_Coord *y = va_arg(*list, Evas_Coord *);
- Evas_Coord *w = va_arg(*list, Evas_Coord *);
- Evas_Coord *h = va_arg(*list, Evas_Coord *);
- Edje *ed = _pd;
Edje_Real_Part *rp;
if (x) *x = 0;
@@ -2092,19 +1661,9 @@ _part_text_cursor_geometry_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
}
}
-EAPI void
-edje_object_part_text_user_insert(const Evas_Object *obj, const char *part, const char *text)
+EOLIAN void
+_edje_part_text_user_insert(Eo *obj EINA_UNUSED, Edje *ed, const char *part, const char *text)
{
- if (!obj) return;
- eo_do((Eo *)obj, edje_obj_part_text_user_insert(part, text));
-}
-
-void
-_part_text_user_insert(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- const char *text = va_arg(*list, const char *);
- Edje *ed = _pd;
Edje_Real_Part *rp;
if ((!ed) || (!part)) return;
@@ -2114,19 +1673,9 @@ _part_text_user_insert(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
_edje_entry_user_insert(rp, text);
}
-EAPI void
-edje_object_part_text_select_allow_set(const Evas_Object *obj, const char *part, Eina_Bool allow)
+EOLIAN void
+_edje_part_text_select_allow_set(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Eina_Bool allow)
{
- if (!obj) return;
- eo_do((Eo *)obj, edje_obj_part_text_select_allow_set(part, allow));
-}
-
-void
-_part_text_select_allow_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Eina_Bool allow = va_arg(*list, int);
- Edje *ed = _pd;
Edje_Real_Part *rp;
if ((!ed) || (!part)) return;
@@ -2136,18 +1685,9 @@ _part_text_select_allow_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
_edje_entry_select_allow_set(rp, allow);
}
-EAPI void
-edje_object_part_text_select_abort(const Evas_Object *obj, const char *part)
+EOLIAN void
+_edje_part_text_select_abort(Eo *obj EINA_UNUSED, Edje *ed, const char *part)
{
- if (!obj) return;
- eo_do((Eo *)obj, edje_obj_part_text_select_abort(part));
-}
-
-void
-_part_text_select_abort(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Edje *ed = _pd;
Edje_Real_Part *rp;
if ((!ed) || (!part)) return;
@@ -2157,18 +1697,9 @@ _part_text_select_abort(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
_edje_entry_select_abort(rp);
}
-EAPI void
-edje_object_part_text_select_begin(const Evas_Object *obj, const char *part)
+EOLIAN void
+_edje_part_text_select_begin(Eo *obj EINA_UNUSED, Edje *ed, const char *part)
{
- if (!obj) return;
- eo_do((Eo *)obj, edje_obj_part_text_select_begin(part));
-}
-
-void
-_part_text_select_begin(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Edje *ed = _pd;
Edje_Real_Part *rp;
if ((!ed) || (!part)) return;
@@ -2178,18 +1709,9 @@ _part_text_select_begin(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
_edje_entry_select_begin(rp);
}
-EAPI void
-edje_object_part_text_select_extend(const Evas_Object *obj, const char *part)
+EOLIAN void
+_edje_part_text_select_extend(Eo *obj EINA_UNUSED, Edje *ed, const char *part)
{
- if (!obj) return;
- eo_do((Eo *)obj, edje_obj_part_text_select_extend(part));
-}
-
-void
-_part_text_select_extend(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Edje *ed = _pd;
Edje_Real_Part *rp;
if ((!ed) || (!part)) return;
@@ -2199,162 +1721,89 @@ _part_text_select_extend(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
_edje_entry_select_extend(rp);
}
-EAPI void *
-edje_object_part_text_imf_context_get(const Evas_Object *obj, const char *part)
+EOLIAN void*
+_edje_part_text_imf_context_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part)
{
- if (!obj) return NULL;
- void *ret = NULL;
- eo_do((Eo *)obj, edje_obj_part_text_imf_context_get(part, &ret));
- return ret;
-}
-
-void
-_part_text_imf_context_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- void **ret = va_arg(*list, void **);
- Edje *ed = _pd;
Edje_Real_Part *rp;
- *ret = NULL;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return NULL;
rp = _edje_real_part_recursive_get(&ed, (char *)part);
- if (!rp) return;
+ if (!rp) return NULL;
if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
- *ret = _edje_entry_imf_context_get(rp);
+ return _edje_entry_imf_context_get(rp);
+
+ return NULL;
}
-EAPI Eina_Bool
-edje_object_part_text_cursor_next(Evas_Object *obj, const char *part, Edje_Cursor cur)
+EOLIAN Eina_Bool
+_edje_part_text_cursor_next(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Edje_Cursor cur)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do(obj, edje_obj_part_text_cursor_next(part, cur, &ret));
- return ret;
-}
-
-void
-_part_text_cursor_next(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Edje_Cursor cur = va_arg(*list, Edje_Cursor);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- Edje *ed = _pd;
Edje_Real_Part *rp;
- if (ret) *ret = EINA_FALSE;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return EINA_FALSE;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
+ if (!rp) return EINA_FALSE;
if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
{
- Eina_Bool int_ret = _edje_entry_cursor_next(rp, cur);
- if (ret) *ret = int_ret;
+ return _edje_entry_cursor_next(rp, cur);
}
+
+ return EINA_FALSE;
}
-EAPI Eina_Bool
-edje_object_part_text_cursor_prev(Evas_Object *obj, const char *part, Edje_Cursor cur)
+EOLIAN Eina_Bool
+_edje_part_text_cursor_prev(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Edje_Cursor cur)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do(obj, edje_obj_part_text_cursor_prev(part, cur, &ret));
- return ret;
-}
-
-void
-_part_text_cursor_prev(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Edje_Cursor cur = va_arg(*list, Edje_Cursor);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- Edje *ed = _pd;
Edje_Real_Part *rp;
- if (ret) *ret = EINA_FALSE;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return EINA_FALSE;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
+ if (!rp) return EINA_FALSE;
if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
{
- Eina_Bool int_ret = _edje_entry_cursor_prev(rp, cur);
- if (ret) *ret = int_ret;
+ return _edje_entry_cursor_prev(rp, cur);
}
+
+ return EINA_FALSE;
}
-EAPI Eina_Bool
-edje_object_part_text_cursor_up(Evas_Object *obj, const char *part, Edje_Cursor cur)
+EOLIAN Eina_Bool
+_edje_part_text_cursor_up(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Edje_Cursor cur)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do(obj, edje_obj_part_text_cursor_up(part, cur, &ret));
- return ret;
-}
-
-void
-_part_text_cursor_up(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Edje_Cursor cur = va_arg(*list, Edje_Cursor);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- Edje *ed = _pd;
Edje_Real_Part *rp;
- if (ret) *ret = EINA_FALSE;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return EINA_FALSE;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
+ if (!rp) return EINA_FALSE;
if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
{
- Eina_Bool int_ret = _edje_entry_cursor_up(rp, cur);
- if (ret) *ret = int_ret;
+ return _edje_entry_cursor_up(rp, cur);
}
+
+ return EINA_FALSE;
}
-EAPI Eina_Bool
-edje_object_part_text_cursor_down(Evas_Object *obj, const char *part, Edje_Cursor cur)
+EOLIAN Eina_Bool
+_edje_part_text_cursor_down(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Edje_Cursor cur)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do(obj, edje_obj_part_text_cursor_down(part, cur, &ret));
- return ret;
-}
-
-void
-_part_text_cursor_down(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Edje_Cursor cur = va_arg(*list, Edje_Cursor);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- Edje *ed = _pd;
Edje_Real_Part *rp;
- if (ret) *ret = EINA_FALSE;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return EINA_FALSE;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
+ if (!rp) return EINA_FALSE;
if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
{
- Eina_Bool int_ret = _edje_entry_cursor_down(rp, cur);
- if (ret) *ret = int_ret;
+ return _edje_entry_cursor_down(rp, cur);
}
+
+ return EINA_FALSE;
}
-EAPI void
-edje_object_part_text_cursor_begin_set(Evas_Object *obj, const char *part, Edje_Cursor cur)
+EOLIAN void
+_edje_part_text_cursor_begin_set(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Edje_Cursor cur)
{
- if (!obj) return;
- eo_do(obj, edje_obj_part_text_cursor_begin_set(part, cur));
-}
-
-void
-_part_text_cursor_begin_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Edje_Cursor cur = va_arg(*list, Edje_Cursor);
- Edje *ed = _pd;
Edje_Real_Part *rp;
if ((!ed) || (!part)) return;
@@ -2366,19 +1815,9 @@ _part_text_cursor_begin_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
}
}
-EAPI void
-edje_object_part_text_cursor_end_set(Evas_Object *obj, const char *part, Edje_Cursor cur)
+EOLIAN void
+_edje_part_text_cursor_end_set(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Edje_Cursor cur)
{
- if (!obj) return;
- eo_do(obj, edje_obj_part_text_cursor_end_set(part, cur));
-}
-
-void
-_part_text_cursor_end_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Edje_Cursor cur = va_arg(*list, Edje_Cursor);
- Edje *ed = _pd;
Edje_Real_Part *rp;
if ((!ed) || (!part)) return;
@@ -2390,20 +1829,9 @@ _part_text_cursor_end_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
}
}
-EAPI void
-edje_object_part_text_cursor_copy(Evas_Object *obj, const char *part, Edje_Cursor src, Edje_Cursor dst)
+EOLIAN void
+_edje_part_text_cursor_copy(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Edje_Cursor src, Edje_Cursor dst)
{
- if (!obj) return;
- eo_do(obj, edje_obj_part_text_cursor_copy(part, src, dst));
-}
-
-void
-_part_text_cursor_copy(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Edje_Cursor src = va_arg(*list, Edje_Cursor);
- Edje_Cursor dst = va_arg(*list, Edje_Cursor);
- Edje *ed = _pd;
Edje_Real_Part *rp;
if ((!ed) || (!part)) return;
@@ -2415,19 +1843,9 @@ _part_text_cursor_copy(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
}
}
-EAPI void
-edje_object_part_text_cursor_line_begin_set(Evas_Object *obj, const char *part, Edje_Cursor cur)
+EOLIAN void
+_edje_part_text_cursor_line_begin_set(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Edje_Cursor cur)
{
- if (!obj) return;
- eo_do(obj, edje_obj_part_text_cursor_line_begin_set(part, cur));
-}
-
-void
-_part_text_cursor_line_begin_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Edje_Cursor cur = va_arg(*list, Edje_Cursor);
- Edje *ed = _pd;
Edje_Real_Part *rp;
if ((!ed) || (!part)) return;
@@ -2439,19 +1857,9 @@ _part_text_cursor_line_begin_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
}
}
-EAPI void
-edje_object_part_text_cursor_line_end_set(Evas_Object *obj, const char *part, Edje_Cursor cur)
+EOLIAN void
+_edje_part_text_cursor_line_end_set(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Edje_Cursor cur)
{
- if (!obj) return;
- eo_do(obj, edje_obj_part_text_cursor_line_end_set(part, cur));
-}
-
-void
-_part_text_cursor_line_end_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Edje_Cursor cur = va_arg(*list, Edje_Cursor);
- Edje *ed = _pd;
Edje_Real_Part *rp;
if ((!ed) || (!part)) return;
@@ -2463,137 +1871,72 @@ _part_text_cursor_line_end_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
}
}
-EAPI Eina_Bool
-edje_object_part_text_cursor_coord_set(Evas_Object *obj, const char *part,
- Edje_Cursor cur, Evas_Coord x,
- Evas_Coord y)
+EOLIAN Eina_Bool
+_edje_part_text_cursor_coord_set(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Edje_Cursor cur, Evas_Coord x, Evas_Coord y)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do(obj, edje_obj_part_text_cursor_coord_set(part, cur, x, y, &ret));
- return ret;
-}
-
-void
-_part_text_cursor_coord_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Edje_Cursor cur = va_arg(*list, Edje_Cursor);
- Evas_Coord x = va_arg(*list, Evas_Coord);
- Evas_Coord y = va_arg(*list, Evas_Coord);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- Edje *ed = _pd;
Edje_Real_Part *rp;
- if (ret) *ret = EINA_FALSE;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return EINA_FALSE;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
+ if (!rp) return EINA_FALSE;
if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
{
- Eina_Bool int_ret = _edje_entry_cursor_coord_set(rp, cur, x, y);
- if (ret) *ret = int_ret;
+ return _edje_entry_cursor_coord_set(rp, cur, x, y);
}
+
+ return EINA_FALSE;
}
-EAPI Eina_Bool
-edje_object_part_text_cursor_is_format_get(const Evas_Object *obj, const char *part, Edje_Cursor cur)
+EOLIAN Eina_Bool
+_edje_part_text_cursor_is_format_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Edje_Cursor cur)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do((Eo *)obj, edje_obj_part_text_cursor_is_format_get(part, cur, &ret));
- return ret;
-}
-
-void
-_part_text_cursor_is_format_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Edje_Cursor cur = va_arg(*list, Edje_Cursor);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- Edje *ed = _pd;
Edje_Real_Part *rp;
- *ret = EINA_FALSE;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return EINA_FALSE;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
+ if (!rp) return EINA_FALSE;
if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
{
- *ret = _edje_entry_cursor_is_format_get(rp, cur);
+ return _edje_entry_cursor_is_format_get(rp, cur);
}
+ return EINA_FALSE;
}
-EAPI Eina_Bool
-edje_object_part_text_cursor_is_visible_format_get(const Evas_Object *obj, const char *part, Edje_Cursor cur)
+EOLIAN Eina_Bool
+_edje_part_text_cursor_is_visible_format_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Edje_Cursor cur)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do((Eo *)obj, edje_obj_part_text_cursor_is_visible_format_get(part, cur, &ret));
- return ret;
-}
-
-void
-_part_text_cursor_is_visible_format_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Edje_Cursor cur = va_arg(*list, Edje_Cursor);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- Edje *ed = _pd;
Edje_Real_Part *rp;
- *ret = EINA_FALSE;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return EINA_FALSE;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
+ if (!rp) return EINA_FALSE;
if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
{
- *ret = _edje_entry_cursor_is_visible_format_get(rp, cur);
+ return _edje_entry_cursor_is_visible_format_get(rp, cur);
}
+
+ return EINA_FALSE;
}
-EAPI char *
-edje_object_part_text_cursor_content_get(const Evas_Object *obj, const char *part, Edje_Cursor cur)
+EOLIAN char*
+_edje_part_text_cursor_content_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Edje_Cursor cur)
{
- if (!obj) return NULL;
- char *ret = NULL;
- eo_do((Eo *)obj, edje_obj_part_text_cursor_content_get(part, cur, &ret));
- return ret;
-}
-
-void
-_part_text_cursor_content_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Edje_Cursor cur = va_arg(*list, Edje_Cursor);
- char **ret = va_arg(*list, char **);
- Edje *ed = _pd;
Edje_Real_Part *rp;
- *ret = NULL;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return NULL;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
+ if (!rp) return NULL;
if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
{
- *ret = _edje_entry_cursor_content_get(rp, cur);
+ return _edje_entry_cursor_content_get(rp, cur);
}
+
+ return NULL;
}
-EAPI void
-edje_object_part_text_cursor_pos_set(Evas_Object *obj, const char *part, Edje_Cursor cur, int pos)
+EOLIAN void
+_edje_part_text_cursor_pos_set(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Edje_Cursor cur, int pos)
{
- if (!obj) return;
- eo_do(obj, edje_obj_part_text_cursor_pos_set(part, cur, pos));
-}
-
-void
-_part_text_cursor_pos_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Edje_Cursor cur = va_arg(*list, Edje_Cursor);
- int pos = va_arg(*list, int);
- Edje *ed = _pd;
Edje_Real_Part *rp;
if ((!ed) || (!part)) return;
@@ -2605,46 +1948,27 @@ _part_text_cursor_pos_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
}
}
-EAPI int
-edje_object_part_text_cursor_pos_get(const Evas_Object *obj, const char *part, Edje_Cursor cur)
+EOLIAN int
+_edje_part_text_cursor_pos_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Edje_Cursor cur)
{
- if (!obj) return 0;
int ret;
- eo_do((Eo *)obj, edje_obj_part_text_cursor_pos_get(part, cur, &ret));
+ Edje_Real_Part *rp;
+ ret = 0;
+
+ if ((!ed) || (!part)) return ret;
+ rp = _edje_real_part_recursive_get(&ed, part);
+ if (!rp) return ret;
+ if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
+ {
+ ret = _edje_entry_cursor_pos_get(rp, cur);
+ }
+
return ret;
}
-void
-_part_text_cursor_pos_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+EOLIAN void
+_edje_part_text_imf_context_reset(Eo *obj EINA_UNUSED, Edje *ed, const char *part)
{
- const char *part = va_arg(*list, const char *);
- Edje_Cursor cur = va_arg(*list, Edje_Cursor);
- int *ret = va_arg(*list, int *);
- Edje *ed = _pd;
- Edje_Real_Part *rp;
- *ret = 0;
-
- if ((!ed) || (!part)) return;
- rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
- if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
- {
- *ret = _edje_entry_cursor_pos_get(rp, cur);
- }
-}
-
-EAPI void
-edje_object_part_text_imf_context_reset(const Evas_Object *obj, const char *part)
-{
- if (!obj) return;
- eo_do((Eo *)obj, edje_obj_part_text_imf_context_reset(part));
-}
-
-void
-_part_text_imf_context_reset(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Edje *ed = _pd;
Edje_Real_Part *rp;
if ((!ed) || (!part)) return;
@@ -2656,19 +1980,9 @@ _part_text_imf_context_reset(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
}
}
-EAPI void
-edje_object_part_text_input_panel_layout_set(Evas_Object *obj, const char *part, Edje_Input_Panel_Layout layout)
+EOLIAN void
+_edje_part_text_input_panel_layout_set(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Edje_Input_Panel_Layout layout)
{
- if (!obj) return;
- eo_do(obj, edje_obj_part_text_input_panel_layout_set(part, layout));
-}
-
-void
-_part_text_input_panel_layout_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Edje_Input_Panel_Layout layout = va_arg(*list, Edje_Input_Panel_Layout);
- Edje *ed = _pd;
Edje_Real_Part *rp;
if ((!ed) || (!part)) return;
@@ -2680,46 +1994,27 @@ _part_text_input_panel_layout_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
}
}
-EAPI Edje_Input_Panel_Layout
-edje_object_part_text_input_panel_layout_get(const Evas_Object *obj, const char *part)
+EOLIAN Edje_Input_Panel_Layout
+_edje_part_text_input_panel_layout_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part)
{
- if (!obj) return EDJE_INPUT_PANEL_LAYOUT_INVALID;
Edje_Input_Panel_Layout ret;
- eo_do((Eo *)obj, edje_obj_part_text_input_panel_layout_get(part, &ret));
+ Edje_Real_Part *rp;
+ ret = EDJE_INPUT_PANEL_LAYOUT_INVALID;
+
+ if ((!ed) || (!part)) return ret;
+ rp = _edje_real_part_recursive_get(&ed, part);
+ if (!rp) return ret;
+ if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
+ {
+ ret = _edje_entry_input_panel_layout_get(rp);
+ }
+
return ret;
}
-void
-_part_text_input_panel_layout_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+EOLIAN void
+_edje_part_text_input_panel_layout_variation_set(Eo *obj EINA_UNUSED, Edje *ed, const char *part, int variation)
{
- const char *part = va_arg(*list, const char *);
- Edje_Input_Panel_Layout *ret = va_arg(*list, Edje_Input_Panel_Layout *);
- Edje *ed = _pd;
- Edje_Real_Part *rp;
- *ret = EDJE_INPUT_PANEL_LAYOUT_INVALID;
-
- if ((!ed) || (!part)) return;
- rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
- if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
- {
- *ret = _edje_entry_input_panel_layout_get(rp);
- }
-}
-
-EAPI void
-edje_object_part_text_input_panel_layout_variation_set(Evas_Object *obj, const char *part, int variation)
-{
- eo_do((Eo *)obj, edje_obj_part_text_input_panel_variation_set(part, variation));
-}
-
-void
-_part_text_input_panel_layout_variation_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- int variation = va_arg(*list, int);
-
- Edje *ed = _pd;
Edje_Real_Part *rp;
if ((!ed) || (!part)) return;
@@ -2731,48 +2026,27 @@ _part_text_input_panel_layout_variation_set(Eo *obj EINA_UNUSED, void *_pd, va_l
}
}
-EAPI int
-edje_object_part_text_input_panel_layout_variation_get(const Evas_Object *obj, const char *part)
+EOLIAN int
+_edje_part_text_input_panel_layout_variation_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part)
{
- int ret = 0;
- if (obj)
- eo_do((Eo *)obj, edje_obj_part_text_input_panel_variation_get(part, &ret));
- return ret;
-}
+ int r;
-void
-_part_text_input_panel_layout_variation_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- int *r = va_arg(*list, int *);
-
- Edje *ed = _pd;
Edje_Real_Part *rp;
- if (*r) *r = 0;
- if ((!ed) || (!part)) return ;
+ r = 0;
+ if ((!ed) || (!part)) return r;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return ;
+ if (!rp) return r;
if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
{
- if (*r) *r = _edje_entry_input_panel_layout_variation_get(rp);
+ r = _edje_entry_input_panel_layout_variation_get(rp);
}
- return ;
+ return r;
}
-EAPI void
-edje_object_part_text_autocapital_type_set(Evas_Object *obj, const char *part, Edje_Text_Autocapital_Type autocapital_type)
+EOLIAN void
+_edje_part_text_autocapital_type_set(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Edje_Text_Autocapital_Type autocapital_type)
{
- if (!obj) return;
- eo_do(obj, edje_obj_part_text_autocapital_type_set(part, autocapital_type));
-}
-
-void
-_part_text_autocapital_type_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Edje_Text_Autocapital_Type autocapital_type = va_arg(*list, Edje_Text_Autocapital_Type);
- Edje *ed = _pd;
Edje_Real_Part *rp;
if ((!ed) || (!part)) return;
@@ -2784,46 +2058,27 @@ _part_text_autocapital_type_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
}
}
-EAPI Edje_Text_Autocapital_Type
-edje_object_part_text_autocapital_type_get(const Evas_Object *obj, const char *part)
+EOLIAN Edje_Text_Autocapital_Type
+_edje_part_text_autocapital_type_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part)
{
- if (!obj) return EDJE_TEXT_AUTOCAPITAL_TYPE_NONE;
Edje_Text_Autocapital_Type ret;
- eo_do((Eo *)obj, edje_obj_part_text_autocapital_type_get(part, &ret));
+ Edje_Real_Part *rp;
+ ret = EDJE_TEXT_AUTOCAPITAL_TYPE_NONE;
+
+ if ((!ed) || (!part)) return ret;
+ rp = _edje_real_part_recursive_get(&ed, part);
+ if (!rp) return ret;
+ if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
+ {
+ ret = _edje_entry_autocapital_type_get(rp);
+ }
+
return ret;
}
-void
-_part_text_autocapital_type_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+EOLIAN void
+_edje_part_text_prediction_allow_set(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Eina_Bool prediction)
{
- const char *part = va_arg(*list, const char *);
- Edje_Text_Autocapital_Type *ret = va_arg(*list, Edje_Text_Autocapital_Type *);
- Edje *ed = _pd;
- Edje_Real_Part *rp;
- *ret = EDJE_TEXT_AUTOCAPITAL_TYPE_NONE;
-
- if ((!ed) || (!part)) return;
- rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
- if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
- {
- *ret = _edje_entry_autocapital_type_get(rp);
- }
-}
-
-EAPI void
-edje_object_part_text_prediction_allow_set(Evas_Object *obj, const char *part, Eina_Bool prediction)
-{
- if (!obj) return;
- eo_do(obj, edje_obj_part_text_prediction_allow_set(part, prediction));
-}
-
-void
-_part_text_prediction_allow_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Eina_Bool prediction = va_arg(*list, int);
- Edje *ed = _pd;
Edje_Real_Part *rp;
if ((!ed) || (!part)) return;
@@ -2835,46 +2090,27 @@ _part_text_prediction_allow_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
}
}
-EAPI Eina_Bool
-edje_object_part_text_prediction_allow_get(const Evas_Object *obj, const char *part)
+EOLIAN Eina_Bool
+_edje_part_text_prediction_allow_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do((Eo *)obj, edje_obj_part_text_prediction_allow_get(part, &ret));
+ Eina_Bool ret;
+ Edje_Real_Part *rp;
+ ret = EINA_FALSE;
+
+ if ((!ed) || (!part)) return ret;
+ rp = _edje_real_part_recursive_get(&ed, part);
+ if (!rp) return ret;
+ if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
+ {
+ ret = _edje_entry_prediction_allow_get(rp);
+ }
+
return ret;
}
-void
-_part_text_prediction_allow_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+EOLIAN void
+_edje_part_text_input_panel_enabled_set(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Eina_Bool enabled)
{
- const char *part = va_arg(*list, const char *);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- Edje *ed = _pd;
- Edje_Real_Part *rp;
- *ret = EINA_FALSE;
-
- if ((!ed) || (!part)) return;
- rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
- if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
- {
- *ret = _edje_entry_prediction_allow_get(rp);
- }
-}
-
-EAPI void
-edje_object_part_text_input_panel_enabled_set(Evas_Object *obj, const char *part, Eina_Bool enabled)
-{
- if (!obj) return;
- eo_do(obj, edje_obj_part_text_input_panel_enabled_set(part, enabled));
-}
-
-void
-_part_text_input_panel_enabled_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Eina_Bool enabled = va_arg(*list, int);
- Edje *ed = _pd;
Edje_Real_Part *rp;
if ((!ed) || (!part)) return;
@@ -2886,45 +2122,27 @@ _part_text_input_panel_enabled_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list
}
}
-EAPI Eina_Bool
-edje_object_part_text_input_panel_enabled_get(const Evas_Object *obj, const char *part)
+EOLIAN Eina_Bool
+_edje_part_text_input_panel_enabled_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do((Eo *)obj, edje_obj_part_text_input_panel_enabled_get(part, &ret));
+ Eina_Bool ret;
+ Edje_Real_Part *rp;
+ ret = EINA_FALSE;
+
+ if ((!ed) || (!part)) return ret;
+ rp = _edje_real_part_recursive_get(&ed, part);
+ if (!rp) return ret;
+ if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
+ {
+ ret = _edje_entry_input_panel_enabled_get(rp);
+ }
+
return ret;
}
-void
-_part_text_input_panel_enabled_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+EOLIAN void
+_edje_part_text_input_panel_show(Eo *obj EINA_UNUSED, Edje *ed, const char *part)
{
- const char *part = va_arg(*list, const char *);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- Edje *ed = _pd;
- Edje_Real_Part *rp;
- *ret = EINA_FALSE;
-
- if ((!ed) || (!part)) return;
- rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
- if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
- {
- *ret = _edje_entry_input_panel_enabled_get(rp);
- }
-}
-
-EAPI void
-edje_object_part_text_input_panel_show(const Evas_Object *obj, const char *part)
-{
- if (!obj) return;
- eo_do((Eo *)obj, edje_obj_part_text_input_panel_show(part));
-}
-
-void
-_part_text_input_panel_show(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Edje *ed = _pd;
Edje_Real_Part *rp;
if ((!ed) || (!part)) return;
@@ -2934,18 +2152,9 @@ _part_text_input_panel_show(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
_edje_entry_input_panel_show(rp);
}
-EAPI void
-edje_object_part_text_input_panel_hide(const Evas_Object *obj, const char *part)
+EOLIAN void
+_edje_part_text_input_panel_hide(Eo *obj EINA_UNUSED, Edje *ed, const char *part)
{
- if (!obj) return;
- eo_do((Eo *)obj, edje_obj_part_text_input_panel_hide(part));
-}
-
-void
-_part_text_input_panel_hide(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Edje *ed = _pd;
Edje_Real_Part *rp;
if ((!ed) || (!part)) return;
@@ -2955,19 +2164,9 @@ _part_text_input_panel_hide(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
_edje_entry_input_panel_hide(rp);
}
-EAPI void
-edje_object_part_text_input_panel_language_set(Evas_Object *obj, const char *part, Edje_Input_Panel_Lang lang)
+EOLIAN void
+_edje_part_text_input_panel_language_set(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Edje_Input_Panel_Lang lang)
{
- if (!obj) return;
- eo_do(obj, edje_obj_part_text_input_panel_language_set(part, lang));
-}
-
-void
-_part_text_input_panel_language_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Edje_Input_Panel_Lang lang = va_arg(*list, Edje_Input_Panel_Lang);
- Edje *ed = _pd;
Edje_Real_Part *rp;
if ((!ed) || (!part)) return;
@@ -2979,47 +2178,27 @@ _part_text_input_panel_language_set(Eo *obj EINA_UNUSED, void *_pd, va_list *lis
}
}
-EAPI Edje_Input_Panel_Lang
-edje_object_part_text_input_panel_language_get(const Evas_Object *obj, const char *part)
+EOLIAN Edje_Input_Panel_Lang
+_edje_part_text_input_panel_language_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part)
{
- if (!obj) return EDJE_INPUT_PANEL_LANG_AUTOMATIC;
Edje_Input_Panel_Lang ret;
- eo_do((Eo *)obj, edje_obj_part_text_input_panel_language_get(part, &ret));
+ Edje_Real_Part *rp;
+ ret = EDJE_INPUT_PANEL_LANG_AUTOMATIC;
+
+ if ((!ed) || (!part)) return ret;
+ rp = _edje_real_part_recursive_get(&ed, part);
+ if (!rp) return ret;
+ if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
+ {
+ ret = _edje_entry_input_panel_language_get(rp);
+ }
+
return ret;
}
-void
-_part_text_input_panel_language_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+EOLIAN void
+_edje_part_text_input_panel_imdata_set(Eo *obj EINA_UNUSED, Edje *ed, const char *part, const void *data, int len)
{
- const char *part = va_arg(*list, const char *);
- Edje_Input_Panel_Lang *ret = va_arg(*list, Edje_Input_Panel_Lang *);
- Edje *ed = _pd;
- Edje_Real_Part *rp;
- *ret = EDJE_INPUT_PANEL_LANG_AUTOMATIC;
-
- if ((!ed) || (!part)) return;
- rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
- if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
- {
- *ret = _edje_entry_input_panel_language_get(rp);
- }
-}
-
-EAPI void
-edje_object_part_text_input_panel_imdata_set(Evas_Object *obj, const char *part, const void *data, int len)
-{
- if (!obj) return;
- eo_do(obj, edje_obj_part_text_input_panel_imdata_set(part, data, len));
-}
-
-void
-_part_text_input_panel_imdata_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- const void *data = va_arg(*list, const void *);
- int len = va_arg(*list, int);
- Edje *ed = _pd;
Edje_Real_Part *rp;
if ((!ed) || (!part)) return;
@@ -3031,20 +2210,9 @@ _part_text_input_panel_imdata_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
}
}
-EAPI void
-edje_object_part_text_input_panel_imdata_get(const Evas_Object *obj, const char *part, void *data, int *len)
+EOLIAN void
+_edje_part_text_input_panel_imdata_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part, void *data, int *len)
{
- if (!obj) return;
- eo_do((Eo *)obj, edje_obj_part_text_input_panel_imdata_get(part, data, len));
-}
-
-void
-_part_text_input_panel_imdata_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- void *data = va_arg(*list, void *);
- int *len = va_arg(*list, int *);
- Edje *ed = _pd;
Edje_Real_Part *rp;
if ((!ed) || (!part)) return;
@@ -3056,19 +2224,9 @@ _part_text_input_panel_imdata_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
}
}
-EAPI void
-edje_object_part_text_input_panel_return_key_type_set(Evas_Object *obj, const char *part, Edje_Input_Panel_Return_Key_Type return_key_type)
+EOLIAN void
+_edje_part_text_input_panel_return_key_type_set(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Edje_Input_Panel_Return_Key_Type return_key_type)
{
- if (!obj) return;
- eo_do(obj, edje_obj_part_text_input_panel_return_key_type_set(part, return_key_type));
-}
-
-void
-_part_text_input_panel_return_key_type_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Edje_Input_Panel_Return_Key_Type return_key_type = va_arg(*list, Edje_Input_Panel_Return_Key_Type);
- Edje *ed = _pd;
Edje_Real_Part *rp;
if ((!ed) || (!part)) return;
@@ -3080,46 +2238,27 @@ _part_text_input_panel_return_key_type_set(Eo *obj EINA_UNUSED, void *_pd, va_li
}
}
-EAPI Edje_Input_Panel_Return_Key_Type
-edje_object_part_text_input_panel_return_key_type_get(const Evas_Object *obj, const char *part)
+EOLIAN Edje_Input_Panel_Return_Key_Type
+_edje_part_text_input_panel_return_key_type_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part)
{
- if (!obj) return EDJE_INPUT_PANEL_RETURN_KEY_TYPE_DEFAULT;
Edje_Input_Panel_Return_Key_Type ret;
- eo_do((Eo *)obj, edje_obj_part_text_input_panel_return_key_type_get(part, &ret));
+ Edje_Real_Part *rp;
+ ret = EDJE_INPUT_PANEL_RETURN_KEY_TYPE_DEFAULT;
+
+ if ((!ed) || (!part)) return ret;
+ rp = _edje_real_part_recursive_get(&ed, part);
+ if (!rp) return ret;
+ if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
+ {
+ ret = _edje_entry_input_panel_return_key_type_get(rp);
+ }
+
return ret;
}
-void
-_part_text_input_panel_return_key_type_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+EOLIAN void
+_edje_part_text_input_panel_return_key_disabled_set(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Eina_Bool disabled)
{
- const char *part = va_arg(*list, const char *);
- Edje_Input_Panel_Return_Key_Type *ret = va_arg(*list, Edje_Input_Panel_Return_Key_Type *);
- Edje *ed = _pd;
- Edje_Real_Part *rp;
- *ret = EDJE_INPUT_PANEL_RETURN_KEY_TYPE_DEFAULT;
-
- if ((!ed) || (!part)) return;
- rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
- if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
- {
- *ret = _edje_entry_input_panel_return_key_type_get(rp);
- }
-}
-
-EAPI void
-edje_object_part_text_input_panel_return_key_disabled_set(Evas_Object *obj, const char *part, Eina_Bool disabled)
-{
- if (!obj) return;
- eo_do(obj, edje_obj_part_text_input_panel_return_key_disabled_set(part, disabled));
-}
-
-void
-_part_text_input_panel_return_key_disabled_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Eina_Bool disabled = va_arg(*list, int);
- Edje *ed = _pd;
Edje_Real_Part *rp;
if ((!ed) || (!part)) return;
@@ -3131,45 +2270,27 @@ _part_text_input_panel_return_key_disabled_set(Eo *obj EINA_UNUSED, void *_pd, v
}
}
-EAPI Eina_Bool
-edje_object_part_text_input_panel_return_key_disabled_get(const Evas_Object *obj, const char *part)
+EOLIAN Eina_Bool
+_edje_part_text_input_panel_return_key_disabled_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do((Eo *)obj, edje_obj_part_text_input_panel_return_key_disabled_get(part, &ret));
+ Eina_Bool ret;
+ Edje_Real_Part *rp;
+ ret = EINA_FALSE;
+
+ if ((!ed) || (!part)) return ret;
+ rp = _edje_real_part_recursive_get(&ed, part);
+ if (!rp) return ret;
+ if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
+ {
+ ret = _edje_entry_input_panel_return_key_disabled_get(rp);
+ }
+
return ret;
}
-void
-_part_text_input_panel_return_key_disabled_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+EOLIAN void
+_edje_part_text_input_panel_show_on_demand_set(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Eina_Bool ondemand)
{
- const char *part = va_arg(*list, const char *);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- Edje *ed = _pd;
- Edje_Real_Part *rp;
- *ret = EINA_FALSE;
-
- if ((!ed) || (!part)) return;
- rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
- if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
- {
- *ret = _edje_entry_input_panel_return_key_disabled_get(rp);
- }
-}
-
-EAPI void
-edje_object_part_text_input_panel_show_on_demand_set(Evas_Object *obj, const char *part, Eina_Bool ondemand)
-{
- if (!obj) return;
- eo_do(obj, edje_obj_part_text_input_panel_show_on_demand_set(part, ondemand));
-}
-
-void _part_text_input_panel_show_on_demand_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Eina_Bool ondemand = va_arg(*list, int);
- Edje *ed = _pd;
Edje_Real_Part *rp;
if ((!ed) || (!part)) return;
@@ -3181,46 +2302,27 @@ void _part_text_input_panel_show_on_demand_set(Eo *obj EINA_UNUSED, void *_pd, v
}
}
-EAPI Eina_Bool
-edje_object_part_text_input_panel_show_on_demand_get(const Evas_Object *obj, const char *part)
+EOLIAN Eina_Bool
+_edje_part_text_input_panel_show_on_demand_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do((Eo *)obj, edje_obj_part_text_input_panel_show_on_demand_get(part, &ret));
+ Eina_Bool ret;
+ Edje_Real_Part *rp;
+ ret = EINA_FALSE;
+
+ if ((!ed) || (!part)) return ret;
+ rp = _edje_real_part_recursive_get(&ed, part);
+ if (!rp) return ret;
+ if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
+ {
+ ret = _edje_entry_input_panel_show_on_demand_get(rp);
+ }
+
return ret;
}
-void _part_text_input_panel_show_on_demand_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+EOLIAN void
+_edje_text_insert_filter_callback_add(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Edje_Text_Filter_Cb func, void *data)
{
- const char *part = va_arg(*list, const char *);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- Edje *ed = _pd;
- Edje_Real_Part *rp;
- *ret = EINA_FALSE;
-
- if ((!ed) || (!part)) return;
- rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
- if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
- {
- *ret = _edje_entry_input_panel_show_on_demand_get(rp);
- }
-}
-
-EAPI void
-edje_object_text_insert_filter_callback_add(Evas_Object *obj, const char *part, Edje_Text_Filter_Cb func, void *data)
-{
- if (!obj) return;
- eo_do(obj, edje_obj_text_insert_filter_callback_add(part, func, data));
-}
-
-void
-_text_insert_filter_callback_add(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Edje_Text_Filter_Cb func = va_arg(*list, Edje_Text_Filter_Cb);
- void *data = va_arg(*list, void *);
- Edje *ed = _pd;
Edje_Text_Insert_Filter_Callback *cb;
if ((!ed) || (!part)) return;
@@ -3232,27 +2334,13 @@ _text_insert_filter_callback_add(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
eina_list_append(ed->text_insert_filter_callbacks, cb);
}
-EAPI void *
-edje_object_text_insert_filter_callback_del(Evas_Object *obj, const char *part, Edje_Text_Filter_Cb func)
+EOLIAN void*
+_edje_text_insert_filter_callback_del(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Edje_Text_Filter_Cb func)
{
- if (!obj) return NULL;
- void *ret = NULL;
- eo_do(obj, edje_obj_text_insert_filter_callback_del(part, func, &ret));
- return ret;
-}
-
-void
-_text_insert_filter_callback_del(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Edje_Text_Filter_Cb func = va_arg(*list, Edje_Text_Filter_Cb);
- void **ret = va_arg(*list, void **);
- Edje *ed = _pd;
Edje_Text_Insert_Filter_Callback *cb;
Eina_List *l;
- if (ret) *ret = NULL;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return NULL;
EINA_LIST_FOREACH(ed->text_insert_filter_callbacks, l, cb)
{
if ((!strcmp(cb->part, part)) && (cb->func == func))
@@ -3262,34 +2350,20 @@ _text_insert_filter_callback_del(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
eina_list_remove_list(ed->text_insert_filter_callbacks, l);
eina_stringshare_del(cb->part);
free(cb);
- if (ret) *ret = data;
- return;
+ return data;
}
}
+
+ return NULL;
}
-EAPI void *
-edje_object_text_insert_filter_callback_del_full(Evas_Object *obj, const char *part, Edje_Text_Filter_Cb func, void *data)
+EOLIAN void*
+_edje_text_insert_filter_callback_del_full(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Edje_Text_Filter_Cb func, void *data)
{
- if (!obj) return NULL;
- void *ret = NULL;
- eo_do(obj, edje_obj_text_insert_filter_callback_del_full(part, func, data, &ret));
- return ret;
-}
-
-void
-_text_insert_filter_callback_del_full(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Edje_Text_Filter_Cb func = va_arg(*list, Edje_Text_Filter_Cb);
- void *data = va_arg(*list, void *);
- void **ret = va_arg(*list, void **);
- Edje *ed = _pd;
Edje_Text_Insert_Filter_Callback *cb;
Eina_List *l;
- if (ret) *ret = NULL;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return NULL;
EINA_LIST_FOREACH(ed->text_insert_filter_callbacks, l, cb)
{
if ((!strcmp(cb->part, part)) && (cb->func == func) &&
@@ -3300,26 +2374,16 @@ _text_insert_filter_callback_del_full(Eo *obj EINA_UNUSED, void *_pd, va_list *l
eina_list_remove_list(ed->text_insert_filter_callbacks, l);
eina_stringshare_del(cb->part);
free(cb);
- if (ret) *ret = tmp;
- return;
+ return tmp;
}
}
+
+ return NULL;
}
-EAPI void
-edje_object_text_markup_filter_callback_add(Evas_Object *obj, const char *part, Edje_Markup_Filter_Cb func, void *data)
+EOLIAN void
+_edje_text_markup_filter_callback_add(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Edje_Markup_Filter_Cb func, void *data)
{
- if (!obj) return;
- eo_do(obj, edje_obj_text_markup_filter_callback_add(part, func, data));
-}
-
-void
-_text_markup_filter_callback_add(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Edje_Markup_Filter_Cb func = va_arg(*list, Edje_Markup_Filter_Cb);
- void *data = va_arg(*list, void *);
- Edje *ed = _pd;
Edje_Markup_Filter_Callback *cb;
if ((!ed) || (!part)) return;
@@ -3331,27 +2395,13 @@ _text_markup_filter_callback_add(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
eina_list_append(ed->markup_filter_callbacks, cb);
}
-EAPI void *
-edje_object_text_markup_filter_callback_del(Evas_Object *obj, const char *part, Edje_Markup_Filter_Cb func)
+EOLIAN void*
+_edje_text_markup_filter_callback_del(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Edje_Markup_Filter_Cb func)
{
- if (!obj) return NULL;
- void *ret = NULL;
- eo_do(obj, edje_obj_text_markup_filter_callback_del(part, func, &ret));
- return ret;
-}
-
-void
-_text_markup_filter_callback_del(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Edje_Markup_Filter_Cb func = va_arg(*list, Edje_Markup_Filter_Cb);
- void **ret = va_arg(*list, void **);
- Edje *ed = _pd;
Edje_Markup_Filter_Callback *cb;
Eina_List *l;
- if (ret) *ret = NULL;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return NULL;
EINA_LIST_FOREACH(ed->markup_filter_callbacks, l, cb)
{
if ((!strcmp(cb->part, part)) && (cb->func == func))
@@ -3361,34 +2411,20 @@ _text_markup_filter_callback_del(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
eina_list_remove_list(ed->markup_filter_callbacks, l);
eina_stringshare_del(cb->part);
free(cb);
- if (ret) *ret = data;
- return;
+ return data;
}
}
+
+ return NULL;
}
-EAPI void *
-edje_object_text_markup_filter_callback_del_full(Evas_Object *obj, const char *part, Edje_Markup_Filter_Cb func, void *data)
+EOLIAN void*
+_edje_text_markup_filter_callback_del_full(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Edje_Markup_Filter_Cb func, void *data)
{
- if (!obj) return NULL;
- void *ret = NULL;
- eo_do(obj, edje_obj_text_markup_filter_callback_del_full(part, func, data, &ret));
- return ret;
-}
-
-void
-_text_markup_filter_callback_del_full(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Edje_Markup_Filter_Cb func = va_arg(*list, Edje_Markup_Filter_Cb);
- void *data = va_arg(*list, void *);
- void **ret = va_arg(*list, void **);
- Edje *ed = _pd;
Edje_Markup_Filter_Callback *cb;
Eina_List *l;
- if (ret) *ret = NULL;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return NULL;
EINA_LIST_FOREACH(ed->markup_filter_callbacks, l, cb)
{
if ((!strcmp(cb->part, part)) && (cb->func == func) &&
@@ -3399,33 +2435,20 @@ _text_markup_filter_callback_del_full(Eo *obj EINA_UNUSED, void *_pd, va_list *l
eina_list_remove_list(ed->markup_filter_callbacks, l);
eina_stringshare_del(cb->part);
free(cb);
- if (ret) *ret = tmp;
- return;
+ return tmp;
}
}
+
+ return NULL;
}
-EAPI Eina_Bool
-edje_object_part_swallow(Evas_Object *obj, const char *part, Evas_Object *obj_swallow)
+EOLIAN Eina_Bool
+_edje_part_swallow(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Evas_Object *obj_swallow)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do(obj, edje_obj_part_swallow(part, obj_swallow, &ret));
- return ret;
-}
-
-void
-_part_swallow(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Evas_Object *obj_swallow = va_arg(*list, Evas_Object *);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- Edje *ed = _pd;
Edje_Real_Part *rp, *rpcur;
Edje_User_Defined *eud = NULL;
- if (ret) *ret = EINA_FALSE;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return EINA_FALSE;
/* Need to recalc before providing the object. */
// XXX: I guess this is not required, removing for testing purposes
@@ -3442,11 +2465,7 @@ _part_swallow(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
if (rpcur)
{
/* the object is already swallowed in the requested part */
- if (rpcur == rp)
- {
- *ret = EINA_TRUE;
- return;
- }
+ if (rpcur == rp) return EINA_TRUE;
/* The object is already swallowed somewhere, unswallow it first */
edje_object_part_unswallow(ed->obj, obj_swallow);
}
@@ -3454,15 +2473,15 @@ _part_swallow(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
if (!rp)
{
DBG("cannot swallow part %s: part not exist!", part);
- return;
+ return EINA_FALSE;
}
if (rp->part->type != EDJE_PART_TYPE_SWALLOW)
{
ERR("cannot swallow part %s: not swallow type!", rp->part->name);
- return;
+ return EINA_FALSE;
}
if ((rp->type != EDJE_RP_TYPE_SWALLOW) ||
- (!rp->typedata.swallow)) return;
+ (!rp->typedata.swallow)) return EINA_FALSE;
_edje_real_part_swallow(ed, rp, obj_swallow, EINA_TRUE);
if (rp->typedata.swallow->swallowed_object)
@@ -3480,7 +2499,7 @@ _part_swallow(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
}
}
- if (ret) *ret = EINA_TRUE;
+ return EINA_TRUE;
}
static void
@@ -3755,18 +2774,9 @@ edje_box_layout_register(const char *name, Evas_Object_Box_Layout func, void *(*
}
}
-EAPI void
-edje_object_part_unswallow(Evas_Object *obj, Evas_Object *obj_swallow)
+EOLIAN void
+_edje_part_unswallow(Eo *obj EINA_UNUSED, Edje *ed, Evas_Object *obj_swallow)
{
- if (!obj) return;
- eo_do(obj, edje_obj_part_unswallow(obj_swallow));
-}
-
-void
-_part_unswallow(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- Evas_Object *obj_swallow = va_arg(*list, Evas_Object *);
- Edje *ed = _pd;
Edje_Real_Part *rp;
if (!obj_swallow) return;
@@ -3822,50 +2832,27 @@ _part_unswallow(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
}
}
-EAPI Evas_Object *
-edje_object_part_swallow_get(const Evas_Object *obj, const char *part)
+EOLIAN Evas_Object*
+_edje_part_swallow_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part)
{
- if (!obj) return NULL;
- Evas_Object *ret = NULL;
- eo_do((Eo *)obj, edje_obj_part_swallow_get(part, &ret));
- return ret;
-}
-
-void
-_part_swallow_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Evas_Object **ret = va_arg(*list, Evas_Object **);
- Edje *ed = (Edje *)_pd;
Edje_Real_Part *rp;
- *ret = NULL;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return NULL;
/* Need to recalc before providing the object. */
_edje_recalc_do(ed);
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
+ if (!rp) return NULL;
if ((rp->type != EDJE_RP_TYPE_SWALLOW) ||
- (!rp->typedata.swallow)) return;
- *ret = rp->typedata.swallow->swallowed_object;
+ (!rp->typedata.swallow)) return NULL;
+
+ return rp->typedata.swallow->swallowed_object;
}
-EAPI void
-edje_object_size_min_get(const Evas_Object *obj, Evas_Coord *minw, Evas_Coord *minh)
+EOLIAN void
+_edje_size_min_get(Eo *obj EINA_UNUSED, Edje *ed, Evas_Coord *minw, Evas_Coord *minh)
{
- if (!obj) return;
- eo_do((Eo *)obj, edje_obj_size_min_get(minw, minh));
-}
-
-void
-_size_min_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- Evas_Coord *minw = va_arg(*list, Evas_Coord *);
- Evas_Coord *minh = va_arg(*list, Evas_Coord *);
- Edje *ed = _pd;
-
if ((!ed) || (!ed->collection))
{
if (minw) *minw = 0;
@@ -3876,20 +2863,9 @@ _size_min_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
if (minh) *minh = ed->collection->prop.min.h;
}
-EAPI void
-edje_object_size_max_get(const Evas_Object *obj, Evas_Coord *maxw, Evas_Coord *maxh)
+EOLIAN void
+_edje_size_max_get(Eo *obj EINA_UNUSED, Edje *ed EINA_UNUSED, Evas_Coord *maxw, Evas_Coord *maxh)
{
- if (!obj) return;
- eo_do((Eo *)obj, edje_obj_size_max_get(maxw, maxh));
-}
-
-void
-_size_max_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- Evas_Coord *maxw = va_arg(*list, Evas_Coord *);
- Evas_Coord *maxh = va_arg(*list, Evas_Coord *);
- Edje *ed = (Edje *)_pd;
-
if ((!ed) || (!ed->collection))
{
if (maxw) *maxw = 0;
@@ -3920,17 +2896,9 @@ _size_max_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
}
}
-EAPI void
-edje_object_calc_force(Evas_Object *obj)
+EOLIAN void
+_edje_calc_force(Eo *obj EINA_UNUSED, Edje *ed)
{
- if (!obj) return;
- eo_do(obj, edje_obj_calc_force());
-}
-
-void
-_calc_force(Eo *obj EINA_UNUSED, void *_pd, va_list *list EINA_UNUSED)
-{
- Edje *ed = _pd;
int pf, pf2;
if (!ed) return;
@@ -3939,55 +2907,30 @@ _calc_force(Eo *obj EINA_UNUSED, void *_pd, va_list *list EINA_UNUSED)
ed->all_part_change = EINA_TRUE;
#endif
- pf2 = _edje_freeze_val;
+ pf2 = _edje_util_freeze_val;
pf = ed->freeze;
- _edje_freeze_val = 0;
+ _edje_util_freeze_val = 0;
ed->freeze = 0;
_edje_recalc_do(ed);
ed->freeze = pf;
- _edje_freeze_val = pf2;
+ _edje_util_freeze_val = pf2;
}
-EAPI void
-edje_object_size_min_calc(Evas_Object *obj, Evas_Coord *minw, Evas_Coord *minh)
+EOLIAN void
+_edje_size_min_calc(Eo *obj, Edje *_pd EINA_UNUSED, Evas_Coord *minw, Evas_Coord *minh)
{
- if (!obj) return;
- eo_do(obj, edje_obj_size_min_calc(minw, minh));
-}
-
-void
-_size_min_calc(Eo *obj, void *_pd EINA_UNUSED, va_list *list)
-{
- Evas_Coord *minw = va_arg(*list, Evas_Coord *);
- Evas_Coord *minh = va_arg(*list, Evas_Coord *);
edje_object_size_min_restricted_calc(obj, minw, minh, 0, 0);
}
-EAPI Eina_Bool
-edje_object_parts_extends_calc(Evas_Object *obj, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h)
+EOLIAN Eina_Bool
+_edje_parts_extends_calc(Eo *obj EINA_UNUSED, Edje *ed, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do(obj, edje_obj_parts_extends_calc(x, y, w, h, &ret));
- return ret;
-}
-
-void
-_parts_extends_calc(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- Evas_Coord *x = va_arg(*list, Evas_Coord *);
- Evas_Coord *y = va_arg(*list, Evas_Coord *);
- Evas_Coord *w = va_arg(*list, Evas_Coord *);
- Evas_Coord *h = va_arg(*list, Evas_Coord *);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- Edje *ed = _pd;
Evas_Coord xx1 = INT_MAX, yy1 = INT_MAX;
Evas_Coord xx2 = 0, yy2 = 0;
unsigned int i;
- if (ret) *ret = EINA_FALSE;
if (!ed)
{
@@ -3995,7 +2938,7 @@ _parts_extends_calc(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
if (y) *y = 0;
if (w) *w = 0;
if (h) *h = 0;
- return;
+ return EINA_FALSE;
}
ed->calc_only = EINA_TRUE;
@@ -4030,24 +2973,12 @@ _parts_extends_calc(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
if (w) *w = xx2 - xx1;
if (h) *h = yy2 - yy1;
- if (ret) *ret = EINA_TRUE;
+ return EINA_TRUE;
}
-EAPI void
-edje_object_size_min_restricted_calc(Evas_Object *obj, Evas_Coord *minw, Evas_Coord *minh, Evas_Coord restrictedw, Evas_Coord restrictedh)
+EOLIAN void
+_edje_size_min_restricted_calc(Eo *obj EINA_UNUSED, Edje *ed, Evas_Coord *minw, Evas_Coord *minh, Evas_Coord restrictedw, Evas_Coord restrictedh)
{
- if (!obj) return;
- eo_do(obj, edje_obj_size_min_restricted_calc(minw, minh, restrictedw, restrictedh));
-}
-
-void
-_size_min_restricted_calc(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- Evas_Coord *minw = va_arg(*list, Evas_Coord *);
- Evas_Coord *minh = va_arg(*list, Evas_Coord *);
- Evas_Coord restrictedw = va_arg(*list, Evas_Coord);
- Evas_Coord restrictedh = va_arg(*list, Evas_Coord);
- Edje *ed = _pd;
Evas_Coord pw, ph;
int maxw, maxh;
int okw, okh;
@@ -4195,29 +3126,18 @@ _size_min_restricted_calc(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
}
/* FIXME: Correctly return other states */
-EAPI const char *
-edje_object_part_state_get(const Evas_Object *obj, const char *part, double *val_ret)
+EOLIAN const char*
+_edje_part_state_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part, double *val_ret)
{
- if (!obj) return NULL;
- const char *ret = NULL;
- eo_do((Eo *)obj, edje_obj_part_state_get(part, val_ret, &ret));
- return ret;
-}
+ const char *ret;
-void
-_part_state_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- double *val_ret = va_arg(*list, double *);
- const char **ret = va_arg(*list, const char **);
- Edje *ed = (Edje *)_pd;
Edje_Real_Part *rp;
- *ret = "";
+ ret = "";
if ((!ed) || (!part))
{
if (val_ret) *val_ret = 0;
- return;
+ return ret;
}
/* Need to recalc before providing the object. */
@@ -4228,16 +3148,16 @@ _part_state_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
{
if (val_ret) *val_ret = 0;
INF("part not found");
- return;
+ return ret;
}
if (rp->chosen_description)
{
if (val_ret) *val_ret = rp->chosen_description->state.value;
if (rp->chosen_description->state.name)
- *ret = rp->chosen_description->state.name;
+ ret = rp->chosen_description->state.name;
else
- *ret = "default";
- return;
+ ret = "default";
+ return ret;
}
else
{
@@ -4245,72 +3165,50 @@ _part_state_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
{
if (val_ret) *val_ret = rp->param1.description->state.value;
if (rp->param1.description->state.name)
- *ret = rp->param1.description->state.name;
+ ret = rp->param1.description->state.name;
else
- *ret = "default";
- return;
+ ret = "default";
+ return ret;
}
}
if (val_ret) *val_ret = 0;
-}
-EAPI Edje_Drag_Dir
-edje_object_part_drag_dir_get(const Evas_Object *obj, const char *part)
-{
- if (!obj) return EDJE_DRAG_DIR_NONE;
- Edje_Drag_Dir ret;
- eo_do((Eo *)obj, edje_obj_part_drag_dir_get(part, &ret));
return ret;
}
-void
-_part_drag_dir_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+EOLIAN Edje_Drag_Dir
+_edje_part_drag_dir_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part)
{
- const char *part = va_arg(*list, const char *);
- Edje_Drag_Dir *ret = va_arg(*list, Edje_Drag_Dir *);
- Edje *ed = (Edje *)_pd;
+ Edje_Drag_Dir ret;
Edje_Real_Part *rp;
- *ret = EDJE_DRAG_DIR_NONE;
+ ret = EDJE_DRAG_DIR_NONE;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return ret;
/* Need to recalc before providing the object. */
_edje_recalc_do(ed);
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
- if ((rp->part->dragable.x) && (rp->part->dragable.y)) *ret = EDJE_DRAG_DIR_XY;
- else if (rp->part->dragable.x) *ret = EDJE_DRAG_DIR_X;
- else if (rp->part->dragable.y) *ret = EDJE_DRAG_DIR_Y;
-}
+ if (!rp) return ret;
+ if ((rp->part->dragable.x) && (rp->part->dragable.y)) ret = EDJE_DRAG_DIR_XY;
+ else if (rp->part->dragable.x) ret = EDJE_DRAG_DIR_X;
+ else if (rp->part->dragable.y) ret = EDJE_DRAG_DIR_Y;
-EAPI Eina_Bool
-edje_object_part_drag_value_set(Evas_Object *obj, const char *part, double dx, double dy)
-{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do(obj, edje_obj_part_drag_value_set(part, dx, dy, &ret));
return ret;
}
-void
-_part_drag_value_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+EOLIAN Eina_Bool
+_edje_part_drag_value_set(Eo *obj EINA_UNUSED, Edje *ed, const char *part, double dx, double dy)
{
- const char *part = va_arg(*list, const char *);
- double dx = va_arg(*list, double);
- double dy = va_arg(*list, double);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- Edje *ed = _pd;
Edje_Real_Part *rp;
Edje_User_Defined *eud;
Eina_List *l;
- if (ret) *ret = EINA_FALSE;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return EINA_FALSE;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
- if (!rp->drag) return;
- if (rp->drag->down.count > 0) return;
+ if (!rp) return EINA_FALSE;
+ if (!rp->drag) return EINA_FALSE;
+ if (rp->drag->down.count > 0) return EINA_FALSE;
EINA_LIST_FOREACH(ed->user_defined, l, eud)
if (eud->type == EDJE_USER_DRAG_VALUE && !strcmp(part, eud->part))
@@ -4338,8 +3236,7 @@ _part_drag_value_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
if (rp->part->dragable.y < 0) dy = 1.0 - dy;
if ((rp->drag->val.x == FROM_DOUBLE(dx)) && (rp->drag->val.y == FROM_DOUBLE(dy)))
{
- if (ret) *ret = EINA_TRUE;
- return;
+ return EINA_TRUE;
}
rp->drag->val.x = FROM_DOUBLE(dx);
rp->drag->val.y = FROM_DOUBLE(dy);
@@ -4348,36 +3245,22 @@ _part_drag_value_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
#endif
_edje_dragable_pos_set(ed, rp, rp->drag->val.x, rp->drag->val.y);
_edje_emit(ed, "drag,set", rp->part->name);
- if (ret) *ret = EINA_TRUE;
+
+ return EINA_TRUE;
}
/* FIXME: Should this be x and y instead of dx/dy? */
-EAPI Eina_Bool
-edje_object_part_drag_value_get(const Evas_Object *obj, const char *part, double *dx, double *dy)
+EOLIAN Eina_Bool
+_edje_part_drag_value_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part, double *dx, double *dy)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do((Eo *)obj, edje_obj_part_drag_value_get(part, dx, dy, &ret));
- return ret;
-}
-
-void
-_part_drag_value_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- double *dx = va_arg(*list, double *);
- double *dy = va_arg(*list, double *);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- Edje *ed = (Edje *)_pd;
Edje_Real_Part *rp;
double ddx, ddy;
- *ret = EINA_FALSE;
if ((!ed) || (!part))
{
if (dx) *dx = 0;
if (dy) *dy = 0;
- return;
+ return EINA_FALSE;
}
/* Need to recalc before providing the object. */
@@ -4388,7 +3271,7 @@ _part_drag_value_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
{
if (dx) *dx = 0;
if (dy) *dy = 0;
- return;
+ return EINA_FALSE;
}
ddx = TO_DOUBLE(rp->drag->val.x);
ddy = TO_DOUBLE(rp->drag->val.y);
@@ -4396,35 +3279,21 @@ _part_drag_value_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
if (rp->part->dragable.y < 0) ddy = 1.0 - ddy;
if (dx) *dx = ddx;
if (dy) *dy = ddy;
- *ret = EINA_TRUE;
+
+ return EINA_TRUE;
}
-EAPI Eina_Bool
-edje_object_part_drag_size_set(Evas_Object *obj, const char *part, double dw, double dh)
+EOLIAN Eina_Bool
+_edje_part_drag_size_set(Eo *obj EINA_UNUSED, Edje *ed, const char *part, double dw, double dh)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do(obj, edje_obj_part_drag_size_set(part, dw, dh, &ret));
- return ret;
-}
-
-void
-_part_drag_size_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- double dw = va_arg(*list, double);
- double dh = va_arg(*list, double);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- Edje *ed = _pd;
Edje_Real_Part *rp;
Edje_User_Defined *eud;
Eina_List *l;
- if (ret) *ret = EINA_FALSE;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return EINA_FALSE;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
- if (!rp->drag) return;
+ if (!rp) return EINA_FALSE;
+ if (!rp->drag) return EINA_FALSE;
EINA_LIST_FOREACH(ed->user_defined, l, eud)
if (eud->type == EDJE_USER_DRAG_SIZE && !strcmp(part, eud->part))
@@ -4449,8 +3318,7 @@ _part_drag_size_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
else if (dh > 1.0) dh = 1.0;
if ((rp->drag->size.x == FROM_DOUBLE(dw)) && (rp->drag->size.y == FROM_DOUBLE(dh)))
{
- if (ret) *ret = EINA_TRUE;
- return;
+ return EINA_TRUE;
}
rp->drag->size.x = FROM_DOUBLE(dw);
rp->drag->size.y = FROM_DOUBLE(dh);
@@ -4460,34 +3328,20 @@ _part_drag_size_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
rp->invalidate = EINA_TRUE;
#endif
_edje_recalc(ed);
- if (ret) *ret = EINA_TRUE;
+
+ return EINA_TRUE;
}
-EAPI Eina_Bool
-edje_object_part_drag_size_get(const Evas_Object *obj, const char *part, double *dw, double *dh)
+EOLIAN Eina_Bool
+_edje_part_drag_size_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part, double *dw, double *dh)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do((Eo *)obj, edje_obj_part_drag_size_get(part, dw, dh, &ret));
- return ret;
-}
-
-void
-_part_drag_size_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- double *dw = va_arg(*list, double *);
- double *dh = va_arg(*list, double *);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- Edje *ed = (Edje *)_pd;
Edje_Real_Part *rp;
- *ret = EINA_FALSE;
if ((!ed) || (!part))
{
if (dw) *dw = 0;
if (dh) *dh = 0;
- return;
+ return EINA_FALSE;
}
/* Need to recalc before providing the object. */
@@ -4498,39 +3352,25 @@ _part_drag_size_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
{
if (dw) *dw = 0;
if (dh) *dh = 0;
- return;
+ return EINA_FALSE;
}
if (dw) *dw = TO_DOUBLE(rp->drag->size.x);
if (dh) *dh = TO_DOUBLE(rp->drag->size.y);
- *ret = EINA_TRUE;
+
+ return EINA_TRUE;
}
-EAPI Eina_Bool
-edje_object_part_drag_step_set(Evas_Object *obj, const char *part, double dx, double dy)
+EOLIAN Eina_Bool
+_edje_part_drag_step_set(Eo *obj EINA_UNUSED, Edje *ed, const char *part, double dx, double dy)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do(obj, edje_obj_part_drag_step_set(part, dx, dy, &ret));
- return ret;
-}
-
-void
-_part_drag_step_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- double dx = va_arg(*list, double);
- double dy = va_arg(*list, double);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- Edje *ed = _pd;
Edje_Real_Part *rp;
Edje_User_Defined *eud;
Eina_List *l;
- if (ret) *ret = EINA_FALSE;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return EINA_FALSE;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
- if (!rp->drag) return;
+ if (!rp) return EINA_FALSE;
+ if (!rp->drag) return EINA_FALSE;
EINA_LIST_FOREACH(ed->user_defined, l, eud)
if (eud->type == EDJE_USER_DRAG_STEP && !strcmp(part, eud->part))
@@ -4558,34 +3398,20 @@ _part_drag_step_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
#ifdef EDJE_CALC_CACHE
rp->invalidate = EINA_TRUE;
#endif
- if (ret) *ret = EINA_TRUE;
+
+ return EINA_TRUE;
}
-EAPI Eina_Bool
-edje_object_part_drag_step_get(const Evas_Object *obj, const char *part, double *dx, double *dy)
+EOLIAN Eina_Bool
+_edje_part_drag_step_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part, double *dx, double *dy)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do((Eo *)obj, edje_obj_part_drag_step_get(part, dx, dy, &ret));
- return ret;
-}
-
-void
-_part_drag_step_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- double *dx = va_arg(*list, double *);
- double *dy = va_arg(*list, double *);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- Edje *ed = (Edje *)_pd;
Edje_Real_Part *rp;
- *ret = EINA_FALSE;
if ((!ed) || (!part))
{
if (dx) *dx = 0;
if (dy) *dy = 0;
- return;
+ return EINA_FALSE;
}
/* Need to recalc before providing the object. */
@@ -4596,39 +3422,25 @@ _part_drag_step_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
{
if (dx) *dx = 0;
if (dy) *dy = 0;
- return;
+ return EINA_FALSE;
}
if (dx) *dx = TO_DOUBLE(rp->drag->step.x);
if (dy) *dy = TO_DOUBLE(rp->drag->step.y);
- *ret = EINA_TRUE;
+
+ return EINA_TRUE;
}
-EAPI Eina_Bool
-edje_object_part_drag_page_set(Evas_Object *obj, const char *part, double dx, double dy)
+EOLIAN Eina_Bool
+_edje_part_drag_page_set(Eo *obj EINA_UNUSED, Edje *ed, const char *part, double dx, double dy)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do(obj, edje_obj_part_drag_page_set(part, dx, dy, &ret));
- return ret;
-}
-
-void
-_part_drag_page_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- double dx = va_arg(*list, double);
- double dy = va_arg(*list, double);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- Edje *ed = _pd;
Edje_Real_Part *rp;
Edje_User_Defined *eud;
Eina_List *l;
- if (ret) *ret = EINA_FALSE;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return EINA_FALSE;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
- if (!rp->drag) return;
+ if (!rp) return EINA_FALSE;
+ if (!rp->drag) return EINA_FALSE;
EINA_LIST_FOREACH(ed->user_defined, l, eud)
if (eud->type == EDJE_USER_DRAG_PAGE && !strcmp(part, eud->part))
@@ -4656,34 +3468,20 @@ _part_drag_page_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
#ifdef EDJE_CALC_CACHE
rp->invalidate = EINA_TRUE;
#endif
- if (ret) *ret = EINA_TRUE;
+
+ return EINA_TRUE;
}
-EAPI Eina_Bool
-edje_object_part_drag_page_get(const Evas_Object *obj, const char *part, double *dx, double *dy)
+EOLIAN Eina_Bool
+_edje_part_drag_page_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part, double *dx, double *dy)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do((Eo *)obj, edje_obj_part_drag_page_get(part, dx, dy, &ret));
- return ret;
-}
-
-void
-_part_drag_page_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- double *dx = va_arg(*list, double *);
- double *dy = va_arg(*list, double *);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- Edje *ed = (Edje *)_pd;
Edje_Real_Part *rp;
- *ret = EINA_FALSE;
if ((!ed) || (!part))
{
if (dx) *dx = 0;
if (dy) *dy = 0;
- return;
+ return EINA_FALSE;
}
/* Need to recalc before providing the object. */
@@ -4694,41 +3492,27 @@ _part_drag_page_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
{
if (dx) *dx = 0;
if (dy) *dy = 0;
- return;
+ return EINA_FALSE;
}
if (dx) *dx = TO_DOUBLE(rp->drag->page.x);
if (dy) *dy = TO_DOUBLE(rp->drag->page.y);
- *ret = EINA_TRUE;
+
+ return EINA_TRUE;
}
-EAPI Eina_Bool
-edje_object_part_drag_step(Evas_Object *obj, const char *part, double dx, double dy)
+EOLIAN Eina_Bool
+_edje_part_drag_step(Eo *obj EINA_UNUSED, Edje *ed, const char *part, double dx, double dy)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do(obj, edje_obj_part_drag_step(part, dx, dy, &ret));
- return ret;
-}
-
-void
-_part_drag_step(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- double dx = va_arg(*list, double);
- double dy = va_arg(*list, double);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- Edje *ed = _pd;
Edje_Real_Part *rp;
FLOAT_T px, py;
Edje_User_Defined *eud;
Eina_List *l;
- if (ret) *ret = EINA_FALSE;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return EINA_FALSE;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
- if (!rp->drag) return;
- if (rp->drag->down.count > 0) return;
+ if (!rp) return EINA_FALSE;
+ if (!rp->drag) return EINA_FALSE;
+ if (rp->drag->down.count > 0) return EINA_FALSE;
EINA_LIST_FOREACH(ed->user_defined, l, eud)
if (eud->type == EDJE_USER_DRAG_STEP && !strcmp(part, eud->part))
@@ -4757,45 +3541,30 @@ _part_drag_step(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
rp->drag->val.y = CLAMP (rp->drag->val.y, ZERO, FROM_DOUBLE(1.0));
if ((px == rp->drag->val.x) && (py == rp->drag->val.y))
{
- if (ret) *ret = EINA_TRUE;
- return;
+ return EINA_TRUE;
}
#ifdef EDJE_CALC_CACHE
rp->invalidate = EINA_TRUE;
#endif
_edje_dragable_pos_set(ed, rp, rp->drag->val.x, rp->drag->val.y);
_edje_emit(ed, "drag,step", rp->part->name);
- if (ret) *ret = EINA_TRUE;
+
+ return EINA_TRUE;
}
-EAPI Eina_Bool
-edje_object_part_drag_page(Evas_Object *obj, const char *part, double dx, double dy)
+EOLIAN Eina_Bool
+_edje_part_drag_page(Eo *obj EINA_UNUSED, Edje *ed, const char *part, double dx, double dy)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do(obj, edje_obj_part_drag_page(part, dx, dy, &ret));
- return ret;
-}
-
-void
-_part_drag_page(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- double dx = va_arg(*list, double);
- double dy = va_arg(*list, double);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- Edje *ed = _pd;
Edje_Real_Part *rp;
FLOAT_T px, py;
Edje_User_Defined *eud;
Eina_List *l;
- if (ret) *ret = EINA_FALSE;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return EINA_FALSE;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
- if (!rp->drag) return;
- if (rp->drag->down.count > 0) return;
+ if (!rp) return EINA_FALSE;
+ if (!rp->drag) return EINA_FALSE;
+ if (rp->drag->down.count > 0) return EINA_FALSE;
EINA_LIST_FOREACH(ed->user_defined, l, eud)
if (eud->type == EDJE_USER_DRAG_PAGE && !strcmp(part, eud->part))
@@ -4822,15 +3591,15 @@ _part_drag_page(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
rp->drag->val.y = CLAMP (rp->drag->val.y, ZERO, FROM_DOUBLE(1.0));
if ((px == rp->drag->val.x) && (py == rp->drag->val.y))
{
- if (ret) *ret = EINA_TRUE;
- return;
+ return EINA_TRUE;
}
#ifdef EDJE_CALC_CACHE
rp->invalidate = EINA_TRUE;
#endif
_edje_dragable_pos_set(ed, rp, rp->drag->val.x, rp->drag->val.y);
_edje_emit(ed, "drag,page", rp->part->name);
- if (ret) *ret = EINA_TRUE;
+
+ return EINA_TRUE;
}
void
@@ -4850,186 +3619,130 @@ _edje_box_shutdown(void)
_edje_box_layout_registry = NULL;
}
-EAPI Eina_Bool
-edje_object_part_box_append(Evas_Object *obj, const char *part, Evas_Object *child)
+EOLIAN Eina_Bool
+_edje_part_box_append(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Evas_Object *child)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do(obj, edje_obj_part_box_append(part, child, &ret));
- return ret;
-}
-
-void
-_part_box_append(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Evas_Object *child = va_arg(*list, Evas_Object *);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- Edje *ed = _pd;
+ Eina_Bool ret;
Edje_Real_Part *rp;
- if (ret) *ret = EINA_FALSE;
+ ret = EINA_FALSE;
- if ((!ed) || (!part) || (!child)) return;
+ if ((!ed) || (!part) || (!child)) return ret;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
- if (rp->part->type != EDJE_PART_TYPE_BOX) return;
+ if (!rp) return ret;
+ if (rp->part->type != EDJE_PART_TYPE_BOX) return ret;
if (_edje_real_part_box_append(ed, rp, child))
{
Edje_User_Defined *eud;
eud = _edje_user_definition_new(EDJE_USER_BOX_PACK, part, ed);
- if (!eud) return;
+ if (!eud) return ret;
eud->u.box.child = child;
eud->u.box.index = -1;
evas_object_event_callback_add(child, EVAS_CALLBACK_DEL, _edje_user_def_del_cb, eud);
- if (ret) *ret = EINA_TRUE;
+ ret = EINA_TRUE;
}
-}
-EAPI Eina_Bool
-edje_object_part_box_prepend(Evas_Object *obj, const char *part, Evas_Object *child)
-{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do(obj, edje_obj_part_box_prepend(part, child, &ret));
return ret;
}
-void
-_part_box_prepend(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+EOLIAN Eina_Bool
+_edje_part_box_prepend(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Evas_Object *child)
{
- const char *part = va_arg(*list, const char *);
- Evas_Object *child = va_arg(*list, Evas_Object *);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- Edje *ed = _pd;
+ Eina_Bool ret;
Edje_Real_Part *rp;
- if (ret) *ret = EINA_FALSE;
+ ret = EINA_FALSE;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return ret;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
- if (rp->part->type != EDJE_PART_TYPE_BOX) return;
+ if (!rp) return ret;
+ if (rp->part->type != EDJE_PART_TYPE_BOX) return ret;
if (_edje_real_part_box_prepend(ed, rp, child))
{
Edje_User_Defined *eud;
eud = _edje_user_definition_new(EDJE_USER_BOX_PACK, part, ed);
- if (!eud) return;
+ if (!eud) return ret;
eud->u.box.child = child;
evas_object_event_callback_add(child, EVAS_CALLBACK_DEL, _edje_user_def_del_cb, eud);
- if (ret) *ret = EINA_TRUE;
+ ret = EINA_TRUE;
}
-}
-EAPI Eina_Bool
-edje_object_part_box_insert_before(Evas_Object *obj, const char *part, Evas_Object *child, const Evas_Object *reference)
-{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do(obj, edje_obj_part_box_insert_before(part, child, reference, &ret));
return ret;
}
-void
-_part_box_insert_before(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+EOLIAN Eina_Bool
+_edje_part_box_insert_before(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Evas_Object *child, const Evas_Object *reference)
{
- const char *part = va_arg(*list, const char *);
- Evas_Object *child = va_arg(*list, Evas_Object *);
- const Evas_Object *reference = va_arg(*list, const Evas_Object *);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- Edje *ed = _pd;
+ Eina_Bool ret;
Edje_Real_Part *rp;
- if (ret) *ret = EINA_FALSE;
+ ret = EINA_FALSE;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return ret;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
- if (rp->part->type != EDJE_PART_TYPE_BOX) return;
+ if (!rp) return ret;
+ if (rp->part->type != EDJE_PART_TYPE_BOX) return ret;
if (_edje_real_part_box_insert_before(ed, rp, child, reference))
{
Edje_User_Defined *eud;
eud = _edje_user_definition_new(EDJE_USER_BOX_PACK, part, ed);
- if (!eud) return;
+ if (!eud) return ret;
eud->u.box.child = child;
evas_object_event_callback_add(child, EVAS_CALLBACK_DEL, _edje_user_def_del_cb, eud);
- if (ret) *ret = EINA_TRUE;
+ ret = EINA_TRUE;
}
-}
-EAPI Eina_Bool
-edje_object_part_box_insert_at(Evas_Object *obj, const char *part, Evas_Object *child, unsigned int pos)
-{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do(obj, edje_obj_part_box_insert_at(part, child, pos, &ret));
return ret;
}
-void
-_part_box_insert_at(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+EOLIAN Eina_Bool
+_edje_part_box_insert_at(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Evas_Object *child, unsigned int pos)
{
- const char *part = va_arg(*list, const char *);
- Evas_Object *child = va_arg(*list, Evas_Object *);
- unsigned int pos = va_arg(*list, unsigned int);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- Edje *ed = _pd;
+ Eina_Bool ret;
Edje_Real_Part *rp;
- if (ret) *ret = EINA_FALSE;
+ ret = EINA_FALSE;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return ret;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
- if (rp->part->type != EDJE_PART_TYPE_BOX) return;
+ if (!rp) return ret;
+ if (rp->part->type != EDJE_PART_TYPE_BOX) return ret;
if (_edje_real_part_box_insert_at(ed, rp, child, pos))
{
Edje_User_Defined *eud;
eud = _edje_user_definition_new(EDJE_USER_BOX_PACK, part, ed);
- if (!eud) return;
+ if (!eud) return ret;
eud->u.box.child = child;
evas_object_event_callback_add(child, EVAS_CALLBACK_DEL, _edje_user_def_del_cb, eud);
- if (ret) *ret = EINA_TRUE;
+ ret = EINA_TRUE;
}
-}
-EAPI Evas_Object *
-edje_object_part_box_remove(Evas_Object *obj, const char *part, Evas_Object *child)
-{
- if (!obj) return NULL;
- Evas_Object *ret = NULL;
- eo_do(obj, edje_obj_part_box_remove(part, child, &ret));
return ret;
}
-void
-_part_box_remove(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+EOLIAN Evas_Object*
+_edje_part_box_remove(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Evas_Object *child)
{
- const char *part = va_arg(*list, const char *);
- Evas_Object *child = va_arg(*list, Evas_Object *);
- Evas_Object **ret = va_arg(*list, Evas_Object **);
- Edje *ed = _pd;
Edje_Real_Part *rp;
Evas_Object *r;
- if (ret) *ret = NULL;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return NULL;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
- if (rp->part->type != EDJE_PART_TYPE_BOX) return;
+ if (!rp) return NULL;
+ if (rp->part->type != EDJE_PART_TYPE_BOX) return NULL;
r = _edje_real_part_box_remove(ed, rp, child);
@@ -5042,38 +3755,23 @@ _part_box_remove(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
if (eud->type == EDJE_USER_BOX_PACK && eud->u.box.child == child && !strcmp(eud->part, part))
{
_edje_user_definition_free(eud);
- if (ret) *ret = r;
- return;
+ return r;
}
}
- if (ret) *ret = r;
+ return r;
}
-EAPI Evas_Object *
-edje_object_part_box_remove_at(Evas_Object *obj, const char *part, unsigned int pos)
+EOLIAN Evas_Object*
+_edje_part_box_remove_at(Eo *obj EINA_UNUSED, Edje *ed, const char *part, unsigned int pos)
{
- if (!obj) return NULL;
- Evas_Object *ret = NULL;
- eo_do(obj, edje_obj_part_box_remove_at(part, pos, &ret));
- return ret;
-}
-
-void
-_part_box_remove_at(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- unsigned int pos = va_arg(*list, unsigned int);
- Evas_Object **ret = va_arg(*list, Evas_Object **);
- Edje *ed = _pd;
Edje_Real_Part *rp;
Evas_Object *r;
- if (ret) *ret = NULL;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return NULL;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
- if (rp->part->type != EDJE_PART_TYPE_BOX) return;
+ if (!rp) return NULL;
+ if (rp->part->type != EDJE_PART_TYPE_BOX) return NULL;
r = _edje_real_part_box_remove_at(ed, rp, pos);
@@ -5086,41 +3784,28 @@ _part_box_remove_at(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
if (eud->type == EDJE_USER_BOX_PACK && eud->u.box.child == r && !strcmp(eud->part, part))
{
_edje_user_definition_free(eud);
- if (ret) *ret = r;
- return;
+ return r;
}
}
- if (ret) *ret = r;
+ return r;
}
-EAPI Eina_Bool
-edje_object_part_box_remove_all(Evas_Object *obj, const char *part, Eina_Bool clear)
+EOLIAN Eina_Bool
+_edje_part_box_remove_all(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Eina_Bool clear)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do(obj, edje_obj_part_box_remove_all(part, clear, &ret));
- return ret;
-}
-
-void
-_part_box_remove_all(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Eina_Bool clear = va_arg(*list, int);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- Edje *ed = _pd;
+ Eina_Bool ret;
Edje_Real_Part *rp;
- if (ret) *ret = EINA_FALSE;
+ ret = EINA_FALSE;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return ret;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
- if (rp->part->type != EDJE_PART_TYPE_BOX) return;
+ if (!rp) return ret;
+ if (rp->part->type != EDJE_PART_TYPE_BOX) return ret;
if (_edje_real_part_box_remove_all(ed, rp, clear))
{
- if (ret) *ret = EINA_TRUE;
+ ret = EINA_TRUE;
Edje_User_Defined *eud;
Eina_List *ll, *l;
@@ -5128,29 +3813,19 @@ _part_box_remove_all(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
if (eud->type == EDJE_USER_BOX_PACK && !strcmp(eud->part, part))
{
_edje_user_definition_free(eud);
- return;
+ return ret;
}
}
-}
-EAPI Eina_List *
-edje_object_access_part_list_get(const Evas_Object *obj)
-{
- if (!obj) return NULL;
- Eina_List *ret = NULL;
- eo_do((Eo *)obj, edje_obj_access_part_list_get(&ret));
return ret;
}
-void
-_access_part_list_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+EOLIAN Eina_List*
+_edje_access_part_list_get(Eo *obj EINA_UNUSED, Edje *ed)
{
- Eina_List **ret = va_arg(*list, Eina_List **);
- Edje *ed = _pd;
Eina_List *access_parts = NULL;
- *ret = NULL;
- if ((!ed)) return;
+ if ((!ed)) return NULL;
unsigned int i;
for (i = 0; i < ed->table_parts_size; i++)
@@ -5161,7 +3836,7 @@ _access_part_list_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
access_parts = eina_list_append(access_parts, rp->part->name);
}
- *ret = access_parts;
+ return access_parts;
}
static void
@@ -5361,70 +4036,39 @@ _edje_real_part_box_remove_all(Edje *ed, Edje_Real_Part *rp, Eina_Bool clear)
return EINA_TRUE;
}
-EAPI Evas_Object *
-edje_object_part_table_child_get(const Evas_Object *obj, const char *part, unsigned int col, unsigned int row)
+EOLIAN Evas_Object*
+_edje_part_table_child_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part, unsigned int col, unsigned int row)
{
- if (!obj) return NULL;
- Evas_Object *ret = NULL;
- eo_do((Eo *)obj, edje_obj_part_table_child_get(part, col, row, &ret));
- return ret;
-}
-
-void
-_part_table_child_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- unsigned int col = va_arg(*list, unsigned int);
- unsigned int row = va_arg(*list, unsigned int);
- Evas_Object **ret = va_arg(*list, Evas_Object **);
- Edje *ed = _pd;
Edje_Real_Part *rp;
- *ret = NULL;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return NULL;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
- if (rp->part->type != EDJE_PART_TYPE_TABLE) return;
+ if (!rp) return NULL;
+ if (rp->part->type != EDJE_PART_TYPE_TABLE) return NULL;
- *ret = evas_object_table_child_get(rp->object, col, row);
+ return evas_object_table_child_get(rp->object, col, row);
}
-EAPI Eina_Bool
-edje_object_part_table_pack(Evas_Object *obj, const char *part, Evas_Object *child_obj, unsigned short col, unsigned short row, unsigned short colspan, unsigned short rowspan)
+EOLIAN Eina_Bool
+_edje_part_table_pack(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Evas_Object *child_obj, unsigned short col, unsigned short row, unsigned short colspan, unsigned short rowspan)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do(obj, edje_obj_part_table_pack(part, child_obj, col, row, colspan, rowspan, &ret));
- return ret;
-}
-
-void
-_part_table_pack(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Evas_Object *child_obj = va_arg(*list, Evas_Object *);
- unsigned short col = va_arg(*list, unsigned int);
- unsigned short row = va_arg(*list, unsigned int);
- unsigned short colspan = va_arg(*list, unsigned int);
- unsigned short rowspan = va_arg(*list, unsigned int);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- Edje *ed = _pd;
+ Eina_Bool ret;
Edje_Real_Part *rp;
Edje_User_Defined *eud;
- if (ret) *ret = EINA_FALSE;
+ ret = EINA_FALSE;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return ret;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
- if (rp->part->type != EDJE_PART_TYPE_TABLE) return;
+ if (!rp) return ret;
+ if (rp->part->type != EDJE_PART_TYPE_TABLE) return ret;
if (_edje_real_part_table_pack(ed, rp, child_obj, col, row, colspan, rowspan))
{
- if (ret) *ret = EINA_TRUE;
+ ret = EINA_TRUE;
eud = _edje_user_definition_new(EDJE_USER_TABLE_PACK, part, ed);
- if (!eud) return;
+ if (!eud) return ret;
eud->u.table.child = child_obj;
eud->u.table.col = col;
@@ -5434,36 +4078,26 @@ _part_table_pack(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
evas_object_event_callback_add(child_obj, EVAS_CALLBACK_DEL, _edje_user_def_del_cb, eud);
}
-}
-EAPI Eina_Bool
-edje_object_part_table_unpack(Evas_Object *obj, const char *part, Evas_Object *child_obj)
-{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do(obj, edje_obj_part_table_unpack(part, child_obj, &ret));
return ret;
}
-void
-_part_table_unpack(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+EOLIAN Eina_Bool
+_edje_part_table_unpack(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Evas_Object *child_obj)
{
- const char *part = va_arg(*list, const char *);
- Evas_Object *child_obj = va_arg(*list, Evas_Object *);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- Edje *ed = _pd;
+ Eina_Bool ret;
Edje_Real_Part *rp;
- if (ret) *ret = EINA_FALSE;
+ ret = EINA_FALSE;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return ret;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
- if (rp->part->type != EDJE_PART_TYPE_TABLE) return;
+ if (!rp) return ret;
+ if (rp->part->type != EDJE_PART_TYPE_TABLE) return ret;
if (_edje_real_part_table_unpack(ed, rp, child_obj))
{
- if (ret) *ret = EINA_TRUE;
+ ret = EINA_TRUE;
Edje_User_Defined *eud;
Eina_List *l;
@@ -5476,65 +4110,40 @@ _part_table_unpack(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
break;
}
}
-}
-EAPI Eina_Bool
-edje_object_part_table_col_row_size_get(const Evas_Object *obj, const char *part, int *cols, int *rows)
-{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do((Eo *)obj, edje_obj_part_table_col_row_size_get(part, cols, rows, &ret));
return ret;
}
-void
-_part_table_col_row_size_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+EOLIAN Eina_Bool
+_edje_part_table_col_row_size_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part, int *cols, int *rows)
{
- const char *part = va_arg(*list, const char *);
- int *cols = va_arg(*list, int *);
- int *rows = va_arg(*list, int *);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- Edje *ed = _pd;
Edje_Real_Part *rp;
- if (ret) *ret = EINA_FALSE;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return EINA_FALSE;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
- if (rp->part->type != EDJE_PART_TYPE_TABLE) return;
+ if (!rp) return EINA_FALSE;
+ if (rp->part->type != EDJE_PART_TYPE_TABLE) return EINA_FALSE;
evas_object_table_col_row_size_get(rp->object, cols, rows);
- if (ret) *ret = EINA_TRUE;
+
+ return EINA_TRUE;
}
-EAPI Eina_Bool
-edje_object_part_table_clear(Evas_Object *obj, const char *part, Eina_Bool clear)
+EOLIAN Eina_Bool
+_edje_part_table_clear(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Eina_Bool clear)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do(obj, edje_obj_part_table_clear(part, clear, &ret));
- return ret;
-}
-
-void
-_part_table_clear(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const char *part = va_arg(*list, const char *);
- Eina_Bool clear = va_arg(*list, int);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- Edje *ed = _pd;
Edje_Real_Part *rp;
- if (ret) *ret = EINA_FALSE;
- if ((!ed) || (!part)) return;
+ if ((!ed) || (!part)) return EINA_FALSE;
rp = _edje_real_part_recursive_get(&ed, part);
- if (!rp) return;
- if (rp->part->type != EDJE_PART_TYPE_TABLE) return;
+ if (!rp) return EINA_FALSE;
+ if (rp->part->type != EDJE_PART_TYPE_TABLE) return EINA_FALSE;
_edje_real_part_table_clear(ed, rp, clear);
- if (ret) *ret = EINA_TRUE;
+
+ return EINA_TRUE;
}
static void
@@ -5678,19 +4287,9 @@ edje_evas_global_perspective_get(const Evas *e)
return evas_object_data_get(obj, "_edje_perspective");
}
-EAPI void
-edje_object_perspective_set(Evas_Object *obj, Edje_Perspective *ps)
+EOLIAN void
+_edje_perspective_set(Eo *obj, Edje *ed, Edje_Perspective *ps)
{
- if (!obj) return;
- eo_do(obj, edje_obj_perspective_set(ps));
-}
-
-void
-_perspective_set(Eo *obj, void *_pd, va_list *list)
-{
- Edje_Perspective *ps = va_arg(*list, Edje_Perspective *);
- Edje *ed = _pd;
-
if (!ed) return;
if (ed->persp == ps) return;
if (ed->persp != ps)
@@ -5705,46 +4304,22 @@ _perspective_set(Eo *obj, void *_pd, va_list *list)
_edje_recalc_do(ed);
}
-EAPI const Edje_Perspective *
-edje_object_perspective_get(const Evas_Object *obj)
+EOLIAN const Edje_Perspective*
+_edje_perspective_get(Eo *obj EINA_UNUSED, Edje *ed)
{
- if (!obj) return NULL;
- const Edje_Perspective *ret = NULL;
- eo_do((Eo *)obj, edje_obj_perspective_get(&ret));
- return ret;
-}
-
-void
-_perspective_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- const Edje_Perspective **ret = va_arg(*list, const Edje_Perspective **);
- const Edje *ed = _pd;
- *ret = ed->persp;
+ return ed->persp;
}
#define EDJE_PRELOAD_EMISSION "preload,done"
#define EDJE_PRELOAD_SOURCE NULL
-EAPI Eina_Bool
-edje_object_preload(Evas_Object *obj, Eina_Bool cancel)
+EOLIAN Eina_Bool
+_edje_preload(Eo *obj, Edje *ed, Eina_Bool cancel)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do(obj, edje_obj_preload(cancel, &ret));
- return ret;
-}
-
-void
-_preload(Eo *obj, void *_pd, va_list *list)
-{
- Eina_Bool cancel = va_arg(*list, int);
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- Edje *ed = _pd;
int count;
unsigned int i;
- if (ret) *ret = EINA_FALSE;
- if (!ed) return;
+ if (!ed) return EINA_FALSE;
_edje_recalc_do(ed);
@@ -5826,22 +4401,12 @@ _preload(Eo *obj, void *_pd, va_list *list)
_edje_emit(ed, EDJE_PRELOAD_EMISSION, EDJE_PRELOAD_SOURCE);
}
- if (ret) *ret = EINA_TRUE;
+ return EINA_TRUE;
}
-EAPI void
-edje_object_update_hints_set(Evas_Object *obj, Eina_Bool update)
+EOLIAN void
+_edje_update_hints_set(Eo *obj EINA_UNUSED, Edje *ed, Eina_Bool update)
{
- if (!obj) return;
- eo_do(obj, edje_obj_update_hints_set(update));
-}
-
-void
-_update_hints_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- Eina_Bool update = va_arg(*list, int);
- Edje *ed = _pd;
-
if (!ed) return;
if (ed->update_hints == !!update) return;
@@ -5853,21 +4418,10 @@ _update_hints_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
}
}
-EAPI Eina_Bool
-edje_object_update_hints_get(Evas_Object *obj)
+EOLIAN Eina_Bool
+_edje_update_hints_get(Eo *obj EINA_UNUSED, Edje *ed)
{
- if (!obj) return EINA_FALSE;
- Eina_Bool ret = EINA_FALSE;
- eo_do((Eo *)obj, edje_obj_update_hints_get(&ret));
- return ret;
-}
-
-void
-_update_hints_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
-{
- Eina_Bool *ret = va_arg(*list, Eina_Bool *);
- const Edje *ed = _pd;
- *ret = ed->update_hints;
+ return ed->update_hints;
}
Eina_Bool
@@ -6259,7 +4813,7 @@ _edje_fetch(const Evas_Object *obj)
}
int
-_edje_freeze(Edje *ed)
+_edje_util_freeze(Edje *ed)
{
ed->freeze++;
// printf("FREEZE %i\n", ed->freeze);
@@ -6267,7 +4821,7 @@ _edje_freeze(Edje *ed)
}
int
-_edje_thaw(Edje *ed)
+_edje_util_thaw(Edje *ed)
{
ed->freeze--;
if (ed->freeze < 0)
diff --git a/src/lib/edje/edje_var.c b/src/lib/edje/edje_var.c
index 10ac2dd64d..14f7d2df84 100644
--- a/src/lib/edje/edje_var.c
+++ b/src/lib/edje/edje_var.c
@@ -77,7 +77,7 @@ _edje_var_anim_cb(void *data EINA_UNUSED)
ed = eina_list_data_get(tl);
_edje_ref(ed);
_edje_block(ed);
- _edje_freeze(ed);
+ _edje_util_freeze(ed);
tl = eina_list_remove(tl, ed);
if (!ed->var_pool) continue;
tl2 = NULL;
@@ -159,7 +159,7 @@ _edje_var_anim_cb(void *data EINA_UNUSED)
if (!ed->var_pool->animators)
_edje_anim_list = eina_list_remove(_edje_anim_list, ed);
_edje_unblock(ed);
- _edje_thaw(ed);
+ _edje_util_thaw(ed);
_edje_unref(ed);
}
if (!_edje_anim_list)