From 2be615916a019b82f772203ffd35aed4ff21732e Mon Sep 17 00:00:00 2001 From: Yossi Kantor Date: Tue, 18 Mar 2014 16:00:14 +0200 Subject: [PATCH] Eolian: Integration of Edje and Edje Edit --- src/Makefile.am | 4 +- src/Makefile_Edje.am | 19 + src/lib/edje/Edje_Eo.h | 11 +- src/lib/edje/Edje_Legacy.h | 2 +- src/lib/edje/edje.eo | 2507 +++++++++++++++++++++++++ src/lib/edje/edje_calc.c | 8 +- src/lib/edje/edje_callbacks.c | 16 +- src/lib/edje/edje_edit.c | 60 +- src/lib/edje/edje_edit.eo | 10 + src/lib/edje/edje_embryo.c | 22 +- src/lib/edje/edje_external.c | 153 +- src/lib/edje/edje_load.c | 65 +- src/lib/edje/edje_lua2.c | 22 +- src/lib/edje/edje_message_queue.c | 46 +- src/lib/edje/edje_private.h | 12 +- src/lib/edje/edje_program.c | 166 +- src/lib/edje/edje_smart.c | 411 +---- src/lib/edje/edje_util.c | 2838 +++++++---------------------- src/lib/edje/edje_var.c | 4 +- 19 files changed, 3442 insertions(+), 2934 deletions(-) create mode 100644 src/lib/edje/edje.eo create mode 100644 src/lib/edje/edje_edit.eo 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)