You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

3237 lines
108 KiB

/**
* @brief Instantiates a new Edje object.
*
* @param evas A valid Evas handle, the canvas to place the new object
* in
* @return A handle to the new object created, or @c NULL on errors.
*
* This function creates a new Edje smart object, returning its @c
* Evas_Object handle. An Edje object is useless without a (source)
* file set to it, so you'd most probably call edje_object_file_set()
* afterwards, like in:
* @code
* Evas_Object *edje;
*
* edje = edje_object_add(canvas);
* if (!edje)
* {
* fprintf(stderr, "could not create edje object!\n");
* return NULL;
* }
*
* if (!edje_object_file_set(edje, "theme.edj", "group_name"))
* {
* int err = edje_object_load_error_get(edje);
* const char *errmsg = edje_load_error_str(err);
* fprintf(stderr, "could not load 'group_name' from theme.edj: %s",
* errmsg);
*
* evas_object_del(edje);
* return NULL;
* }
*
* @endcode
*
* @note You can get a callback every time edje re-calculates the object
* (either due to animation or some kind of signal or input). This is called
* in-line just after the recalculation has occurred. It is a good idea not
* to go and delete or alter the object inside this callbacks, simply make
* a note that the recalculation has taken place and then do something about
* it outside the callback. To register a callback use code like:
*
* @code
* evas_object_smart_callback_add(edje_obj, "recalc", my_cb, my_cb_data);
* @endcode
*
* @see evas_object_smart_callback_add()
*
* @note Before creating the first Edje object in your code, remember
* to initialize the library, with edje_init(), or unexpected behavior
* might occur.
*/
EAPI Evas_Object *edje_object_add (Evas *evas);
/**
* @brief Preloads the images on the Edje Object in the background.
*
* 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 true on scenarios where you don't need the image data preloaded
* anymore.
*
* @param[in] obj The object.
* @param[in] cancel @c false will add it the preloading work queue, @c true
* will remove it (if it was issued before).
*
* @return @c false if obj was not a valid Edje object otherwise @c true
*/
EAPI Eina_Bool edje_object_preload(Evas_Object *obj, Eina_Bool cancel);
/**
* @brief Adds a callback for an arriving Edje signal, emitted by a given Edje
* object.
*
* Edje signals are one of the communication interfaces between code and a
* given Edje object's 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.
*
* Signal callback registration is powerful, in the way that blobs may be used
* to match multiple signals at once. All the "*?[\" set of @c fnmatch()
* operators can be used, both for emission and source.
*
* Edje has 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 edje_object_signal_callback_add(obj, "mouse,down,*",
* "button.*", signal_cb, NULL); being @ref "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 @"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 emission and source
* parameters of the callback function (e.g. "mouse,down,2" and
* @"button.close"), for each of those events.
*
* @note See @ref edcref "the syntax" for EDC files See also
* @ref edje_object_signal_emit() on how to emits Edje signals from code to a
* an object @ref edje_object_signal_callback_del_full()
*
* @param[in] emission The signal's "emission" string
* @param[in] source The signal's "source" string
* @param[in] func The callback function to be executed when the signal is
* emitted.
* @param[in] data A pointer to data to pass in to func.
*/
EAPI void edje_object_signal_callback_add(Evas_Object *obj, const char *emission, const char *source, Edje_Signal_Cb func, void *data);
/**
* @brief Sends/emits an Edje signal to a given Edje object
*
* This function sends a signal to the object obj. An Edje program, at obj's
* EDC specification level, can respond to a signal by having declared matching
* @'signal' and @'source' fields on its block (see @ref edcref "the syntax"
* for EDC files).
*
* See also @ref edje_object_signal_callback_add() for more on Edje signals.
*
* @param[in] emission The signal's "emission" string
* @param[in] source The signal's "source" string
*/
EAPI void edje_object_signal_emit(Evas_Object *obj, const char *emission, const char *source);
/**
* @brief Removes a signal-triggered callback from an object.
*
* @param obj A valid Evas_Object handle.
* @param emission The emission string.
* @param source The source string.
* @param func The callback function.
* @return The data pointer
*
* This function removes a callback, previously attached to the
* emission 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().
*
*/
EAPI void *edje_object_signal_callback_del (Evas_Object *obj, const char *emission, const char *source, Edje_Signal_Cb func);
/**
* @brief Unregisters/deletes a callback set for an arriving Edje
* signal, emitted by a given Edje object.
*
* @param obj A handle to an Edje object
* @param emission The signal's "emission" string
* @param source The signal's "source" string
* @param func The callback function passed on the callback's
* registration
* @param data The pointer given to be passed as data to @p func
* @return @p data on success, or @c NULL on errors (or if @p data
* had this value)
*
* This function removes a callback, previously attached to the
* emission of a signal, from the object @a obj. The parameters
* @a emission, @a source, @a func and @a data 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().
*
*/
EAPI void *edje_object_signal_callback_del_full(Evas_Object *obj, const char *emission, const char *source, Edje_Signal_Cb func, void *data);
/** Edje file loading error codes one can get - see edje_load_error_str() too. */
typedef enum
{
EDJE_LOAD_ERROR_NONE = 0, /**< No error happened, the loading was successful */
EDJE_LOAD_ERROR_GENERIC = 1, /**< A generic error happened during the loading */
EDJE_LOAD_ERROR_DOES_NOT_EXIST = 2, /**< The file pointed to did not exist */
EDJE_LOAD_ERROR_PERMISSION_DENIED = 3, /**< Permission to read the given file was denied */
EDJE_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED = 4, /**< Resource allocation failed during the loading */
EDJE_LOAD_ERROR_CORRUPT_FILE = 5, /**< The file pointed to was corrupt */
EDJE_LOAD_ERROR_UNKNOWN_FORMAT = 6, /**< The file pointed to had an unknown format */
EDJE_LOAD_ERROR_INCOMPATIBLE_FILE = 7, /**< The file pointed to is incompatible, i.e., it doesn't
* match the library's current version's format */
EDJE_LOAD_ERROR_UNKNOWN_COLLECTION = 8, /**< The group/collection set to load
* from was not found in the file */
EDJE_LOAD_ERROR_RECURSIVE_REFERENCE = 9 /**< The group/collection set to load from had
* <b>recursive references</b> on its components */
} Edje_Load_Error;
/**
* @brief Gets the (last) file loading error for a given Edje object
*
* 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 true, one should check for the reason of failure with this one.
*
* @ref edje_load_error_str()
*
* @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
*/
EAPI Edje_Load_Error edje_object_load_error_get(const Evas_Object *obj);
/**
* @brief Converts the given Edje file load error code into a string
* describing it in English.
*
* @param error the error code, a value in ::Edje_Load_Error.
* @return Always returns a valid string. If the given @p error is not
* supported, <code>"Unknown error"</code> is returned.
*
* edje_object_file_set() is a function which sets an error value,
* afterwards, which can be fetched with
* edje_object_load_error_get(). The function in question is meant
* to be used in conjunction with the latter, for pretty-printing any
* possible error cause.
*/
EAPI const char *edje_load_error_str (Edje_Load_Error error);
/**
* @brief Retrieves 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 x and
* y coordinates are relative to the top left corner of the whole 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-$null geometry pointers'
* pointed variables be set to zero.
*
* @param[in] part The Edje part's name
* @param[out] x A pointer to a variable where to store the part's x coordinate
* @param[out] y A pointer to a variable where to store the part's y coordinate
* @param[out] w A pointer to a variable where to store the part's width
* @param[out] h A pointer to a variable where to store the part's height
*
* @return @c true on success, @c false otherwise
*
* @ingroup Edje_Object
*/
EAPI Eina_Bool edje_object_part_geometry_get(const Evas_Object *obj, const char * part, int *x, int *y, int *w, int *h);
/**
* @brief Returns the state of the Edje part.
*
* @param[in] part The part name
* @param[out] val_ret Part state value
*
* @return The part state: "default" for the default state "" for other states
*
* @ingroup Edje_Object
*/
EAPI const char *edje_object_part_state_get(const Evas_Object *obj, const char * part, double *val_ret);
/**
* @brief Gets a handle to the Evas object implementing a given Edje part, in
* an Edje object.
*
* This function gets a pointer of the Evas object corresponding to a given
* part in the obj object's group.
*
* You should never modify the state of the returned object (with @ref
* evas_object_move() or @ref 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 evas_object_visible_get() or @ref
* evas_object_color_get() for example), though.
*
* @note If the type of Edje part is GROUP, SWALLOW or EXTERNAL, returned
* handle by this function will indicate nothing or transparent rectangle for
* events. Use $.part_swallow_get() in that case.
*
* @param[in] part The Edje part's name
*
* @return A pointer to the Evas object implementing the given part, @c null on
* failure (e.g. the given part doesn't exist)
*
* @ingroup Edje_Object
*/
EAPI const Efl_Canvas_Object *edje_object_part_object_get(const Evas_Object *obj, const char * part);
/**
* @brief Whether this object updates its size hints automatically.
*
* By default edje doesn't set size hints on itself. If this property is set to
* @c true, size hints will be updated after recalculation. Be careful, as
* recalculation may happen often, enabling this property may have a
* considerable performance impact as other widgets will be notified of the
* size hints changes.
*
* A layout recalculation can be triggered by @ref edje_object_size_min_calc(),
* @ref edje_object_size_min_restricted_calc(),
* @ref edje_object_parts_extends_calc() or even any other internal event.
*
* Enable or disable auto-update of size hints.
*
* @param[in] update Whether or not update the size hints.
*
* @ingroup Edje_Object
*/
EAPI void edje_object_update_hints_set(Evas_Object *obj, Eina_Bool update);
/**
* @brief Whether this object updates its size hints automatically.
*
* By default edje doesn't set size hints on itself. If this property is set to
* @c true, size hints will be updated after recalculation. Be careful, as
* recalculation may happen often, enabling this property may have a
* considerable performance impact as other widgets will be notified of the
* size hints changes.
*
* A layout recalculation can be triggered by @ref edje_object_size_min_calc(),
* @ref edje_object_size_min_restricted_calc(),
* @ref edje_object_parts_extends_calc() or even any other internal event.
*
* Whether this object updates its size hints automatically.
*
* @return Whether or not update the size hints.
*
* @ingroup Edje_Object
*/
EAPI Eina_Bool edje_object_update_hints_get(const Evas_Object *obj);
/**
* @brief Calculates 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.
*
* @param[out] minw The minimum required width (return value)
* @param[out] minh The minimum required height (return value)
*
* @ingroup Edje_Object
*/
EAPI void edje_object_size_min_calc(Evas_Object *obj, int *minw, int *minh);
/**
* @brief Calculates the minimum required size for a given Edje object.
*
* This call will trigger an internal recalculation of all parts of the object,
* in order to return its minimum required dimensions for width and height. The
* user might choose to impose those minimum sizes, making the resulting
* calculation to get to values equal or larger than @c restrictedw and
* @c restrictedh, for width and height, respectively.
*
* @note At the end of this call, the object won't be automatically resized to
* the 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 the object will be taken into
* account in this calculation.
*
* @param[out] minw The minimum required width (return value)
* @param[out] minh The minimum required height (return value)
* @param[in] restrictedw The minimum width constraint as input, @c minw can
* not be lower than this
* @param[in] restrictedh The minimum height constraint as input, @c minh can
* not be lower than this
*
* @ingroup Edje_Object
*/
EAPI void edje_object_size_min_restricted_calc(Evas_Object *obj, int *minw, int *minh, int restrictedw, int restrictedh);
/**
* @brief Calculates 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 obj's group/collection. The x and y coordinates are
* relative to the top left corner of the whole obj object's area. Parts placed
* out of the group's boundaries will also be taken in account, so that x and y
* may be negative.
*
* @note On failure, this function will make all non-$null geometry pointers'
* pointed variables be set to zero.
*
* @param[out] x The parts region's X coordinate
* @param[out] y The parts region's Y coordinate
* @param[out] w The parts region's width
* @param[out] h The parts region's height
*
* @return @c true on success, @c false otherwise
*
* @ingroup Edje_Object
*/
EAPI Eina_Bool edje_object_parts_extends_calc(Evas_Object *obj, int *x, int *y, int *w, int *h);
/**
* @brief Forces a Size/Geometry calculation.
*
* Forces the object to recalculate its layout regardless of freeze/thaw.
*
* See also @ref edje_object_freeze and @ref edje_object_thaw.
*
* @ingroup Edje_Object
*/
EAPI void edje_object_calc_force(Evas_Object *obj);
/**
* @brief Freezes the Edje object.
*
* This function puts all changes on hold. Successive freezes will nest,
* requiring an equal number of thaws.
*
* See also @ref edje_object_thaw()
*
* @return The frozen state or 0 on error
*
* @ingroup Edje_Object
*/
EAPI int edje_object_freeze(Evas_Object *obj);
/**
* @brief Thaws the Edje object.
*
* This function thaws the given Edje object.
*
* @note If successive freezes were done, an equal number of thaws will be
* required.
*
* See also @ref edje_object_freeze()
*
* @return The frozen state or 0 if the object is not frozen or on error.
*
* @ingroup Edje_Object
*/
EAPI int edje_object_thaw(Evas_Object *obj);
/**
* @typedef (*Edje_Text_Change_Cb)
*
* Callback prototype for Edje_Text_Change.
* @param data User provided data to pass to the callback
* @param obj The Evas_Object
* @param part The edje part
*/
typedef void (*Edje_Text_Change_Cb) (void *data, Evas_Object *obj, const char *part);
/**
* @}
*/
/**
* @brief Sets the object text callback.
*
* This function sets the callback to be called when the text changes.
*
* @param[in] obj The object.
* @param[in] func The callback function to handle the text change
* @param[in] data The data associated to the callback function.
*/
EAPI void edje_object_text_change_cb_set(Evas_Object *obj, Edje_Text_Change_Cb func, void *data);
/**
* @addtogroup Edje_Object_Communication_Interface_Message
*
* @{
*/
typedef struct _Edje_Message_String Edje_Message_String; /**< Alias for _Edje_Message_String. */
typedef struct _Edje_Message_Int Edje_Message_Int; /**< Alias for _Edje_Message_Int */
typedef struct _Edje_Message_Float Edje_Message_Float; /**< Alias for _Edje_Message_Float */
typedef struct _Edje_Message_String_Set Edje_Message_String_Set; /**< Alias for _Edje_Message_String_Set */
typedef struct _Edje_Message_Int_Set Edje_Message_Int_Set; /**< Alias for _Edje_Message_Int_Set */
typedef struct _Edje_Message_Float_Set Edje_Message_Float_Set; /**< Alias for _Edje_Message_Float_Set */
typedef struct _Edje_Message_String_Int Edje_Message_String_Int; /**< Alias for _Edje_Message_String_Int */
typedef struct _Edje_Message_String_Float Edje_Message_String_Float; /**< Alias for _Edje_Message_String_Float */
typedef struct _Edje_Message_String_Int_Set Edje_Message_String_Int_Set; /**< Alias for _Edje_Message_String_Int_Set */
typedef struct _Edje_Message_String_Float_Set Edje_Message_String_Float_Set; /**< Alias for _Edje_Message_String_Float_Set */
struct _Edje_Message_String
{
char *str; /**< The message's string pointer */
}; /**< Structure passed as value on #EDJE_MESSAGE_STRING messages. The string in it is automatically freed Edje if passed to you by Edje */
struct _Edje_Message_Int
{
int val; /**< The message's value */
}; /**< Structure passed as value on #EDJE_MESSAGE_INT messages */
struct _Edje_Message_Float
{
double val; /**< The message's value */
}; /**< Structure passed as value on #EDJE_MESSAGE_FLOAT messages */
struct _Edje_Message_String_Set
{
int count; /**< The size of the message's array (may be greater than 1) */
char *str[1]; /**< The message's @b array of string pointers */
}; /**< Structure passed as value on #EDJE_MESSAGE_STRING_SET messages. The array in it is automatically freed if passed to you by Edje */
struct _Edje_Message_Int_Set
{
int count; /**< The size of the message's array (may be greater than 1) */
int val[1]; /**< The message's @b array of integers */
}; /**< Structure passed as value on #EDJE_MESSAGE_INT_SET messages. The array in it is automatically freed if passed to you by Edje */
struct _Edje_Message_Float_Set
{
int count; /**< The size of the message's array (may be greater than 1) */
double val[1]; /**< The message's @b array of floats */
}; /**< Structure passed as value on #EDJE_MESSAGE_FLOAT_SET messages. The array in it is automatically freed if passed to you by Edje */
struct _Edje_Message_String_Int
{
char *str; /**< The message's string value */
int val; /**< The message's integer value */
}; /**< Structure passed as value on #EDJE_MESSAGE_STRING_INT messages. The string in it is automatically freed if passed to you by Edje */
struct _Edje_Message_String_Float
{
char *str; /**< The message's string value */
double val; /**< The message's float value */
}; /**< Structure passed as value on #EDJE_MESSAGE_STRING_FLOAT messages. The string in it is automatically freed if passed to you by Edje */
struct _Edje_Message_String_Int_Set
{
char *str; /**< The message's string value */
int count; /**< The size of the message's array (may be greater than 1) */
int val[1]; /**< The message's @b array of integers */
}; /**< Structure passed as value on #EDJE_MESSAGE_STRING_INT_SET messages. The array and string in it are automatically freed if passed to you by Edje */
struct _Edje_Message_String_Float_Set
{
char *str; /**< The message's string value */
int count; /**< The size of the message's array (may be greater than 1) */
double val[1]; /**< The message's @b array of floats */
}; /**< Structure passed as value on #EDJE_MESSAGE_STRING_FLOAT_SET messages. The array and string in it are automatically freed if passed to you by Edje */
/** Identifiers of Edje message types, which can be sent back and forth code
* and a given Edje object's theme file/group.
*
* @ref edje_object_message_send
* @ref edje_object_message_handler_set
*/
typedef enum
{
EDJE_MESSAGE_NONE = 0, /**< No message type */
EDJE_MESSAGE_SIGNAL = 1, /**< DO NOT USE THIS */
EDJE_MESSAGE_STRING = 2, /**< A message with a string as value. Use
* #Edje_Message_String structs as message body, for
* this type. */
EDJE_MESSAGE_INT = 3, /**< A message with an integer number as value. Use
* #Edje_Message_Int structs as message body, for this
* type. */
EDJE_MESSAGE_FLOAT = 4, /**< A message with a floating pointer number as
* value. Use #Edje_Message_Float structs as message
* body, for this type. */
EDJE_MESSAGE_STRING_SET = 5, /**< A message with a list of strings as value.
* Use #Edje_Message_String_Set structs as
* message body, for this type. */
EDJE_MESSAGE_INT_SET = 6, /**< A message with a list of integer numbers as
* value. Use #Edje_Message_Int_Set structs as
* message body, for this type. */
EDJE_MESSAGE_FLOAT_SET = 7, /**< A message with a list of floating point
* numbers as value. Use #Edje_Message_Float_Set
* structs as message body, for this type. */
EDJE_MESSAGE_STRING_INT = 8, /**< A message with a struct containing a string
* and an integer number as value. Use
* #Edje_Message_String_Int structs as message
* body, for this type. */
EDJE_MESSAGE_STRING_FLOAT = 9, /**< A message with a struct containing a
* string and a floating point number as
* value. Use #Edje_Message_String_Float
* structs as message body, for this type. */
EDJE_MESSAGE_STRING_INT_SET = 10, /**< A message with a struct containing a
* string and list of integer numbers as
* value. Use #Edje_Message_String_Int_Set
* structs as message body, for this type.
*/
EDJE_MESSAGE_STRING_FLOAT_SET = 11 /**< A message with a struct containing a
* string and list of floating point
* numbers as value. Use
* #Edje_Message_String_Float_Set structs
* as message body, for this type. */
} Edje_Message_Type;
typedef void (*Edje_Message_Handler_Cb) (void *data, Evas_Object *obj, Edje_Message_Type type, int id, void *msg); /**< Edje message handler callback functions's prototype definition. @c data will have the auxiliary data pointer set at the time the callback registration. @c obj will be a pointer the Edje object where the message comes from. @c type will identify the type of the given message and @c msg will be a pointer the message's contents, de facto, which depend on @c type. */
/**
* @brief Sets 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 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 obj.
*
* See also @ref edje_object_message_send()
*
* @param[in] func The function to handle messages coming from obj
* @param[in] data Auxiliary data to be passed to func
*/
EAPI void edje_object_message_handler_set(Evas_Object *obj, Edje_Message_Handler_Cb func, void *data);
/**
* @brief Sends an (Edje) message to a given Edje object
*
* This function sends an Edje message to obj and to all of its child objects,
* if it has any (swallowed objects are one kind of child object). type and msg
* must be matched accordingly, as documented in #Edje_Message_Type.
*
* The 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 from obj is set with
* edje_object_message_handler_set().
*
* @param[in] type The type of message to send to obj
* @param[in] id A identification number for the message to be sent
* @param[in] msg The message's body, a struct depending on type
*/
EAPI void edje_object_message_send(Evas_Object *obj, Edje_Message_Type type, int id, void *msg);
/**
* @brief Processes an object's message queue.
*
* This function goes through the object message queue processing the pending
* messages for this specific Edje object. Normally they'd be processed only
* at idle time. Child objects will not be affected.
*
* @see edje_object_message_signal_recursive_process
*/
EAPI void edje_object_message_signal_process(Evas_Object *obj);
/**
* @brief Processes an object's message queue recursively.
*
* This function goes through the object message queue processing the pending
* messages for this specific Edje object. Normally they'd be processed only
* at idle time. This will also propagate the processing to all child objects.
*
* @see edje_object_message_signal_process
*
* @since 1.20
*/
EAPI void edje_object_message_signal_recursive_process(Evas_Object *obj);
/**
* @}
*/
/**
* @addgroup Edje_Object
*
* @{
*/
/**
* @brief Facility to query the type of the given parameter of the given part.
*
* @param[in] part The part name
* @param[in] param The parameter name to use
*
* @return @ref EDJE_EXTERNAL_PARAM_TYPE_MAX on errors, or another value from
* @ref Edje_External_Param_Type on success.
*
* @ingroup Edje_Object
*/
EAPI Edje_External_Param_Type edje_object_part_external_param_type_get(const Evas_Object *obj, const char *part, const char * param);
/**
* @brief Sets 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.
*
* @param[in] part The part name
* @param[in] 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 false will be returned.
*
* @return @c true if everything went fine, @c false on errors.
*
* @ingroup Edje_Object
*/
EAPI Eina_Bool edje_object_part_external_param_set(Evas_Object *obj, const char *part, const Edje_External_Param *param);
/**
* @brief Gets 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.
*
* @param[in] part The part name
* @param[out] 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 false will be returned.
*
* @return @c true if everything went fine and param members are filled with
* information, @c false on errors and param member values are not set or
* valid.
*
* @ingroup Edje_Object
*/
EAPI Eina_Bool edje_object_part_external_param_get(const Evas_Object *obj, const char *part, Edje_External_Param *param);
/**
* @brief Gets 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 never delete this object!
*
* @param[in] part The part name
*
* @return The externally created object, or @c null if there is none or part
* is not an external.
*
* @ingroup Edje_Object
*/
EAPI Evas_Object *edje_object_part_external_object_get(const Evas_Object *obj, const char * part);
/**
* @brief Gets an object contained in an part of type EXTERNAL
*
* The content string must not be @c null. Its actual value depends on the code
* providing the EXTERNAL.
*
* @param[in] part The name of the part holding the EXTERNAL
* @param[in] content A string identifying which content from the EXTERNAL to
* get
*
* @return Canvas object
*
* @ingroup Edje_Object
*/
EAPI Evas_Object *edje_object_part_external_content_get(const Evas_Object *obj, const char *part, const char *content);
/**
* @}
*/
/**
* @deprecated use evas_object_size_hint_min_set() instead.
* @brief Sets the object minimum size.
*
* @param obj A valid Evas_Object handle
* @param minw The minimum width
* @param minh The minimum height
*
* This sets the minimum size restriction for the object.
*
*/
EINA_DEPRECATED EAPI void edje_extern_object_min_size_set (Evas_Object *obj, Evas_Coord minw, Evas_Coord minh);
/**
* @deprecated use evas_object_size_hint_max_set() instead.
* @brief Sets the object maximum size.
*
* @param obj A valid Evas_Object handle
* @param maxw The maximum width
* @param maxh The maximum height
*
* This sets the maximum size restriction for the object.
*
*/
EINA_DEPRECATED EAPI void edje_extern_object_max_size_set (Evas_Object *obj, Evas_Coord maxw, Evas_Coord maxh);
/**