kimcinoo
/
efl
forked from enlightenment/efl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

add stuff for evoak... and edje list vars... :) 

SVN revision: 10424
This commit is contained in:
Carsten Haitzler 2004-06-03 09:14:55 +00:00
parent e7b077d975
commit 8c5069a658
6 changed files with 1236 additions and 180 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

542
legacy/edje/src/lib/Edje.h
View File

@ -21,68 +21,524 @@
extern "C" {
#endif
/***************************************************************************/
/** Initialize the EDJE library.
*
* @return The new init count.
*/
int edje_init (void);
/** Shutdown the EET library.
*
* @return The new init count.
*/
int edje_shutdown (void);
/** Set the frametime
* @param t The frametime
*
* Sets the frametime in seconds, by default this is 1/60.
*/
void edje_frametime_set (double t);
/** Get the frametime
* @return The frametime
*
* Returns the frametime in seconds, by default this is 1/60.
*/
double edje_frametime_get (void);
/** Freeze all objects in the Edje.
*/
void edje_freeze (void);
/** Thaw all objects in Edje
*/
void edje_thaw (void);
/** Get the collection list from the edje file ?!
* @param file The file path?
*
* @return The file Evas List of files
*/
Evas_List *edje_file_collection_list (const char *file);
/** Free file collection ?!
* @param lst The Evas List of files
*
* Frees the file collection.
*/
void edje_file_collection_list_free (Evas_List *lst);
/** Get edje file data
* @param file The file
* @param key The data key
* @return The file data string
*/
char *edje_file_data_get (const char *file, const char *key);
/** Set Edje color class
* @param color_class
* @param r Object Red value
* @param g Object Green value
* @param b Object Blue value
* @param a Object Alpha value
* @param r2 Outline Red value
* @param g2 Outline Green value
* @param b2 Outline Blue value
* @param a2 Outline Alpha value
* @param r3 Shadow Red value
* @param g3 Shadow Green value
* @param b3 Shadow Blue value
* @param a3 Shadow Alpha value
*
* Sets the color class for the Edje.
*/
void edje_color_class_set(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);
/** Set the Edje text class
* @param text_class The text class name ?!
* @param font The font name
* @param size The font size
*
* This sets the Edje text class ?!
*/
void edje_text_class_set(const char *text_class, const char *font, Evas_Font_Size size);
/** Set 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.
*/
void edje_extern_object_min_size_set (Evas_Object *obj, Evas_Coord minw, Evas_Coord minh);
/** Set the object maximum size
* @param obj A vaild Evas_Object handle
* @param maxw The maximum width
* @param maxh The maximum height
*
* This sets the maximum size restriction for the object.
*/
void edje_extern_object_max_size_set (Evas_Object *obj, Evas_Coord maxw, Evas_Coord maxh);
/** Contruct edje object ?! What's the correct terminology?
* @param evas A valid Evas handle
* @return The Evas_Object pointer.
*/
Evas_Object *edje_object_add (Evas *evas);
/** Get Edje object data
* @param obj A valid Evas_Object handle
* @param key The data key
* @return The data string
*/
const char *edje_object_data_get (Evas_Object *obj, const char *key);
int edje_object_file_set (Evas_Object *o, const char *file, const char *part);
void edje_object_file_get (Evas_Object *o, const char **file, const char **part);
int edje_object_load_error_get (Evas_Object *o);
void edje_object_signal_callback_add (Evas_Object *o, const char *emission, const char *source, void (*func) (void *data, Evas_Object *o, const char *emission, const char *source), void *data);
void *edje_object_signal_callback_del (Evas_Object *o, const char *emission, const char *source, void (*func) (void *data, Evas_Object *o, const char *emission, const char *source));
void edje_object_signal_emit (Evas_Object *o, const char *emission, const char *source);
void edje_object_play_set (Evas_Object *o, int play);
int edje_object_play_get (Evas_Object *o);
void edje_object_animation_set (Evas_Object *o, int on);
int edje_object_animation_get (Evas_Object *o);
int edje_object_freeze (Evas_Object *o);
int edje_object_thaw (Evas_Object *o);
void edje_object_color_class_set (Evas_Object *o, 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);
void edje_object_text_class_set (Evas_Object *o, const char *text_class, const char *font, Evas_Font_Size size);
void edje_object_size_min_get (Evas_Object *o, Evas_Coord *minw, Evas_Coord *minh);
void edje_object_size_max_get (Evas_Object *o, Evas_Coord *maxw, Evas_Coord *maxh);
void edje_object_size_min_calc (Evas_Object *o, Evas_Coord *minw, Evas_Coord *minh);
int edje_object_part_exists (Evas_Object *o, const char *part);
void edje_object_part_geometry_get (Evas_Object *o, const char *part, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h);
void edje_object_part_text_set (Evas_Object *o, const char *part, const char *text);
const char *edje_object_part_text_get (Evas_Object *o, const char *part);
void edje_object_part_swallow (Evas_Object *o, const char *part, Evas_Object *o_swallow);
void edje_object_part_unswallow (Evas_Object *o, Evas_Object *o_swallow);
Evas_Object *edje_object_part_swallow_get (Evas_Object *o, const char *part);
const char *edje_object_part_state_get (Evas_Object *o, const char *part, double *val_ret);
int edje_object_part_drag_dir_get (Evas_Object *o, const char *part);
void edje_object_part_drag_value_set (Evas_Object *o, const char *part, double dx, double dy);
void edje_object_part_drag_value_get (Evas_Object *o, const char *part, double *dx, double *dy);
void edje_object_part_drag_size_set (Evas_Object *o, const char *part, double dw, double dh);
void edje_object_part_drag_size_get (Evas_Object *o, const char *part, double *dw, double *dh);
void edje_object_part_drag_step_set (Evas_Object *o, const char *part, double dx, double dy);
void edje_object_part_drag_step_get (Evas_Object *o, const char *part, double *dx, double *dy);
void edje_object_part_drag_page_set (Evas_Object *o, const char *part, double dx, double dy);
void edje_object_part_drag_page_get (Evas_Object *o, const char *part, double *dx, double *dy);
void edje_object_part_drag_step (Evas_Object *o, const char *part, double dx, double dy);
void edje_object_part_drag_page (Evas_Object *o, const char *part, double dx, double dy);
int edje_object_variable_id_get (Evas_Object *o, char *name);
int edje_object_variable_int_get (Evas_Object *o, int id);
void edje_object_variable_int_set (Evas_Object *o, int id, int val);
double edje_object_variable_float_get (Evas_Object *o, int id);
void edje_object_variable_float_set (Evas_Object *o, int id, double val);
char *edje_object_variable_str_get (Evas_Object *o, int id);
void edje_object_variable_str_set (Evas_Object *o, int id, char *str);
/** Sets the .eet location and loads the Edje. ?! Assuming eet file
* @param obj A valid Evas_Object handle
* @param file The path to the .eet file
* @param part The group name in the eet
* @return 0 on Error\n
* 1 on Success
*
* This loads the .eet file and sets up the Edje.
*/
int edje_object_file_set (Evas_Object *obj, const char *file, const char *part);
/** Get the .eet location and group for the Evas Object. ?! Assuming eet file
* @param obj A valid Evas_Object handle
* @param file The .eet file location pointer
* @param part The eet part pointer
*
* @ return 0 on Error\n
* 1 on Success
*
* This gets the .eet file location and group for the given Evas_Object.
*/
void edje_object_file_get (Evas_Object *obj, const char **file, const char **part);
/** Get the Edje load error
* @param obj A valid Evas_Object handle
*
* @return The load error from the object's Edje. 1/0, one being no error ?!
*/
int edje_object_load_error_get (Evas_Object *obj);
/** Adds a callback for the object.
* @param obj A valid Evas_Object handle
* @param emission Signal to activate callback ?!
* @param source Source of signal
* @param func The function to be executed when the callback is signaled
*
* Creates a callback for the object to execute the given function.
*/
void edje_object_signal_callback_add (Evas_Object *obj, const char *emission, const char *source, void (*func) (void *data, Evas_Object *obj, const char *emission, const char *source), void *data);
/** Delete an object callback
* @param obj A valid Evas_Object handle
* @param emission ?!
* @param source ?!
*
* Deletes an existing callback
*/
void *edje_object_signal_callback_del (Evas_Object *obj, const char *emission, const char *source, void (*func) (void *data, Evas_Object *obj, const char *emission, const char *source));
/** Send a signal to the Edje
* @param A vaild Evas_Object handle
* @param emission The signal
* @param source The signal source
*
* This sends a signal to the edje. These are defined in the programs section of an edc. ?! Better description of signals
*/
void edje_object_signal_emit (Evas_Object *obj, const char *emission, const char *source);
/** Set the Edje to play or pause
* @param obj A vaild Evas_Object handle
* @param play Play instruction (1 to play, 0 to pause)
*
* This sets the Edje to play or pause depending on the parameter. This has no effect if the Edje is already in that state. ?! Better description
*/
void edje_object_play_set (Evas_Object *obj, int play);
/** Get the Edje play/pause state
* @param obj A valid Evas_Object handle
* @return 0 if Edje not connected, Edje delete_me, or Edje paused\n
* 1 if Edje set to play
*/
int edje_object_play_get (Evas_Object *obj);
/** Set
* @param obj A valid Evas_Object handle
* @param on ?!
*/
void edje_object_animation_set (Evas_Object *obj, int on);
/** Get the Edje object animation state
* @param obj A valid Evas_Object handle
* @return 0 on Error or not animated\n ?!
* 1 if animated
*/
int edje_object_animation_get (Evas_Object *obj);
/** Freeze object
* @param obj A valid Evas_Object handle
* @return The frozen state\n
* 0 on Error
*
* This puts all changes on hold. Successive freezes will nest, requiring an equal number of thaws.
*/
int edje_object_freeze (Evas_Object *obj);
/** Thaw object
* @param obj A valid Evas_Object handle
* @return The frozen state\n
* 0 on Error
*
* This allows frozen changes to occur.
*/
int edje_object_thaw (Evas_Object *obj);
/** Sets the object color class
* @param color_class
* @param r Object Red value
* @param g Object Green value
* @param b Object Blue value
* @param a Object Alpha value
* @param r2 Outline Red value
* @param g2 Outline Green value
* @param b2 Outline Blue value
* @param a2 Outline Alpha value
* @param r3 Shadow Red value
* @param g3 Shadow Green value
* @param b3 Shadow Blue value
* @param a3 Shadow Alpha value
*
* Applys the color class to the object, where the first color is the object, the second is the outline, and the third is the shadow.
*/
void 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);
/** Sets Edje text class
* @param text_class The text class name
* @param font Font name
* @param size Font Size
*
* Sets the text class for the Edje.
*/
void edje_object_text_class_set (Evas_Object *obj, const char *text_class, const char *font, Evas_Font_Size size);
/** Get the minimum size for an object
* @param obj A valid Evas_Object handle
* @param minw Minimum width pointer
* @param minh Minimum height pointer
*
* Gets the object's minimum size values from the Edje. These are set to zero if no Edje is connected to the Evas Object.
*/
void edje_object_size_min_get (Evas_Object *obj, Evas_Coord *minw, Evas_Coord *minh);
/** Get the maximum size for an object
* @param obj A valid Evas_Object handle
* @param maxw Maximum width pointer
* @param maxh Maximum height pointer
*
* Gets the object's maximum size values from the Edje. These are set to zero if no Edje is connected to the Evas Object.
*/
void edje_object_size_max_get (Evas_Object *obj, Evas_Coord *maxw, Evas_Coord *maxh);
/** Calculate minimum size
* @param obj A valid Evas_Object handle
* @param minw Minimum width pointer
* @param minh Minimum height pointer
*
* Calculates the object's minimum size ?!
*/
void edje_object_size_min_calc (Evas_Object *obj, Evas_Coord *minw, Evas_Coord *minh);
/** Check if Edje part exists
* @param obj A valid Evas_Object handle
* @param part The part name to check
* @return 0 on Error\n
* 1 if Edje part exists
*/
int edje_object_part_exists (Evas_Object *obj, const char *part);
/** Get Edje part geometry
* @param obj A valid Evas_Object handle
* @param part The Edje part
* @param x The x coordinate pointer
* @param y The y coordinate pointer
* @param w The width pointer
* @param h The height pointer
*
* Gets the Edje part geometry
*/
void edje_object_part_geometry_get (Evas_Object *obj, const char *part, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h);
/** Sets the callback to be called when text for the specified part is changed
* @param obj A valid Evas Object handle
* @param part The part name
* @param func The function callback to call when text has been changed
* @param data The data to pass to the callback's data parameter
*/
void edje_object_text_change_cb_set(Evas_Object *obj, void (*func) (void *data, Evas_Object *obj, const char *part), void *data);
/** Sets the text for an object part
* @param obj A valid Evas Object handle
* @param part The part name
* @param text The text string
*/
void edje_object_part_text_set (Evas_Object *obj, const char *part, const char *text);
/** Returns the text of the object part
* @param obj A valid Evas_Object handle
* @param part The part name
* @return The text string
*/
const char *edje_object_part_text_get (Evas_Object *obj, const char *part);
/** Swallows an object into the edje
* @param obj A valid Evas_Object handle
* @param part The part name
* @param obj_swallow The object to swallow
*
* Describe swallowing ?!
*/
void edje_object_part_swallow (Evas_Object *obj, const char *part, Evas_Object *obj_swallow);
/** Unswallow an object
* @param obj A valid Evas_Object handle
* @param obj_swallow The swallowed object
*
* Describe unswallowing ?!
*/
void edje_object_part_unswallow (Evas_Object *obj, Evas_Object *obj_swallow);
/** Get the swallowed part ?!
* @param obj A valid Evas_Object handle
* @param part The part name
* @return The swallowed object
*/
Evas_Object *edje_object_part_swallow_get (Evas_Object *obj, const char *part);
/** Returns the state of the edje part
* @param obj A valid Evas_Object handle
* @param part The part name
* @param val_ret
*
* @return The part state:\n
* "default" for the default state\n
* "" for other states
*/
/* FIXME: Correctly return other states */
const char *edje_object_part_state_get (Evas_Object *obj, const char *part, double *val_ret);
/** Determine if part is dragable ?!
* @param obj A valid Evas_Object handle
* @param part The part name
*
* @return 1 if dragable
* 0 if Error/not ?!
*/
int edje_object_part_drag_dir_get (Evas_Object *obj, const char *part);
/** Set drag value
* @param obj A valid Evas_Object handle
* @param part The part name
* @param dx Change in x ?!
* @param dy Change in y ?!
*/
void edje_object_part_drag_value_set (Evas_Object *obj, const char *part, double dx, double dy);
/** Get the part drag value
* @param obj A valid Evas_Object handle
* @param part The part name
* @param dx The dx pointer
* @param dy The dy pointer
*
* Gets the drag values for the object part ?!
*/
void edje_object_part_drag_value_get (Evas_Object *obj, const char *part, double *dx, double *dy);
/** Set the drag size
* @param obj A valid Evas_Object handle
* @param part The part name
* @param dw The drag width
* @param dh The drag height
*
* Does?!
*/
void edje_object_part_drag_size_set (Evas_Object *obj, const char *part, double dw, double dh);
/** Get the drag size
* @param obj A valid Evas_Object handle
* @param part The part name
* @param dw The drag width pointer
* @param dh The drag height pointer
*
* Gets the drag size for the Edje object.
*/
void edje_object_part_drag_size_get (Evas_Object *obj, const char *part, double *dw, double *dh);
/** Sets the drag step
* @param obj A valid Evas_Object handle
* @param part The part name
* @param dx The x step
* @param dy The y step
*
* Sets the x and y step.?!
*/
void edje_object_part_drag_step_set (Evas_Object *obj, const char *part, double dx, double dy);
/** Gets the drag step
* @param obj A valid Evas_Object handle
* @param part The part
* @param dx The x step pointer
* @param dy The y step pointer
*
* Gets the x and y step for the Edje object ?!
*/
void edje_object_part_drag_step_get (Evas_Object *obj, const char *part, double *dx, double *dy);
/** Sets the drag page
* @param obj A valid Evas_Object handle
* @param part The part name
* @param dx ?!
* @param df ?!
*
* Sets the drag page dx dy
*/
void edje_object_part_drag_page_set (Evas_Object *obj, const char *part, double dx, double dy);
/** Gets the drag page
* @param obj A valid Evas_Object handle
* @param part The part name
* @param dx The x drag pointer
* @param dy The y drag pointer
*
* Gets the x and y drag page settings.
*/
void edje_object_part_drag_page_get (Evas_Object *obj, const char *part, double *dx, double *dy);
/** Step now ?!
* @param obj A valid Evas_Object handle
* @param part The part name
* @param dx The x step
* @param dy The y step
*
* Steps x,y ?!
*/
void edje_object_part_drag_step (Evas_Object *obj, const char *part, double dx, double dy);
/** Page now
* @param obj A valid Evas_Object handle
* @param part The part name
* @param dx The x page
* @param dy The y page
*
* Pages x,y ?!
*/
void edje_object_part_drag_page (Evas_Object *obj, const char *part, double dx, double dy);
/** Returns the variable ID
* @param obj A valid Evas_Object handle
* @param name The variable name
*
* @return Variable ID\n
* 0 on Error.
*/
int edje_object_variable_id_get (Evas_Object *obj, char *name);
/** Returns the variable int
* @param obj A valid Evas_Object handle
* @param id The variable id
*
* @return Variable int\n
* 0 on Error
*/
int edje_object_variable_int_get (Evas_Object *obj, int id);
/** Sets the variable int
* @param obj A valid Evas_Object handle
* @param id The variable id
* @param val The int value to set
*/
void edje_object_variable_int_set (Evas_Object *obj, int id, int val);
/** Returns the variable float
* @param obj A valid Evas_Object handle
* @param id The variable id
*
* @return Variable float\n
* 0 on Error
*/
double edje_object_variable_float_get (Evas_Object *obj, int id);
/** Sets the variable float
* @param obj A valid Evas_Object handle
* @param id The variable id
* @param val The float value to set
*/
void edje_object_variable_float_set (Evas_Object *obj, int id, double val);
/** Returns the variable string
* @param obj A valid Evas_Object handle
* @param id The variable id
*
* @return Variable String\n
* 0 on Error
*/
char *edje_object_variable_str_get (Evas_Object *obj, int id);
/** Sets the variable string
* @param obj A valid Evas_Object handle
* @param id The variable id
* @param str The string value to set
*/
void edje_object_variable_str_set (Evas_Object *obj, int id, char *str);
#ifdef __cplusplus
}

21
legacy/edje/src/lib/Edje_Edit.h
View File

@ -127,6 +127,8 @@ Edje_Edit_Image *edje_edit_iamge_get_by_id(int id);
#define EDJE_VAR_INT 1
#define EDJE_VAR_FLOAT 2
#define EDJE_VAR_STRING 3
#define EDJE_VAR_LIST 4
#define EDJE_VAR_HASH 5
#define EDJE_ASPECT_PREFER_NONE 0
#define EDJE_ASPECT_PREFER_VERTICAL 1
@ -387,6 +389,8 @@ typedef struct _Edje_Var Edje_Var;
typedef struct _Edje_Var_Int Edje_Var_Int;
typedef struct _Edje_Var_Float Edje_Var_Float;
typedef struct _Edje_Var_String Edje_Var_String;
typedef struct _Edje_Var_List Edje_Var_List;
typedef struct _Edje_Var_Hash Edje_Var_Hash;
typedef struct _Edje_Var_Animator Edje_Var_Animator;
typedef struct _Edje_Var_Timer Edje_Var_Timer;
typedef struct _Edje_Var_Pool Edje_Var_Pool;
@ -438,6 +442,11 @@ struct _Edje
Edje_Real_Part **table_parts;
int table_programs_size;
Edje_Program **table_programs;
struct {
void (*func) (void *data, Evas_Object *obj, const char *part);
void *data;
} text_change;
};
struct _Edje_Real_Part
@ -608,6 +617,16 @@ struct _Edje_Var_String
char *v;
};
struct _Edje_Var_List
{
Evas_List *v;
};
struct _Edje_Var_Hash
{
Evas_Hash *v;
};
struct _Edje_Var_Timer
{
Edje *edje;
@ -644,6 +663,8 @@ struct _Edje_Var
Edje_Var_Int i;
Edje_Var_Float f;
Edje_Var_String s;
Edje_Var_List l;
Edje_Var_Hash h;
} data;
};

39
legacy/edje/src/lib/edje_embryo.c
View File

@ -4,6 +4,13 @@
/*
* ALREADY EXPORTED BY EMBRYO:
*
* enum Float_Round_Method {
* ROUND, FLOOR, CEIL, TOZERO
* };
* enum Float_Angle_Mode {
* RADIAN, DEGREES, GRADES
* };
*
* Float:atof(string[]);
* Float:fract(Float:value);
* round(Float:value, Float_Round_Method:method=ROUND);
@ -31,6 +38,10 @@
* strchr(str[], ch[]);
* strrchr(str[], ch[]);
* rand();
* Float:randf();
* Float:seconds();
* date(&year, &month, &day, &yearday, &weekday, &hr, &min, &Float:sec);
*
*/
#define CHKPARAM(n) if (params[0] != (sizeof(Embryo_Cell) * (n))) return 0;
@ -60,6 +71,19 @@ static void _edje_embryo_globals_init(Edje *ed);
*
* implemented so far as examples:
*
* get_int(id)
* set_int(id, v)
* Float:get_float (id)
* set_float(id, Float:v)
* get_strlen(id)
* get_str(id, dst[], maxlen)
* set_str(id, str[])
* ** lists/arrays for stored variables
* ** dynamic allocation (just use cell as index to dynamic block)
* timer(Float:in, fname[], val);
* cancel_timer(id)
* anim(Float:len, fname[], val)
* cancel_anim(id)
* emit(sig[], src[])
* set_state(part_id, state[], Float:state_val)
* set_tween_state(part_id, Float:tween, state1[], Float:state1_val, state2[], Float:state2_val)
@ -87,6 +111,8 @@ static void _edje_embryo_globals_init(Edje *ed);
*
* still need to implement this:
*
* ** part_id and program_id need to be able to be "found" from strings
*
* get_drag_count(part_id, &Float:dx, &Float:&dy)
* set_drag_count(part_id, Float:dx, Float:dy)
* set_drag_confine(part_id, confine_part_id)
@ -102,7 +128,6 @@ static void _edje_embryo_globals_init(Edje *ed);
* set_clip(part_id, clip_part_id)
* get_clip(part_id)
*/
/* MODIFY STATE VALUES
*
* set_state_val(part_id, state[], Float:state_val, Param:param, ...)
@ -601,9 +626,9 @@ _edje_embryo_fn_set_drag(Embryo_Program *ep, Embryo_Cell *params)
return(0);
}
/* text_set(part_id, str[]) */
/* set_text(part_id, str[]) */
static Embryo_Cell
_edje_embryo_fn_text_set(Embryo_Program *ep, Embryo_Cell *params)
_edje_embryo_fn_set_text(Embryo_Program *ep, Embryo_Cell *params)
{
Edje *ed;
int part_id = 0;
@ -622,9 +647,9 @@ _edje_embryo_fn_text_set(Embryo_Program *ep, Embryo_Cell *params)
return(0);
}
/* text_get(part_id, dst[], maxlen) */
/* get_text(part_id, dst[], maxlen) */
static Embryo_Cell
_edje_embryo_fn_text_get(Embryo_Program *ep, Embryo_Cell *params)
_edje_embryo_fn_get_text(Embryo_Program *ep, Embryo_Cell *params)
{
Edje *ed;
int part_id = 0;
@ -881,8 +906,8 @@ _edje_embryo_script_init(Edje *ed)
embryo_program_native_call_add(ep, "get_drag_dir", _edje_embryo_fn_get_drag_dir);
embryo_program_native_call_add(ep, "get_drag", _edje_embryo_fn_get_drag);
embryo_program_native_call_add(ep, "set_drag", _edje_embryo_fn_set_drag);
embryo_program_native_call_add(ep, "set_text", _edje_embryo_fn_text_set);
embryo_program_native_call_add(ep, "get_text", _edje_embryo_fn_text_get);
embryo_program_native_call_add(ep, "set_text", _edje_embryo_fn_set_text);
embryo_program_native_call_add(ep, "get_text", _edje_embryo_fn_get_text);
embryo_program_native_call_add(ep, "get_min_size", _edje_embryo_fn_get_min_size);
embryo_program_native_call_add(ep, "get_max_size", _edje_embryo_fn_get_max_size);
embryo_program_native_call_add(ep, "get_color_class", _edje_embryo_fn_get_color_class);

36
legacy/edje/src/lib/edje_private.h
View File

@ -64,9 +64,17 @@ void _edje_embryo_script_init (Edje *ed);
void _edje_embryo_script_shutdown (Edje *ed);
void _edje_embryo_script_reset (Edje *ed);
void _edje_embryo_test_run (Edje *ed, char *fname, char *sig, char *src);
Edje_Var *_edje_var_new (void);
void _edje_var_free (Edje_Var *var);
void _edje_var_init (Edje *ed);
void _edje_var_shutdown (Edje *ed);
int _edje_var_string_id_get (Edje *ed, char *string);
int _edje_var_var_int_get (Edje *ed, Edje_Var *var);
void _edje_var_var_int_set (Edje *ed, Edje_Var *var, int v);
double _edje_var_var_float_get (Edje *ed, Edje_Var *var);
void _edje_var_var_float_set (Edje *ed, Edje_Var *var, double v);
const char *_edje_var_var_str_get (Edje *ed, Edje_Var *var);
void _edje_var_var_str_set (Edje *ed, Edje_Var *var, char *str);
int _edje_var_int_get (Edje *ed, int id);
void _edje_var_int_set (Edje *ed, int id, int v);
double _edje_var_float_get (Edje *ed, int id);
@ -74,6 +82,33 @@ void _edje_var_float_set (Edje *ed, int id, double v);
const char *_edje_var_str_get (Edje *ed, int id);
void _edje_var_str_set (Edje *ed, int id, char *str);
void _edje_var_list_var_append(Edje *ed, int id, Edje_Var *var);
void _edje_var_list_var_prepend(Edje *ed, int id, Edje_Var *var);
void _edje_var_list_var_append_relative(Edje *ed, int id, Edje_Var *var, Edje_Var *relative);
void _edje_var_list_var_prepend_relative(Edje *ed, int id, Edje_Var *var, Edje_Var *relative);
Edje_Var *_edje_var_list_nth(Edje *ed, int id, int n);
int _edje_var_list_count_get(Edje *ed, int id);
void _edje_var_list_remove_nth(Edje *ed, int id, int n);
int _edje_var_list_nth_int_get(Edje *ed, int id, int n);
void _edje_var_list_nth_int_set(Edje *ed, int id, int n, int v);
void _edje_var_list_int_append(Edje *ed, int id, int v);
void _edje_var_list_int_prepend(Edje *ed, int id, int v);
void _edje_var_list_int_insert(Edje *ed, int id, int n, int v);
double _edje_var_list_nth_float_get(Edje *ed, int id, int n);
void _edje_var_list_nth_float_set(Edje *ed, int id, int n, double v);
void _edje_var_list_float_append(Edje *ed, int id, double v);
void _edje_var_list_float_prepend(Edje *ed, int id, double v);
void _edje_var_list_float_insert(Edje *ed, int id, int n, double v);
char *_edje_var_list_nth_str_get(Edje *ed, int id, int n);
void _edje_var_list_nth_str_set(Edje *ed, int id, int n, char *v);
void _edje_var_list_str_append(Edje *ed, int id, char *v);
void _edje_var_list_str_prepend(Edje *ed, int id, char *v);
void _edje_var_list_str_insert(Edje *ed, int id, int n, char *v);
int _edje_var_timer_add (Edje *ed, double in, char *fname, int val);
void _edje_var_timer_del (Edje *ed, int id);
@ -81,4 +116,5 @@ int _edje_var_anim_add (Edje *ed, double len, char *fname,
void _edje_var_anim_del (Edje *ed, int id);
void _edje_var_anim_frametime_reset(void);
#endif

15
legacy/edje/src/lib/edje_util.c
View File

@ -354,6 +354,18 @@ edje_object_part_geometry_get(Evas_Object *obj, const char *part, Evas_Coord *x,
if (h) *h = rp->h;
}
void
edje_object_text_change_cb_set(Evas_Object *obj, void (*func) (void *data, Evas_Object *obj, const char *part), void *data)
{
Edje *ed;
Edje_Real_Part *rp;
ed = _edje_fetch(obj);
if (!ed) return;
ed->text_change.func = func;
ed->text_change.data = data;
}
void
edje_object_part_text_set(Evas_Object *obj, const char *part, const char *text)
{
@ -374,6 +386,7 @@ edje_object_part_text_set(Evas_Object *obj, const char *part, const char *text)
rp->text.text = strdup(text);
ed->dirty = 1;
_edje_recalc(ed);
if (ed->text_change.func) ed->text_change.func(ed->text_change.data, obj, part);
}
const char *
@ -387,7 +400,7 @@ edje_object_part_text_get(Evas_Object *obj, const char *part)
rp = _edje_real_part_get(ed, (char *)part);
if (!rp) return NULL;
if (rp->part->type == EDJE_PART_TYPE_TEXT)
return evas_object_text_text_get(rp->object);
return rp->text.text;
return NULL;
}

763
legacy/edje/src/lib/edje_var.c
View File

@ -127,6 +127,28 @@ _edje_var_anim_cb(void *data)
return 0;
}
Edje_Var *
_edje_var_new(void)
{
Edje_Var *var;
var = calloc(1, sizeof(Edje_Var));
return var;
}
void
_edje_var_free(Edje_Var *var)
{
if (var->type == EDJE_VAR_STRING)
{
if (var->data.s.v)
{
free(var->data.s.v);
}
}
free(var);
}
void
_edje_var_init(Edje *ed)
{
@ -157,6 +179,14 @@ _edje_var_shutdown(Edje *ed)
ed->var_pool->vars[i].data.s.v = NULL;
}
}
else if (ed->var_pool->vars[i].type == EDJE_VAR_LIST)
{
while (ed->var_pool->vars[i].data.l.v)
{
_edje_var_free(ed->var_pool->vars[i].data.l.v->data);
ed->var_pool->vars[i].data.l.v = evas_list_remove_list(ed->var_pool->vars[i].data.l.v, ed->var_pool->vars[i].data.l.v);
}
}
}
free(ed->var_pool->vars);
}
@ -209,6 +239,216 @@ _edje_var_string_id_get(Edje *ed, char *string)
return (int)(*cptr);
}
int
_edje_var_var_int_get(Edje *ed, Edje_Var *var)
{
/* auto-cast */
if (var->type == EDJE_VAR_STRING)
{
if (var->data.s.v)
{
double f;
f = atof(var->data.s.v);
free(var->data.s.v);
var->data.s.v = NULL;
var->data.i.v = (int)f;
}
var->type = EDJE_VAR_INT;
}
else if (var->type == EDJE_VAR_FLOAT)
{
var->data.i.v = (int)(var->data.f.v);
var->type = EDJE_VAR_INT;
}
else if (var->type == EDJE_VAR_NONE)
{
var->type = EDJE_VAR_INT;
}
else if (var->type == EDJE_VAR_LIST)
{
return 0;
}
else if (var->type == EDJE_VAR_HASH)
{
return 0;
}
return var->data.i.v;
}
void
_edje_var_var_int_set(Edje *ed, Edje_Var *var, int v)
{
/* auto-cast */
if (var->type == EDJE_VAR_STRING)
{
if (var->data.s.v)
{
free(var->data.s.v);
var->data.s.v = NULL;
}
var->type = EDJE_VAR_INT;
}
else if (var->type == EDJE_VAR_FLOAT)
{
var->type = EDJE_VAR_INT;
}
else if (var->type == EDJE_VAR_NONE)
{
var->type = EDJE_VAR_INT;
}
else if (var->type == EDJE_VAR_LIST)
{
return;
}
else if (var->type == EDJE_VAR_HASH)
{
return;
}
var->data.i.v = v;
}
double
_edje_var_var_float_get(Edje *ed, Edje_Var *var)
{
/* auto-cast */
if (var->type == EDJE_VAR_STRING)
{
if (var->data.s.v)
{
double f;
f = atof(var->data.s.v);
free(var->data.s.v);
var->data.s.v = NULL;
var->data.f.v = f;
}
var->type = EDJE_VAR_FLOAT;
}
else if (var->type == EDJE_VAR_INT)
{
var->data.f.v = (double)(var->data.i.v);
var->type = EDJE_VAR_FLOAT;
}
else if (var->type == EDJE_VAR_NONE)
{
var->type = EDJE_VAR_FLOAT;
}
else if (var->type == EDJE_VAR_LIST)
{
return 0.0;
}
else if (var->type == EDJE_VAR_HASH)
{
return 0.0;
}
return var->data.f.v;
}
void
_edje_var_var_float_set(Edje *ed, Edje_Var *var, double v)
{
/* auto-cast */
if (var->type == EDJE_VAR_STRING)
{
if (var->data.s.v)
{
free(var->data.s.v);
var->data.s.v = NULL;
}
var->type = EDJE_VAR_FLOAT;
}
else if (var->type == EDJE_VAR_INT)
{
var->data.f.v = 0;
var->type = EDJE_VAR_FLOAT;
}
else if (var->type == EDJE_VAR_NONE)
{
var->type = EDJE_VAR_FLOAT;
}
else if (var->type == EDJE_VAR_LIST)
{
return;
}
else if (var->type == EDJE_VAR_HASH)
{
return;
}
var->data.f.v = v;
}
const char *
_edje_var_var_str_get(Edje *ed, Edje_Var *var)
{
/* auto-cast */
if (var->type == EDJE_VAR_INT)
{
char buf[64];
snprintf(buf, sizeof(buf), "%i", var->data.i.v);
var->data.s.v = strdup(buf);
var->type = EDJE_VAR_STRING;
}
else if (var->type == EDJE_VAR_FLOAT)
{
char buf[64];
snprintf(buf, sizeof(buf), "%f", var->data.f.v);
var->data.s.v = strdup(buf);
var->type = EDJE_VAR_STRING;
}
else if (var->type == EDJE_VAR_NONE)
{
var->data.s.v = strdup("");
var->type = EDJE_VAR_STRING;
}
else if (var->type == EDJE_VAR_LIST)
{
return NULL;
}
else if (var->type == EDJE_VAR_HASH)
{
return NULL;
}
return var->data.s.v;
}
void
_edje_var_var_str_set(Edje *ed, Edje_Var *var, char *str)
{
/* auto-cast */
if (var->type == EDJE_VAR_STRING)
{
if (var->data.s.v)
{
free(var->data.s.v);
var->data.s.v = NULL;
}
}
else if (var->type == EDJE_VAR_INT)
{
var->type = EDJE_VAR_STRING;
}
else if (var->type == EDJE_VAR_FLOAT)
{
var->type = EDJE_VAR_STRING;
}
else if (var->type == EDJE_VAR_NONE)
{
var->type = EDJE_VAR_STRING;
}
else if (var->type == EDJE_VAR_LIST)
{
return;
}
else if (var->type == EDJE_VAR_HASH)
{
return;
}
var->data.s.v = strdup(str);
}
int
_edje_var_int_get(Edje *ed, int id)
{
@ -216,32 +456,7 @@ _edje_var_int_get(Edje *ed, int id)
if (!ed->var_pool) return 0;
id -= EDJE_VAR_MAGIC_BASE;
if ((id < 0) || (id >= ed->var_pool->size)) return 0;
/* auto-cast */
if (ed->var_pool->vars[id].type == EDJE_VAR_STRING)
{
if (ed->var_pool->vars[id].data.s.v)
{
double f;
f = atof(ed->var_pool->vars[id].data.s.v);
free(ed->var_pool->vars[id].data.s.v);
ed->var_pool->vars[id].data.s.v = NULL;
ed->var_pool->vars[id].data.i.v = (int)f;
}
ed->var_pool->vars[id].type = EDJE_VAR_INT;
}
else if (ed->var_pool->vars[id].type == EDJE_VAR_FLOAT)
{
int v;
v = (int)(ed->var_pool->vars[id].data.f.v);
ed->var_pool->vars[id].type = EDJE_VAR_INT;
}
else if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
{
ed->var_pool->vars[id].type = EDJE_VAR_INT;
}
return ed->var_pool->vars[id].data.i.v;
return _edje_var_var_int_get(ed, &(ed->var_pool->vars[id]));
}
void
@ -251,26 +466,7 @@ _edje_var_int_set(Edje *ed, int id, int v)
if (!ed->var_pool) return;
id -= EDJE_VAR_MAGIC_BASE;
if ((id < 0) || (id >= ed->var_pool->size)) return;
/* auto-cast */
if (ed->var_pool->vars[id].type == EDJE_VAR_STRING)
{
if (ed->var_pool->vars[id].data.s.v)
{
free(ed->var_pool->vars[id].data.s.v);
ed->var_pool->vars[id].data.s.v = NULL;
}
ed->var_pool->vars[id].type = EDJE_VAR_INT;
}
else if (ed->var_pool->vars[id].type == EDJE_VAR_FLOAT)
{
ed->var_pool->vars[id].data.f.v = 0;
ed->var_pool->vars[id].type = EDJE_VAR_INT;
}
else if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
{
ed->var_pool->vars[id].type = EDJE_VAR_INT;
}
ed->var_pool->vars[id].data.i.v = v;
_edje_var_var_int_set(ed, &(ed->var_pool->vars[id]), v);
}
double
@ -280,32 +476,7 @@ _edje_var_float_get(Edje *ed, int id)
if (!ed->var_pool) return 0;
id -= EDJE_VAR_MAGIC_BASE;
if ((id < 0) || (id >= ed->var_pool->size)) return 0;
/* auto-cast */
if (ed->var_pool->vars[id].type == EDJE_VAR_STRING)
{
if (ed->var_pool->vars[id].data.s.v)
{
double f;
f = atof(ed->var_pool->vars[id].data.s.v);
free(ed->var_pool->vars[id].data.s.v);
ed->var_pool->vars[id].data.s.v = NULL;
ed->var_pool->vars[id].data.f.v = f;
}
ed->var_pool->vars[id].type = EDJE_VAR_FLOAT;
}
else if (ed->var_pool->vars[id].type == EDJE_VAR_INT)
{
int v;
v = (int)(ed->var_pool->vars[id].data.f.v);
ed->var_pool->vars[id].type = EDJE_VAR_FLOAT;
}
else if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
{
ed->var_pool->vars[id].type = EDJE_VAR_FLOAT;
}
return ed->var_pool->vars[id].data.f.v;
return _edje_var_var_float_get(ed, &(ed->var_pool->vars[id]));
}
void
@ -315,26 +486,7 @@ _edje_var_float_set(Edje *ed, int id, double v)
if (!ed->var_pool) return;
id -= EDJE_VAR_MAGIC_BASE;
if ((id < 0) || (id >= ed->var_pool->size)) return;
/* auto-cast */
if (ed->var_pool->vars[id].type == EDJE_VAR_STRING)
{
if (ed->var_pool->vars[id].data.s.v)
{
free(ed->var_pool->vars[id].data.s.v);
ed->var_pool->vars[id].data.s.v = NULL;
}
ed->var_pool->vars[id].type = EDJE_VAR_FLOAT;
}
else if (ed->var_pool->vars[id].type == EDJE_VAR_INT)
{
ed->var_pool->vars[id].data.f.v = 0;
ed->var_pool->vars[id].type = EDJE_VAR_FLOAT;
}
else if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
{
ed->var_pool->vars[id].type = EDJE_VAR_FLOAT;
}
ed->var_pool->vars[id].data.f.v = v;
_edje_var_var_float_set(ed, &(ed->var_pool->vars[id]), v);
}
const char *
@ -344,29 +496,7 @@ _edje_var_str_get(Edje *ed, int id)
if (!ed->var_pool) return NULL;
id -= EDJE_VAR_MAGIC_BASE;
if ((id < 0) || (id >= ed->var_pool->size)) return NULL;
/* auto-cast */
if (ed->var_pool->vars[id].type == EDJE_VAR_INT)
{
char buf[64];
snprintf(buf, sizeof(buf), "%i", ed->var_pool->vars[id].data.i.v);
ed->var_pool->vars[id].data.s.v = strdup(buf);
ed->var_pool->vars[id].type = EDJE_VAR_STRING;
}
else if (ed->var_pool->vars[id].type == EDJE_VAR_FLOAT)
{
char buf[64];
snprintf(buf, sizeof(buf), "%f", ed->var_pool->vars[id].data.f.v);
ed->var_pool->vars[id].data.s.v = strdup(buf);
ed->var_pool->vars[id].type = EDJE_VAR_STRING;
}
else if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
{
ed->var_pool->vars[id].data.s.v = strdup("");
ed->var_pool->vars[id].type = EDJE_VAR_STRING;
}
return ed->var_pool->vars[id].data.s.v;
return _edje_var_var_str_get(ed, &(ed->var_pool->vars[id]));
}
void
@ -377,30 +507,405 @@ _edje_var_str_set(Edje *ed, int id, char *str)
if (!str) return;
id -= EDJE_VAR_MAGIC_BASE;
if ((id < 0) || (id >= ed->var_pool->size)) return;
/* auto-cast */
if (ed->var_pool->vars[id].type == EDJE_VAR_STRING)
_edje_var_var_str_set(ed, &(ed->var_pool->vars[id]), str);
}
/* list stuff */
void
_edje_var_list_var_append(Edje *ed, int id, Edje_Var *var)
{
if (!ed) return;
if (!ed->var_pool) return;
id -= EDJE_VAR_MAGIC_BASE;
if ((id < 0) || (id >= ed->var_pool->size)) return;
if (ed->var_pool->vars[id].type != EDJE_VAR_LIST) return;
ed->var_pool->vars[id].data.l.v = evas_list_append(ed->var_pool->vars[id].data.l.v, var);
}
void
_edje_var_list_var_prepend(Edje *ed, int id, Edje_Var *var)
{
if (!ed) return;
if (!ed->var_pool) return;
id -= EDJE_VAR_MAGIC_BASE;
if ((id < 0) || (id >= ed->var_pool->size)) return;
if (ed->var_pool->vars[id].type != EDJE_VAR_LIST) return;
ed->var_pool->vars[id].data.l.v = evas_list_prepend(ed->var_pool->vars[id].data.l.v, var);
}
void
_edje_var_list_var_append_relative(Edje *ed, int id, Edje_Var *var, Edje_Var *relative)
{
if (!ed) return;
if (!ed->var_pool) return;
id -= EDJE_VAR_MAGIC_BASE;
if ((id < 0) || (id >= ed->var_pool->size)) return;
if (ed->var_pool->vars[id].type != EDJE_VAR_LIST) return;
ed->var_pool->vars[id].data.l.v = evas_list_append_relative(ed->var_pool->vars[id].data.l.v, var, relative);
}
void
_edje_var_list_var_prepend_relative(Edje *ed, int id, Edje_Var *var, Edje_Var *relative)
{
if (!ed) return;
if (!ed->var_pool) return;
id -= EDJE_VAR_MAGIC_BASE;
if ((id < 0) || (id >= ed->var_pool->size)) return;
if (ed->var_pool->vars[id].type != EDJE_VAR_LIST) return;
ed->var_pool->vars[id].data.l.v = evas_list_prepend_relative(ed->var_pool->vars[id].data.l.v, var, relative);
}
Edje_Var *
_edje_var_list_nth(Edje *ed, int id, int n)
{
if (!ed) return NULL;
if (!ed->var_pool) return NULL;
id -= EDJE_VAR_MAGIC_BASE;
if ((id < 0) || (id >= ed->var_pool->size)) return NULL;
if (ed->var_pool->vars[id].type != EDJE_VAR_LIST) return NULL;
return evas_list_nth(ed->var_pool->vars[id].data.l.v, n);
}
int
_edje_var_list_count_get(Edje *ed, int id)
{
if (!ed) return 0;
if (!ed->var_pool) return 0;
id -= EDJE_VAR_MAGIC_BASE;
if ((id < 0) || (id >= ed->var_pool->size)) return 0;
if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
ed->var_pool->vars[id].type = EDJE_VAR_LIST;
else if (ed->var_pool->vars[id].type != EDJE_VAR_LIST) return 0;
return evas_list_count(ed->var_pool->vars[id].data.l.v);
}
void
_edje_var_list_remove_nth(Edje *ed, int id, int n)
{
if (!ed) return;
if (!ed->var_pool) return;
id -= EDJE_VAR_MAGIC_BASE;
if ((id < 0) || (id >= ed->var_pool->size)) return;
if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
ed->var_pool->vars[id].type = EDJE_VAR_LIST;
else if (ed->var_pool->vars[id].type != EDJE_VAR_LIST) return;
{
if (ed->var_pool->vars[id].data.s.v)
Evas_List *nth;
nth = evas_list_nth_list(ed->var_pool->vars[id].data.l.v, n);
if (nth)
{
free(ed->var_pool->vars[id].data.s.v);
ed->var_pool->vars[id].data.s.v = NULL;
_edje_var_free(nth->data);
ed->var_pool->vars[id].data.l.v = evas_list_remove_list(ed->var_pool->vars[id].data.l.v, nth);
}
}
else if (ed->var_pool->vars[id].type == EDJE_VAR_INT)
}
int
_edje_var_list_nth_int_get(Edje *ed, int id, int n)
{
if (!ed) return 0;
if (!ed->var_pool) return 0;
id -= EDJE_VAR_MAGIC_BASE;
if ((id < 0) || (id >= ed->var_pool->size)) return 0;
if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
ed->var_pool->vars[id].type = EDJE_VAR_LIST;
else if (ed->var_pool->vars[id].type != EDJE_VAR_LIST) return 0;
{
ed->var_pool->vars[id].data.f.v = 0;
ed->var_pool->vars[id].type = EDJE_VAR_STRING;
Edje_Var *var;
var = _edje_var_list_nth(ed, id, n);
if (!var) return 0;
return _edje_var_var_int_get(ed, var);
}
else if (ed->var_pool->vars[id].type == EDJE_VAR_FLOAT)
}
void
_edje_var_list_nth_int_set(Edje *ed, int id, int n, int v)
{
if (!ed) return;
if (!ed->var_pool) return;
id -= EDJE_VAR_MAGIC_BASE;
if ((id < 0) || (id >= ed->var_pool->size)) return;
if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
ed->var_pool->vars[id].type = EDJE_VAR_LIST;
else if (ed->var_pool->vars[id].type != EDJE_VAR_LIST) return;
{
ed->var_pool->vars[id].data.f.v = 0;
ed->var_pool->vars[id].type = EDJE_VAR_STRING;
Edje_Var *var;
var = _edje_var_list_nth(ed, id, n);
if (!var) return;
_edje_var_var_int_set(ed, var, v);
}
else if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
}
void
_edje_var_list_int_append(Edje *ed, int id, int v)
{
if (!ed) return;
if (!ed->var_pool) return;
id -= EDJE_VAR_MAGIC_BASE;
if ((id < 0) || (id >= ed->var_pool->size)) return;
if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
ed->var_pool->vars[id].type = EDJE_VAR_LIST;
else if (ed->var_pool->vars[id].type != EDJE_VAR_LIST) return;
{
ed->var_pool->vars[id].type = EDJE_VAR_STRING;
Edje_Var *var;
var = _edje_var_new();
if (!var) return;
_edje_var_var_int_set(ed, var, v);
_edje_var_list_var_append(ed, id, var);
}
}
void
_edje_var_list_int_prepend(Edje *ed, int id, int v)
{
if (!ed) return;
if (!ed->var_pool) return;
id -= EDJE_VAR_MAGIC_BASE;
if ((id < 0) || (id >= ed->var_pool->size)) return;
if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
ed->var_pool->vars[id].type = EDJE_VAR_LIST;
else if (ed->var_pool->vars[id].type != EDJE_VAR_LIST) return;
{
Edje_Var *var;
var = _edje_var_new();
if (!var) return;
_edje_var_var_int_set(ed, var, v);
_edje_var_list_var_prepend(ed, id, var);
}
}
void
_edje_var_list_int_insert(Edje *ed, int id, int n, int v)
{
if (!ed) return;
if (!ed->var_pool) return;
id -= EDJE_VAR_MAGIC_BASE;
if ((id < 0) || (id >= ed->var_pool->size)) return;
if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
ed->var_pool->vars[id].type = EDJE_VAR_LIST;
else if (ed->var_pool->vars[id].type != EDJE_VAR_LIST) return;
{
Edje_Var *var, *var_rel;
var = _edje_var_new();
if (!var) return;
_edje_var_var_int_set(ed, var, v);
var_rel = _edje_var_list_nth(ed, id, n);
if (!var_rel)
_edje_var_list_var_append(ed, id, var);
else
_edje_var_list_var_prepend_relative(ed, id, var, var_rel);
}
}
double
_edje_var_list_nth_float_get(Edje *ed, int id, int n)
{
if (!ed) return 0;
if (!ed->var_pool) return 0;
id -= EDJE_VAR_MAGIC_BASE;
if ((id < 0) || (id >= ed->var_pool->size)) return 0;
if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
ed->var_pool->vars[id].type = EDJE_VAR_LIST;
else if (ed->var_pool->vars[id].type != EDJE_VAR_LIST) return 0;
{
Edje_Var *var;
var = _edje_var_list_nth(ed, id, n);
if (!var) return 0;
return _edje_var_var_float_get(ed, var);
}
}
void
_edje_var_list_nth_float_set(Edje *ed, int id, int n, double v)
{
if (!ed) return;
if (!ed->var_pool) return;
id -= EDJE_VAR_MAGIC_BASE;
if ((id < 0) || (id >= ed->var_pool->size)) return;
if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
ed->var_pool->vars[id].type = EDJE_VAR_LIST;
else if (ed->var_pool->vars[id].type != EDJE_VAR_LIST) return;
{
Edje_Var *var;
var = _edje_var_list_nth(ed, id, n);
if (!var) return;
_edje_var_var_float_set(ed, var, v);
}
}
void
_edje_var_list_float_append(Edje *ed, int id, double v)
{
if (!ed) return;
if (!ed->var_pool) return;
id -= EDJE_VAR_MAGIC_BASE;
if ((id < 0) || (id >= ed->var_pool->size)) return;
if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
ed->var_pool->vars[id].type = EDJE_VAR_LIST;
else if (ed->var_pool->vars[id].type != EDJE_VAR_LIST) return;
{
Edje_Var *var;
var = _edje_var_new();
if (!var) return;
_edje_var_var_float_set(ed, var, v);
_edje_var_list_var_append(ed, id, var);
}
}
void
_edje_var_list_float_prepend(Edje *ed, int id, double v)
{
if (!ed) return;
if (!ed->var_pool) return;
id -= EDJE_VAR_MAGIC_BASE;
if ((id < 0) || (id >= ed->var_pool->size)) return;
if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
ed->var_pool->vars[id].type = EDJE_VAR_LIST;
else if (ed->var_pool->vars[id].type != EDJE_VAR_LIST) return;
{
Edje_Var *var;
var = _edje_var_new();
if (!var) return;
_edje_var_var_float_set(ed, var, v);
_edje_var_list_var_prepend(ed, id, var);
}
}
void
_edje_var_list_float_insert(Edje *ed, int id, int n, double v)
{
if (!ed) return;
if (!ed->var_pool) return;
id -= EDJE_VAR_MAGIC_BASE;
if ((id < 0) || (id >= ed->var_pool->size)) return;
if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
ed->var_pool->vars[id].type = EDJE_VAR_LIST;
else if (ed->var_pool->vars[id].type != EDJE_VAR_LIST) return;
{
Edje_Var *var, *var_rel;
var = _edje_var_new();
if (!var) return;
_edje_var_var_float_set(ed, var, v);
var_rel = _edje_var_list_nth(ed, id, n);
if (!var_rel)
_edje_var_list_var_append(ed, id, var);
else
_edje_var_list_var_prepend_relative(ed, id, var, var_rel);
}
}
char *
_edje_var_list_nth_str_get(Edje *ed, int id, int n)
{
if (!ed) return 0;
if (!ed->var_pool) return 0;
id -= EDJE_VAR_MAGIC_BASE;
if ((id < 0) || (id >= ed->var_pool->size)) return 0;
if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
ed->var_pool->vars[id].type = EDJE_VAR_LIST;
else if (ed->var_pool->vars[id].type != EDJE_VAR_LIST) return 0;
{
Edje_Var *var;
var = _edje_var_list_nth(ed, id, n);
if (!var) return 0;
return _edje_var_var_str_get(ed, var);
}
}
void
_edje_var_list_nth_str_set(Edje *ed, int id, int n, char *v)
{
if (!ed) return;
if (!ed->var_pool) return;
id -= EDJE_VAR_MAGIC_BASE;
if ((id < 0) || (id >= ed->var_pool->size)) return;
if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
ed->var_pool->vars[id].type = EDJE_VAR_LIST;
else if (ed->var_pool->vars[id].type != EDJE_VAR_LIST) return;
{
Edje_Var *var;
var = _edje_var_list_nth(ed, id, n);
if (!var) return;
_edje_var_var_str_set(ed, var, v);
}
}
void
_edje_var_list_str_append(Edje *ed, int id, char *v)
{
if (!ed) return;
if (!ed->var_pool) return;
id -= EDJE_VAR_MAGIC_BASE;
if ((id < 0) || (id >= ed->var_pool->size)) return;
if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
ed->var_pool->vars[id].type = EDJE_VAR_LIST;
else if (ed->var_pool->vars[id].type != EDJE_VAR_LIST) return;
{
Edje_Var *var;
var = _edje_var_new();
if (!var) return;
_edje_var_var_str_set(ed, var, v);
_edje_var_list_var_append(ed, id, var);
}
}
void
_edje_var_list_str_prepend(Edje *ed, int id, char *v)
{
if (!ed) return;
if (!ed->var_pool) return;
id -= EDJE_VAR_MAGIC_BASE;
if ((id < 0) || (id >= ed->var_pool->size)) return;
if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
ed->var_pool->vars[id].type = EDJE_VAR_LIST;
else if (ed->var_pool->vars[id].type != EDJE_VAR_LIST) return;
{
Edje_Var *var;
var = _edje_var_new();
if (!var) return;
_edje_var_var_str_set(ed, var, v);
_edje_var_list_var_prepend(ed, id, var);
}
}
void
_edje_var_list_str_insert(Edje *ed, int id, int n, char *v)
{
if (!ed) return;
if (!ed->var_pool) return;
id -= EDJE_VAR_MAGIC_BASE;
if ((id < 0) || (id >= ed->var_pool->size)) return;
if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
ed->var_pool->vars[id].type = EDJE_VAR_LIST;
else if (ed->var_pool->vars[id].type != EDJE_VAR_LIST) return;
{
Edje_Var *var, *var_rel;
var = _edje_var_new();
if (!var) return;
_edje_var_var_str_set(ed, var, v);
var_rel = _edje_var_list_nth(ed, id, n);
if (!var_rel)
_edje_var_list_var_append(ed, id, var);
else
_edje_var_list_var_prepend_relative(ed, id, var, var_rel);
}
ed->var_pool->vars[id].data.s.v = strdup(str);
}
int