2008-10-26 10:18:19 -07:00
|
|
|
#include <string.h>
|
|
|
|
|
2003-06-23 19:33:04 -07:00
|
|
|
#include "edje_private.h"
|
|
|
|
|
2004-03-26 01:10:05 -08:00
|
|
|
#ifdef EDJE_PROGRAM_CACHE
|
2008-12-05 19:08:17 -08:00
|
|
|
static Eina_Bool _edje_collection_free_prog_cache_matches_free_cb(const Eina_Hash *hash, const void *key, void *data, void *fdata);
|
2004-03-26 01:10:05 -08:00
|
|
|
#endif
|
2008-11-23 21:15:15 -08:00
|
|
|
static void _edje_object_pack_item_hints_set(Evas_Object *obj, Edje_Pack_Element *it);
|
2007-05-26 22:28:07 -07:00
|
|
|
static void _cb_signal_repeat(void *data, Evas_Object *obj, const char *signal, const char *source);
|
2003-07-19 19:08:47 -07:00
|
|
|
|
2008-10-22 04:34:42 -07:00
|
|
|
static Eina_List *_edje_swallows_collect(Edje *ed);
|
2007-03-16 14:37:57 -07:00
|
|
|
|
2004-06-05 21:42:17 -07:00
|
|
|
/************************** API Routines **************************/
|
|
|
|
|
|
|
|
/* FIXDOC: Verify/expand doc */
|
2007-04-14 20:19:35 -07:00
|
|
|
/** Sets the EET file and group to load @a obj from
|
2004-06-05 21:42:17 -07:00
|
|
|
* @param obj A valid Evas_Object handle
|
2005-03-22 11:29:06 -08:00
|
|
|
* @param file The path to the EET file
|
2008-08-14 11:04:43 -07:00
|
|
|
* @param group The group name in the Edje
|
2004-06-05 21:42:17 -07:00
|
|
|
* @return 0 on Error\n
|
|
|
|
* 1 on Success and sets EDJE_LOAD_ERROR_NONE
|
|
|
|
*
|
2007-04-14 20:19:35 -07:00
|
|
|
* Edje uses EET files, conventionally ending in .edj, to store object
|
|
|
|
* descriptions. A single file contains multiple named groups. This function
|
|
|
|
* specifies the file and group name to load @a obj from.
|
2004-06-05 21:42:17 -07:00
|
|
|
*/
|
2010-01-14 10:07:24 -08:00
|
|
|
EAPI Eina_Bool
|
2008-08-14 11:04:43 -07:00
|
|
|
edje_object_file_set(Evas_Object *obj, const char *file, const char *group)
|
2007-05-26 22:28:07 -07:00
|
|
|
{
|
2010-04-08 12:21:54 -07:00
|
|
|
Edje *ed;
|
|
|
|
|
|
|
|
ed = _edje_fetch(obj);
|
|
|
|
if (!ed)
|
|
|
|
return EINA_FALSE;
|
|
|
|
return ed->api->file_set(obj, file, group);
|
2007-05-26 22:28:07 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* FIXDOC: Verify/expand doc. */
|
|
|
|
/** Get the file and group name that @a obj was loaded from
|
|
|
|
* @param obj A valid Evas_Object handle
|
|
|
|
* @param file A pointer to store a pointer to the filename in
|
2008-08-14 11:04:43 -07:00
|
|
|
* @param group A pointer to store a pointer to the group name in
|
2007-05-26 22:28:07 -07:00
|
|
|
*
|
|
|
|
* This gets the EET file location and group for the given Evas_Object.
|
|
|
|
* If @a obj is either not an edje file, or has not had its file/group set
|
2008-08-14 11:04:43 -07:00
|
|
|
* using edje_object_file_set(), then both @a file and @a group will be set
|
2007-05-26 22:28:07 -07:00
|
|
|
* to NULL.
|
|
|
|
*
|
2008-08-14 11:04:43 -07:00
|
|
|
* It is valid to pass in NULL for either @a file or @a group if you are not
|
2007-05-26 22:28:07 -07:00
|
|
|
* interested in one of the values.
|
|
|
|
*/
|
|
|
|
EAPI void
|
2008-08-14 11:21:27 -07:00
|
|
|
edje_object_file_get(const Evas_Object *obj, const char **file, const char **group)
|
2007-05-26 22:28:07 -07:00
|
|
|
{
|
|
|
|
Edje *ed;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2007-05-26 22:28:07 -07:00
|
|
|
ed = _edje_fetch(obj);
|
|
|
|
if (!ed)
|
|
|
|
{
|
|
|
|
if (file) *file = NULL;
|
2008-08-14 11:04:43 -07:00
|
|
|
if (group) *group = NULL;
|
2007-05-26 22:28:07 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (file) *file = ed->path;
|
2008-08-14 11:04:43 -07:00
|
|
|
if (group) *group = ed->group;
|
2007-05-26 22:28:07 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* FIXDOC: Verify. return error? */
|
|
|
|
/** Gets the Edje load error
|
|
|
|
* @param obj A valid Evas_Object handle
|
|
|
|
*
|
|
|
|
* @return The Edje load error:\n
|
2009-05-24 01:24:32 -07:00
|
|
|
* EDJE_LOAD_ERROR_NONE: No Error\n
|
|
|
|
* EDJE_LOAD_ERROR_GENERIC: Generic Error\n
|
|
|
|
* EDJE_LOAD_ERROR_DOES_NOT_EXIST: Does not Exist\n
|
|
|
|
* EDJE_LOAD_ERROR_PERMISSION_DENIED: Permission Denied\n
|
|
|
|
* EDJE_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED: Resource Allocation Failed\n
|
|
|
|
* EDJE_LOAD_ERROR_CORRUPT_FILE: Corrupt File\n
|
|
|
|
* EDJE_LOAD_ERROR_UNKNOWN_FORMAT: Unknown Format\n
|
|
|
|
* EDJE_LOAD_ERROR_INCOMPATIBLE_FILE: Incompatible File\n
|
|
|
|
* EDJE_LOAD_ERROR_UNKNOWN_COLLECTION: Unknown Collection\n
|
|
|
|
* EDJE_LOAD_ERROR_RECURSIVE_REFERENCE: Recursive Reference\n
|
2007-05-26 22:28:07 -07:00
|
|
|
*/
|
|
|
|
EAPI int
|
2008-08-14 11:21:27 -07:00
|
|
|
edje_object_load_error_get(const Evas_Object *obj)
|
2007-05-26 22:28:07 -07:00
|
|
|
{
|
|
|
|
Edje *ed;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2007-05-26 22:28:07 -07:00
|
|
|
ed = _edje_fetch(obj);
|
|
|
|
if (!ed) return EDJE_LOAD_ERROR_NONE;
|
|
|
|
return ed->load_error;
|
|
|
|
}
|
|
|
|
|
2008-12-21 10:39:36 -08:00
|
|
|
EAPI const char *
|
|
|
|
edje_load_error_str(int error)
|
|
|
|
{
|
|
|
|
switch (error)
|
|
|
|
{
|
|
|
|
case EDJE_LOAD_ERROR_NONE:
|
|
|
|
return "No Error";
|
|
|
|
case EDJE_LOAD_ERROR_GENERIC:
|
|
|
|
return "Generic Error";
|
|
|
|
case EDJE_LOAD_ERROR_DOES_NOT_EXIST:
|
|
|
|
return "File Does Not Exist";
|
|
|
|
case EDJE_LOAD_ERROR_PERMISSION_DENIED:
|
|
|
|
return "Permission Denied";
|
|
|
|
case EDJE_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED:
|
|
|
|
return "Resource Allocation Failed";
|
|
|
|
case EDJE_LOAD_ERROR_CORRUPT_FILE:
|
|
|
|
return "Corrupt File";
|
|
|
|
case EDJE_LOAD_ERROR_UNKNOWN_FORMAT:
|
|
|
|
return "Unknown Format";
|
|
|
|
case EDJE_LOAD_ERROR_INCOMPATIBLE_FILE:
|
|
|
|
return "Incompatible File";
|
|
|
|
case EDJE_LOAD_ERROR_UNKNOWN_COLLECTION:
|
|
|
|
return "Unknown Collection";
|
|
|
|
case EDJE_LOAD_ERROR_RECURSIVE_REFERENCE:
|
|
|
|
return "Recursive Reference";
|
|
|
|
default:
|
|
|
|
return "Unknown Error";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-05-26 22:28:07 -07:00
|
|
|
/** Get a list of groups in an edje file
|
|
|
|
* @param file The path to the edje file
|
|
|
|
*
|
2008-10-22 04:34:42 -07:00
|
|
|
* @return The Eina_List of group names (char *)
|
2007-05-26 22:28:07 -07:00
|
|
|
*
|
|
|
|
* Note: the list must be freed using edje_file_collection_list_free()
|
|
|
|
* when you are done with it.
|
2007-09-08 11:31:56 -07:00
|
|
|
*/
|
2008-10-22 04:34:42 -07:00
|
|
|
EAPI Eina_List *
|
2007-05-26 22:28:07 -07:00
|
|
|
edje_file_collection_list(const char *file)
|
|
|
|
{
|
2008-10-22 04:34:42 -07:00
|
|
|
Eina_List *lst = NULL;
|
2007-05-26 22:28:07 -07:00
|
|
|
Edje_File *edf;
|
|
|
|
int error_ret = 0;
|
|
|
|
|
|
|
|
if ((!file) || (!*file)) return NULL;
|
|
|
|
edf = _edje_cache_file_coll_open(file, NULL, &error_ret, NULL);
|
|
|
|
if (edf != NULL)
|
|
|
|
{
|
2010-06-28 06:56:30 -07:00
|
|
|
Eina_Iterator *i;
|
|
|
|
const char *key;
|
|
|
|
|
|
|
|
i = eina_hash_iterator_key_new(edf->collection);
|
|
|
|
|
|
|
|
EINA_ITERATOR_FOREACH(i, key)
|
|
|
|
lst = eina_list_append(lst, eina_stringshare_add(key));
|
|
|
|
|
|
|
|
eina_iterator_free(i);
|
2007-09-08 11:31:56 -07:00
|
|
|
|
|
|
|
_edje_cache_file_unref(edf);
|
2007-05-26 22:28:07 -07:00
|
|
|
}
|
|
|
|
return lst;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Free file collection list
|
2008-10-22 04:34:42 -07:00
|
|
|
* @param lst The Eina_List of groups
|
2007-05-26 22:28:07 -07:00
|
|
|
*
|
|
|
|
* Frees the list returned by edje_file_collection_list().
|
|
|
|
*/
|
|
|
|
EAPI void
|
2008-10-22 04:34:42 -07:00
|
|
|
edje_file_collection_list_free(Eina_List *lst)
|
2007-05-26 22:28:07 -07:00
|
|
|
{
|
|
|
|
while (lst)
|
|
|
|
{
|
2008-10-22 04:34:42 -07:00
|
|
|
if (eina_list_data_get(lst)) eina_stringshare_del(eina_list_data_get(lst));
|
|
|
|
lst = eina_list_remove(lst, eina_list_data_get(lst));
|
2007-05-26 22:28:07 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Determine whether a group matching glob exists in an edje file.
|
|
|
|
* @param file The file path
|
2007-09-08 11:31:56 -07:00
|
|
|
* @param glob A glob to match on
|
2007-05-26 22:28:07 -07:00
|
|
|
*
|
|
|
|
* @return 1 if a match is found, 0 otherwise
|
2007-09-08 11:31:56 -07:00
|
|
|
*/
|
2010-01-14 10:07:24 -08:00
|
|
|
EAPI Eina_Bool
|
2007-05-26 22:28:07 -07:00
|
|
|
edje_file_group_exists(const char *file, const char *glob)
|
|
|
|
{
|
|
|
|
Edje_File *edf;
|
|
|
|
int error_ret = 0;
|
2010-06-28 06:56:30 -07:00
|
|
|
Eina_Bool succeed = EINA_FALSE;
|
2007-05-26 22:28:07 -07:00
|
|
|
|
2010-06-05 06:07:08 -07:00
|
|
|
if ((!file) || (!*file)) return EINA_FALSE;
|
2007-05-26 22:28:07 -07:00
|
|
|
edf = _edje_cache_file_coll_open(file, NULL, &error_ret, NULL);
|
|
|
|
if (edf != NULL)
|
|
|
|
{
|
2010-06-28 06:56:30 -07:00
|
|
|
Edje_Patterns *patterns;
|
|
|
|
|
2010-06-28 10:18:47 -07:00
|
|
|
if (edf->collection_patterns)
|
|
|
|
{
|
|
|
|
patterns = edf->collection_patterns;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
Edje_Part_Collection_Directory_Entry *ce;
|
|
|
|
Eina_Iterator *i;
|
|
|
|
Eina_List *l = NULL;
|
|
|
|
|
|
|
|
i = eina_hash_iterator_data_new(edf->collection);
|
2010-06-28 06:56:30 -07:00
|
|
|
|
2010-06-28 10:18:47 -07:00
|
|
|
EINA_ITERATOR_FOREACH(i, ce)
|
|
|
|
l = eina_list_append(l, ce);
|
2010-06-28 06:56:30 -07:00
|
|
|
|
2010-06-28 10:18:47 -07:00
|
|
|
eina_iterator_free(i);
|
2010-06-28 06:56:30 -07:00
|
|
|
|
2010-06-28 10:18:47 -07:00
|
|
|
patterns = edje_match_collection_dir_init(l);
|
|
|
|
eina_list_free(l);
|
|
|
|
}
|
2010-06-28 06:56:30 -07:00
|
|
|
|
|
|
|
succeed = edje_match_collection_dir_exec(patterns, glob);
|
|
|
|
|
2010-06-28 10:18:47 -07:00
|
|
|
edf->collection_patterns = patterns;
|
2008-01-17 22:34:04 -08:00
|
|
|
|
2007-09-08 11:31:56 -07:00
|
|
|
_edje_cache_file_unref(edf);
|
2007-05-26 22:28:07 -07:00
|
|
|
}
|
2010-06-28 06:56:30 -07:00
|
|
|
return succeed;
|
2007-05-26 22:28:07 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/** Get data from the file level data block of an edje file
|
|
|
|
* @param file The path to the .edj file
|
|
|
|
* @param key The data key
|
|
|
|
* @return The string value of the data
|
|
|
|
*
|
|
|
|
* If an edje file is built from the following edc:
|
|
|
|
*
|
|
|
|
* data {
|
|
|
|
* item: "key1" "value1";
|
|
|
|
* item: "key2" "value2";
|
|
|
|
* }
|
|
|
|
* collections { ... }
|
2007-09-08 11:31:56 -07:00
|
|
|
*
|
2007-05-26 22:28:07 -07:00
|
|
|
* Then, edje_file_data_get("key1") will return "value1"
|
|
|
|
*/
|
|
|
|
EAPI char *
|
|
|
|
edje_file_data_get(const char *file, const char *key)
|
|
|
|
{
|
|
|
|
Edje_File *edf;
|
|
|
|
char *str = NULL;
|
|
|
|
int error_ret = 0;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2007-05-26 22:28:07 -07:00
|
|
|
if (key)
|
|
|
|
{
|
|
|
|
edf = _edje_cache_file_coll_open(file, NULL, &error_ret, NULL);
|
2008-08-22 07:32:25 -07:00
|
|
|
if (edf != NULL)
|
2007-05-26 22:28:07 -07:00
|
|
|
{
|
2010-08-12 05:58:54 -07:00
|
|
|
str = (char*) edje_string_get(eina_hash_find(edf->data, key));
|
2010-06-28 06:56:30 -07:00
|
|
|
|
|
|
|
if (str) str = strdup(str);
|
|
|
|
|
2007-05-26 22:28:07 -07:00
|
|
|
_edje_cache_file_unref(edf);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return str;
|
|
|
|
}
|
|
|
|
|
2010-01-19 12:14:14 -08:00
|
|
|
void
|
2008-02-26 12:12:00 -08:00
|
|
|
_edje_programs_patterns_clean(Edje *ed)
|
|
|
|
{
|
|
|
|
_edje_signals_sources_patterns_clean(&ed->patterns.programs);
|
2008-11-10 08:37:52 -08:00
|
|
|
|
|
|
|
eina_rbtree_delete(ed->patterns.programs.exact_match,
|
|
|
|
EINA_RBTREE_FREE_CB(edje_match_signal_source_free),
|
|
|
|
NULL);
|
|
|
|
ed->patterns.programs.exact_match = NULL;
|
|
|
|
|
2010-08-04 07:25:40 -07:00
|
|
|
free(ed->patterns.programs.u.programs.globing);
|
|
|
|
ed->patterns.programs.u.programs.globing = NULL;
|
2008-02-26 12:12:00 -08:00
|
|
|
}
|
|
|
|
|
2010-01-19 12:14:14 -08:00
|
|
|
void
|
2008-02-26 12:12:00 -08:00
|
|
|
_edje_programs_patterns_init(Edje *ed)
|
|
|
|
{
|
|
|
|
Edje_Signals_Sources_Patterns *ssp = &ed->patterns.programs;
|
2010-08-04 07:25:40 -07:00
|
|
|
Edje_Program **all;
|
|
|
|
unsigned int i, j;
|
2008-02-26 12:12:00 -08:00
|
|
|
|
|
|
|
if (ssp->signals_patterns)
|
|
|
|
return;
|
|
|
|
|
2010-08-04 07:25:40 -07:00
|
|
|
edje_match_program_hash_build(ed->collection->programs.strcmp,
|
|
|
|
ed->collection->programs.strcmp_count,
|
|
|
|
&ssp->exact_match);
|
|
|
|
|
|
|
|
j = ed->collection->programs.strncmp_count
|
|
|
|
+ ed->collection->programs.strrncmp_count
|
|
|
|
+ ed->collection->programs.fnmatch_count
|
|
|
|
+ ed->collection->programs.nocmp_count;
|
|
|
|
if (j == 0) return ;
|
|
|
|
|
|
|
|
all = malloc(sizeof (Edje_Program *) * j);
|
|
|
|
if (!all) return ;
|
|
|
|
j = 0;
|
|
|
|
|
|
|
|
/* FIXME: Build specialized data type for each case */
|
|
|
|
#define EDJE_LOAD_PROGRAMS_ADD(Array, Ed, It, Git, All) \
|
|
|
|
for (It = 0; It < Ed->collection->programs.Array##_count; ++It, ++Git) \
|
|
|
|
All[Git] = Ed->collection->programs.Array[It];
|
|
|
|
|
|
|
|
EDJE_LOAD_PROGRAMS_ADD(fnmatch, ed, i, j, all);
|
|
|
|
EDJE_LOAD_PROGRAMS_ADD(strncmp, ed, i, j, all);
|
|
|
|
EDJE_LOAD_PROGRAMS_ADD(strrncmp, ed, i, j, all);
|
|
|
|
/* FIXME: Do a special pass for that one */
|
|
|
|
EDJE_LOAD_PROGRAMS_ADD(nocmp, ed, i, j, all);
|
|
|
|
|
|
|
|
ssp->u.programs.globing = all;
|
|
|
|
ssp->u.programs.count = j;
|
|
|
|
ssp->signals_patterns = edje_match_programs_signal_init(all, j);
|
|
|
|
ssp->sources_patterns = edje_match_programs_source_init(all, j);
|
2008-02-26 12:12:00 -08:00
|
|
|
}
|
|
|
|
|
2010-04-08 12:21:54 -07:00
|
|
|
int
|
2008-10-22 04:34:42 -07:00
|
|
|
_edje_object_file_set_internal(Evas_Object *obj, const char *file, const char *group, Eina_List *group_path)
|
2003-06-23 19:33:04 -07:00
|
|
|
{
|
|
|
|
Edje *ed;
|
2010-07-29 05:02:36 -07:00
|
|
|
unsigned int n;
|
2008-10-22 04:34:42 -07:00
|
|
|
Eina_List *parts = NULL;
|
|
|
|
Eina_List *old_swallows;
|
2007-05-26 22:28:07 -07:00
|
|
|
int group_path_started = 0;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2003-06-23 19:33:04 -07:00
|
|
|
ed = _edje_fetch(obj);
|
2003-09-29 13:43:37 -07:00
|
|
|
if (!ed) return 0;
|
2003-06-23 19:33:04 -07:00
|
|
|
if (!file) file = "";
|
2008-08-14 11:04:43 -07:00
|
|
|
if (!group) group = "";
|
2003-06-23 19:33:04 -07:00
|
|
|
if (((ed->path) && (!strcmp(file, ed->path))) &&
|
2008-08-14 11:04:43 -07:00
|
|
|
(ed->group) && (!strcmp(group, ed->group)))
|
2003-10-19 23:10:09 -07:00
|
|
|
return 1;
|
2007-03-16 14:37:57 -07:00
|
|
|
|
|
|
|
old_swallows = _edje_swallows_collect(ed);
|
|
|
|
|
2008-05-30 04:20:49 -07:00
|
|
|
if (_edje_script_only(ed)) _edje_script_only_shutdown(ed);
|
From: "Hanspeter Portner" <ventosus@airpost.net>
This concerns Ticket #109: Add Lua support for Edje
It adds Lua as scripting facility to Edje, letting Embryo untouched.
It should be easier to use and be more flexible than Embryo, imho ;-)
---
The patch
---
Lua 5.1 is used in sandboxed mode. Lua byte code is not
platform/architecture independent, Lua code is saved as text in the Edje
container and parsed at load time, therefore.
The patch goes in two directions
1) Analogous to Embryo for scripting logic, messaging and custom states.
The same things are implemented as in Embryo:
- messaging from and to C
- manual creation of timers, animators, pollers for custom events /
animations
- manual manipulation of Edje parts by means of the public
edje_object_part_* and internal functions and custom states
-> those routines are actually implemented as Lua
bindings to
functions in Edje.h and Ecore.h
-> the implementation is done in an object oriented way, so that the
interface gives the feel of an object description language, pretty
similar to EDC itself
-> combining custom states and custom animators allows
for fancy
animations and transitions, e.g circular/spline translations or
complex/conditional transitions, etc.
-> this is just the same as Embryo does, but implemented in Lua, so
nothing new here, actually
2) Dynamic object creation and manipulation
- this interface stems from the 'script_only' objects in
Edje. Those
objects are a kind of scriptable Edje counterparts to Evas_Smart
objects. The infrastructure for Embryo is already there, but has
never been used
- I added this in Lua and added some first bindings to
experiment
with
- I thought it would be useful to allow for a limited dynamic
creation of ui parts
- We can create instances of groups from within the same Edje
container and use them just like the main Edje object as
stated in
1)
- And there are some stand-alone bindings to dynamically create
Evas_Image, Evas_Table, Evas_Line, Evas_Polygon as examples
-> this may be useful to decouple the program from the ui
even more,
to be able to do things that have to be done in the program itself
atm, but actually belong to the user interface, but need dynamic
creation of objects or complex interactions
-> those objects are manipulated manually with Lua bindings
to the
corresponding edje_object_* and evas_object_* functions
---
Discussion points
---
Both stuff in 1) & 2) is functioning, but needs testing, feedback,
improvements, ...
Stuff in 1) can already fully replace Embryo scripting with Lua
scripting. There still is space for improvements/additions, though.
Of the stuff in 2), I think it may only make sense to add the dynamic
creation of groups defined in the same Edje container. Dynamic creation
of other Evas_Objects makes not much sense, as most of them can already
be used as Edje parts and be manipulated with custom states (apart from
polygons and lines) and it would make the whole theming potentially more
programing-like and much more susceptible for errors, etc.
Would this be useful, or drop it all?
The scripting should be there just for logic, conditionals, custom
states and animations, not for a whole dynamic canvas, imho.
There is a patch around with EXTERNAL Edje parts. Seems to be a better,
faster, more secure way to extend Edje with custom objects.
There would be the possibility of precompiling Lua code at compile time
(edje_cc) for faster loading, but we would have to patch and run our own
Lua version.
The Lua parser is pretty fast, though, and using
byte-converted/endianness-swapped byte-code does only pay off for Lua
chunks of some kilo lines.
Byte code also occupies much more space than text in the final Edje
container, as it includes debug symbols.
---
Cedric and Vincent told me, that the plan was to replace Embryo totally
by Lua before the official release of Edje at the end of the year? So it
would make sense to bring Lua to svn soon and look how it fits in, test,
debug, adapt it further to the themers needs, decide on its final shape,
GATHER SOME PEOPLE TO HELP ;-)
---
The Lua enhanced Edje is in sync with svn and can be get directly here
git clone git://repo.or.cz/edje_lua.git
cd edje_lua
git checkout -b lua_patch origin/lua_patch
or apply the attached patch
There are also some examples to show the usage of the things
mentioned
above
- showcase.edj: shows usage of custom animators, custom states,
messaging and the script_only object
- test.edj: test cases of script usage and bindings (custom states,
custom transitions, tween_states, animators, timers,
object_parts),
but most of it are experimental script_only objects
http://didgmo.sourceforge.net/showcase.edj
http://didgmo.sourceforge.net/test.edj
The source of showcase.edc is attached, too, to just have a glimpse at
Lua inside of EDC
---
So, what do you guys think?
Thanks and sry for the looong mail, hehe ;-)
SVN revision: 41802
2009-08-15 19:34:02 -07:00
|
|
|
if (_edje_lua_script_only(ed)) _edje_lua_script_only_shutdown(ed);
|
2003-06-23 19:33:04 -07:00
|
|
|
_edje_file_del(ed);
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2008-10-15 07:11:11 -07:00
|
|
|
if (ed->path) eina_stringshare_del(ed->path);
|
|
|
|
if (ed->group) eina_stringshare_del(ed->group);
|
|
|
|
ed->path = eina_stringshare_add(file);
|
|
|
|
ed->group = eina_stringshare_add(group);
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2003-10-19 23:10:09 -07:00
|
|
|
ed->load_error = EDJE_LOAD_ERROR_NONE;
|
2009-11-24 09:55:11 -08:00
|
|
|
_edje_file_add(ed);
|
|
|
|
|
2009-11-24 13:08:52 -08:00
|
|
|
if (ed->file && ed->file->external_dir)
|
2009-11-24 09:55:11 -08:00
|
|
|
{
|
2010-06-29 06:48:03 -07:00
|
|
|
unsigned int i;
|
2009-11-24 09:55:11 -08:00
|
|
|
|
2010-06-29 06:48:03 -07:00
|
|
|
for (i = 0; i < ed->file->external_dir->entries_count; ++i)
|
|
|
|
edje_module_load(ed->file->external_dir->entries[i].entry);
|
2009-11-24 09:55:11 -08:00
|
|
|
}
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2006-03-27 23:45:54 -08:00
|
|
|
_edje_textblock_styles_add(ed);
|
|
|
|
_edje_textblock_style_all_update(ed);
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2010-02-17 15:43:31 -08:00
|
|
|
ed->has_entries = EINA_FALSE;
|
|
|
|
|
2003-06-23 19:33:04 -07:00
|
|
|
if (ed->collection)
|
|
|
|
{
|
2008-05-30 04:20:49 -07:00
|
|
|
if (ed->collection->script_only)
|
2008-05-30 07:27:56 -07:00
|
|
|
{
|
|
|
|
ed->load_error = EDJE_LOAD_ERROR_NONE;
|
|
|
|
_edje_script_only_init(ed);
|
|
|
|
}
|
From: "Hanspeter Portner" <ventosus@airpost.net>
This concerns Ticket #109: Add Lua support for Edje
It adds Lua as scripting facility to Edje, letting Embryo untouched.
It should be easier to use and be more flexible than Embryo, imho ;-)
---
The patch
---
Lua 5.1 is used in sandboxed mode. Lua byte code is not
platform/architecture independent, Lua code is saved as text in the Edje
container and parsed at load time, therefore.
The patch goes in two directions
1) Analogous to Embryo for scripting logic, messaging and custom states.
The same things are implemented as in Embryo:
- messaging from and to C
- manual creation of timers, animators, pollers for custom events /
animations
- manual manipulation of Edje parts by means of the public
edje_object_part_* and internal functions and custom states
-> those routines are actually implemented as Lua
bindings to
functions in Edje.h and Ecore.h
-> the implementation is done in an object oriented way, so that the
interface gives the feel of an object description language, pretty
similar to EDC itself
-> combining custom states and custom animators allows
for fancy
animations and transitions, e.g circular/spline translations or
complex/conditional transitions, etc.
-> this is just the same as Embryo does, but implemented in Lua, so
nothing new here, actually
2) Dynamic object creation and manipulation
- this interface stems from the 'script_only' objects in
Edje. Those
objects are a kind of scriptable Edje counterparts to Evas_Smart
objects. The infrastructure for Embryo is already there, but has
never been used
- I added this in Lua and added some first bindings to
experiment
with
- I thought it would be useful to allow for a limited dynamic
creation of ui parts
- We can create instances of groups from within the same Edje
container and use them just like the main Edje object as
stated in
1)
- And there are some stand-alone bindings to dynamically create
Evas_Image, Evas_Table, Evas_Line, Evas_Polygon as examples
-> this may be useful to decouple the program from the ui
even more,
to be able to do things that have to be done in the program itself
atm, but actually belong to the user interface, but need dynamic
creation of objects or complex interactions
-> those objects are manipulated manually with Lua bindings
to the
corresponding edje_object_* and evas_object_* functions
---
Discussion points
---
Both stuff in 1) & 2) is functioning, but needs testing, feedback,
improvements, ...
Stuff in 1) can already fully replace Embryo scripting with Lua
scripting. There still is space for improvements/additions, though.
Of the stuff in 2), I think it may only make sense to add the dynamic
creation of groups defined in the same Edje container. Dynamic creation
of other Evas_Objects makes not much sense, as most of them can already
be used as Edje parts and be manipulated with custom states (apart from
polygons and lines) and it would make the whole theming potentially more
programing-like and much more susceptible for errors, etc.
Would this be useful, or drop it all?
The scripting should be there just for logic, conditionals, custom
states and animations, not for a whole dynamic canvas, imho.
There is a patch around with EXTERNAL Edje parts. Seems to be a better,
faster, more secure way to extend Edje with custom objects.
There would be the possibility of precompiling Lua code at compile time
(edje_cc) for faster loading, but we would have to patch and run our own
Lua version.
The Lua parser is pretty fast, though, and using
byte-converted/endianness-swapped byte-code does only pay off for Lua
chunks of some kilo lines.
Byte code also occupies much more space than text in the final Edje
container, as it includes debug symbols.
---
Cedric and Vincent told me, that the plan was to replace Embryo totally
by Lua before the official release of Edje at the end of the year? So it
would make sense to bring Lua to svn soon and look how it fits in, test,
debug, adapt it further to the themers needs, decide on its final shape,
GATHER SOME PEOPLE TO HELP ;-)
---
The Lua enhanced Edje is in sync with svn and can be get directly here
git clone git://repo.or.cz/edje_lua.git
cd edje_lua
git checkout -b lua_patch origin/lua_patch
or apply the attached patch
There are also some examples to show the usage of the things
mentioned
above
- showcase.edj: shows usage of custom animators, custom states,
messaging and the script_only object
- test.edj: test cases of script usage and bindings (custom states,
custom transitions, tween_states, animators, timers,
object_parts),
but most of it are experimental script_only objects
http://didgmo.sourceforge.net/showcase.edj
http://didgmo.sourceforge.net/test.edj
The source of showcase.edc is attached, too, to just have a glimpse at
Lua inside of EDC
---
So, what do you guys think?
Thanks and sry for the looong mail, hehe ;-)
SVN revision: 41802
2009-08-15 19:34:02 -07:00
|
|
|
else if (ed->collection->lua_script_only)
|
|
|
|
{
|
|
|
|
ed->load_error = EDJE_LOAD_ERROR_NONE;
|
|
|
|
_edje_lua_script_only_init(ed);
|
|
|
|
}
|
2008-05-30 04:20:49 -07:00
|
|
|
else
|
2003-06-23 19:33:04 -07:00
|
|
|
{
|
2010-08-12 05:58:54 -07:00
|
|
|
unsigned int i;
|
2008-05-30 04:20:49 -07:00
|
|
|
int errors = 0;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2008-05-30 04:20:49 -07:00
|
|
|
/* colorclass stuff */
|
2010-08-12 05:58:54 -07:00
|
|
|
for (i = 0; i < ed->collection->parts_count; ++i)
|
2004-01-22 18:13:42 -08:00
|
|
|
{
|
2010-07-29 05:02:36 -07:00
|
|
|
Edje_Part *ep;
|
|
|
|
unsigned int k;
|
|
|
|
|
2010-08-12 05:58:54 -07:00
|
|
|
ep = ed->collection->parts[i];
|
2008-10-22 04:34:42 -07:00
|
|
|
|
|
|
|
if (errors)
|
|
|
|
break;
|
2008-05-30 04:20:49 -07:00
|
|
|
/* Register any color classes in this parts descriptions. */
|
2010-07-29 05:02:36 -07:00
|
|
|
if ((ep->default_desc) && (ep->default_desc->color_class))
|
|
|
|
_edje_color_class_member_add(ed, ep->default_desc->color_class);
|
|
|
|
|
2010-08-09 10:34:03 -07:00
|
|
|
for (k = 0; k < ep->other.desc_count; k++)
|
2010-07-29 05:02:36 -07:00
|
|
|
{
|
|
|
|
Edje_Part_Description_Common *desc;
|
2008-10-22 04:34:42 -07:00
|
|
|
|
2010-08-09 10:34:03 -07:00
|
|
|
desc = ep->other.desc[k];
|
2010-07-29 05:02:36 -07:00
|
|
|
|
|
|
|
if (desc->color_class)
|
|
|
|
_edje_color_class_member_add(ed, desc->color_class);
|
|
|
|
}
|
2004-07-14 02:59:29 -07:00
|
|
|
}
|
2008-05-30 04:20:49 -07:00
|
|
|
/* build real parts */
|
2010-07-29 05:02:36 -07:00
|
|
|
for (n = 0; n < ed->collection->parts_count; n++)
|
2003-06-23 19:33:04 -07:00
|
|
|
{
|
2008-05-30 04:20:49 -07:00
|
|
|
Edje_Part *ep;
|
|
|
|
Edje_Real_Part *rp;
|
2008-10-22 04:34:42 -07:00
|
|
|
|
2010-07-29 05:02:36 -07:00
|
|
|
ep = ed->collection->parts[n];
|
2009-08-14 10:19:42 -07:00
|
|
|
rp = eina_mempool_malloc(_edje_real_part_mp, sizeof(Edje_Real_Part));
|
2008-05-30 04:20:49 -07:00
|
|
|
if (!rp)
|
2004-07-14 02:59:29 -07:00
|
|
|
{
|
2008-05-30 04:20:49 -07:00
|
|
|
ed->load_error = EDJE_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED;
|
|
|
|
return 0;
|
|
|
|
}
|
2009-08-11 05:47:00 -07:00
|
|
|
|
2009-08-14 10:19:42 -07:00
|
|
|
memset(rp, 0, sizeof (Edje_Real_Part));
|
|
|
|
|
2009-08-11 05:47:00 -07:00
|
|
|
if ((ep->dragable.x != 0) || (ep->dragable.y != 0))
|
|
|
|
{
|
|
|
|
rp->drag = calloc(1, sizeof (Edje_Real_Part_Drag));
|
|
|
|
if (!rp->drag)
|
|
|
|
{
|
|
|
|
ed->load_error = EDJE_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED;
|
|
|
|
free(rp);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-12-09 07:44:54 -08:00
|
|
|
rp->drag->step.x = FROM_INT(ep->dragable.step_x);
|
|
|
|
rp->drag->step.y = FROM_INT(ep->dragable.step_y);
|
2009-08-11 05:47:00 -07:00
|
|
|
}
|
|
|
|
|
2008-05-30 04:20:49 -07:00
|
|
|
rp->edje = ed;
|
|
|
|
_edje_ref(rp->edje);
|
|
|
|
rp->part = ep;
|
2008-10-22 04:34:42 -07:00
|
|
|
parts = eina_list_append(parts, rp);
|
2008-05-30 04:20:49 -07:00
|
|
|
rp->param1.description = ep->default_desc;
|
|
|
|
rp->chosen_description = rp->param1.description;
|
|
|
|
if (!rp->param1.description)
|
2009-12-22 05:46:00 -08:00
|
|
|
ERR("no default part description!");
|
2009-08-11 02:45:06 -07:00
|
|
|
|
|
|
|
switch (ep->type)
|
2008-11-23 21:15:15 -08:00
|
|
|
{
|
2009-08-11 02:45:06 -07:00
|
|
|
case EDJE_PART_TYPE_RECTANGLE:
|
|
|
|
rp->object = evas_object_rectangle_add(ed->evas);
|
|
|
|
break;
|
|
|
|
case EDJE_PART_TYPE_IMAGE:
|
|
|
|
rp->object = evas_object_image_add(ed->evas);
|
|
|
|
break;
|
|
|
|
case EDJE_PART_TYPE_TEXT:
|
|
|
|
_edje_text_part_on_add(ed, rp);
|
|
|
|
rp->object = evas_object_text_add(ed->evas);
|
|
|
|
evas_object_text_font_source_set(rp->object, ed->path);
|
|
|
|
break;
|
|
|
|
case EDJE_PART_TYPE_SWALLOW:
|
|
|
|
case EDJE_PART_TYPE_GROUP:
|
2009-10-26 18:08:19 -07:00
|
|
|
case EDJE_PART_TYPE_EXTERNAL:
|
2009-08-11 02:45:06 -07:00
|
|
|
rp->object = evas_object_rectangle_add(ed->evas);
|
|
|
|
evas_object_color_set(rp->object, 0, 0, 0, 0);
|
|
|
|
evas_object_pass_events_set(rp->object, 1);
|
|
|
|
evas_object_pointer_mode_set(rp->object, EVAS_OBJECT_POINTER_MODE_NOGRAB);
|
2010-02-23 05:39:19 -08:00
|
|
|
_edje_callbacks_focus_add(rp->object, ed, rp);
|
2009-08-11 02:45:06 -07:00
|
|
|
break;
|
|
|
|
case EDJE_PART_TYPE_TEXTBLOCK:
|
|
|
|
rp->object = evas_object_textblock_add(ed->evas);
|
|
|
|
break;
|
|
|
|
case EDJE_PART_TYPE_BOX:
|
|
|
|
rp->object = evas_object_box_add(ed->evas);
|
|
|
|
break;
|
|
|
|
case EDJE_PART_TYPE_TABLE:
|
|
|
|
rp->object = evas_object_table_add(ed->evas);
|
|
|
|
break;
|
2010-07-13 08:47:19 -07:00
|
|
|
case EDJE_PART_TYPE_GRADIENT:
|
|
|
|
ERR("SPANK ! SPANK ! SPANK !\nYOU ARE USING GRADIENT IN PART %s FROM GROUP %s INSIDE FILE %s !!\n THEY ARE NOW REMOVED !",
|
|
|
|
ep->name, group, file);
|
2009-08-11 02:45:06 -07:00
|
|
|
default:
|
2010-03-25 11:05:42 -07:00
|
|
|
ERR("wrong part type %i!", ep->type);
|
2009-08-11 02:45:06 -07:00
|
|
|
break;
|
2008-11-23 21:15:15 -08:00
|
|
|
}
|
2009-08-11 02:45:06 -07:00
|
|
|
|
2008-05-30 04:20:49 -07:00
|
|
|
if (rp->object)
|
|
|
|
{
|
|
|
|
evas_object_smart_member_add(rp->object, ed->obj);
|
|
|
|
// evas_object_layer_set(rp->object, evas_object_layer_get(ed->obj));
|
2010-03-04 06:44:20 -08:00
|
|
|
if (ep->type != EDJE_PART_TYPE_SWALLOW && ep->type != EDJE_PART_TYPE_GROUP && ep->type != EDJE_PART_TYPE_EXTERNAL)
|
2007-07-24 07:20:07 -07:00
|
|
|
{
|
2008-05-30 04:20:49 -07:00
|
|
|
if (ep->mouse_events)
|
|
|
|
{
|
|
|
|
_edje_callbacks_add(rp->object, ed, rp);
|
|
|
|
if (ep->repeat_events)
|
|
|
|
evas_object_repeat_events_set(rp->object, 1);
|
|
|
|
|
|
|
|
if (ep->pointer_mode != EVAS_OBJECT_POINTER_MODE_AUTOGRAB)
|
|
|
|
evas_object_pointer_mode_set(rp->object, ep->pointer_mode);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
evas_object_pass_events_set(rp->object, 1);
|
|
|
|
evas_object_pointer_mode_set(rp->object, EVAS_OBJECT_POINTER_MODE_NOGRAB);
|
|
|
|
}
|
|
|
|
if (ep->precise_is_inside)
|
|
|
|
evas_object_precise_is_inside_set(rp->object, 1);
|
2007-07-24 07:20:07 -07:00
|
|
|
}
|
2008-05-30 04:20:49 -07:00
|
|
|
if (rp->part->clip_to_id < 0)
|
|
|
|
evas_object_clip_set(rp->object, ed->clipper);
|
2004-07-14 02:59:29 -07:00
|
|
|
}
|
2007-05-26 16:57:21 -07:00
|
|
|
}
|
2008-05-30 04:20:49 -07:00
|
|
|
if (n > 0)
|
2007-05-26 16:57:21 -07:00
|
|
|
{
|
2008-05-30 04:20:49 -07:00
|
|
|
Edje_Real_Part *rp;
|
2010-07-29 05:02:36 -07:00
|
|
|
Eina_List *l;
|
|
|
|
|
2008-05-30 04:20:49 -07:00
|
|
|
ed->table_parts = malloc(sizeof(Edje_Real_Part *) * n);
|
|
|
|
ed->table_parts_size = n;
|
|
|
|
/* FIXME: check malloc return */
|
|
|
|
n = 0;
|
2008-10-22 04:34:42 -07:00
|
|
|
EINA_LIST_FOREACH(parts, l, rp)
|
2003-06-26 07:04:31 -07:00
|
|
|
{
|
2008-05-30 04:20:49 -07:00
|
|
|
ed->table_parts[n] = rp;
|
|
|
|
n++;
|
2003-06-26 07:04:31 -07:00
|
|
|
}
|
2008-10-22 04:34:42 -07:00
|
|
|
eina_list_free(parts);
|
2008-05-30 04:20:49 -07:00
|
|
|
for (i = 0; i < ed->table_parts_size; i++)
|
2005-07-26 06:59:03 -07:00
|
|
|
{
|
2008-05-30 04:20:49 -07:00
|
|
|
rp = ed->table_parts[i];
|
2010-07-29 05:02:36 -07:00
|
|
|
if (rp->param1.description->rel1.id_x >= 0)
|
|
|
|
rp->param1.rel1_to_x = ed->table_parts[rp->param1.description->rel1.id_x % ed->table_parts_size];
|
|
|
|
if (rp->param1.description->rel1.id_y >= 0)
|
|
|
|
rp->param1.rel1_to_y = ed->table_parts[rp->param1.description->rel1.id_y % ed->table_parts_size];
|
|
|
|
if (rp->param1.description->rel2.id_x >= 0)
|
|
|
|
rp->param1.rel2_to_x = ed->table_parts[rp->param1.description->rel2.id_x % ed->table_parts_size];
|
|
|
|
if (rp->param1.description->rel2.id_y >= 0)
|
|
|
|
rp->param1.rel2_to_y = ed->table_parts[rp->param1.description->rel2.id_y % ed->table_parts_size];
|
2008-05-30 04:20:49 -07:00
|
|
|
if (rp->part->clip_to_id >= 0)
|
|
|
|
{
|
|
|
|
rp->clip_to = ed->table_parts[rp->part->clip_to_id % ed->table_parts_size];
|
|
|
|
if (rp->clip_to)
|
|
|
|
{
|
|
|
|
evas_object_pass_events_set(rp->clip_to->object, 1);
|
|
|
|
evas_object_pointer_mode_set(rp->clip_to->object, EVAS_OBJECT_POINTER_MODE_NOGRAB);
|
|
|
|
evas_object_clip_set(rp->object, rp->clip_to->object);
|
|
|
|
}
|
|
|
|
}
|
2009-08-11 05:47:00 -07:00
|
|
|
if (rp->drag)
|
2008-05-30 04:20:49 -07:00
|
|
|
{
|
2009-08-11 05:47:00 -07:00
|
|
|
if (rp->part->dragable.confine_id >= 0)
|
|
|
|
rp->drag->confine_to = ed->table_parts[rp->part->dragable.confine_id % ed->table_parts_size];
|
2009-08-11 07:55:26 -07:00
|
|
|
}
|
2009-08-11 05:47:00 -07:00
|
|
|
|
2009-08-11 07:55:26 -07:00
|
|
|
/* replay events for dragable */
|
2010-07-16 06:58:35 -07:00
|
|
|
if (rp->part->dragable.event_id >= 0)
|
2009-08-11 07:55:26 -07:00
|
|
|
{
|
|
|
|
rp->events_to =
|
2010-07-16 06:58:35 -07:00
|
|
|
ed->table_parts[rp->part->dragable.event_id % ed->table_parts_size];
|
2009-08-11 07:55:26 -07:00
|
|
|
/* events_to may be used only with dragable */
|
|
|
|
if (!rp->events_to->part->dragable.x &&
|
|
|
|
!rp->events_to->part->dragable.y)
|
|
|
|
rp->events_to = NULL;
|
2008-05-30 04:20:49 -07:00
|
|
|
}
|
2009-08-11 05:47:00 -07:00
|
|
|
|
2008-05-30 04:20:49 -07:00
|
|
|
rp->swallow_params.min.w = 0;
|
|
|
|
rp->swallow_params.min.w = 0;
|
|
|
|
rp->swallow_params.max.w = -1;
|
|
|
|
rp->swallow_params.max.h = -1;
|
2010-07-29 05:02:36 -07:00
|
|
|
|
|
|
|
if (rp->part->type == EDJE_PART_TYPE_TEXT
|
|
|
|
|| rp->part->type == EDJE_PART_TYPE_TEXTBLOCK)
|
2008-05-30 04:20:49 -07:00
|
|
|
{
|
2010-07-29 05:02:36 -07:00
|
|
|
Edje_Part_Description_Text *text;
|
|
|
|
|
|
|
|
text = (Edje_Part_Description_Text *) rp->param1.description;
|
|
|
|
|
|
|
|
if (ed->file->feature_ver < 1)
|
|
|
|
{
|
|
|
|
text->text.id_source = -1;
|
|
|
|
text->text.id_text_source = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (text->text.id_source >= 0)
|
|
|
|
rp->text.source = ed->table_parts[text->text.id_source % ed->table_parts_size];
|
|
|
|
if (text->text.id_text_source >= 0)
|
|
|
|
rp->text.text_source = ed->table_parts[text->text.id_text_source % ed->table_parts_size];
|
|
|
|
if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
|
|
|
|
{
|
|
|
|
_edje_entry_real_part_init(rp);
|
|
|
|
if (!ed->has_entries)
|
|
|
|
ed->has_entries = EINA_TRUE;
|
|
|
|
}
|
2008-05-30 04:20:49 -07:00
|
|
|
}
|
2005-07-26 06:59:03 -07:00
|
|
|
}
|
2008-05-30 04:20:49 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
_edje_programs_patterns_init(ed);
|
2010-08-04 07:25:40 -07:00
|
|
|
|
|
|
|
n = ed->collection->programs.fnmatch_count +
|
|
|
|
ed->collection->programs.strcmp_count +
|
|
|
|
ed->collection->programs.strncmp_count +
|
|
|
|
ed->collection->programs.strrncmp_count +
|
|
|
|
ed->collection->programs.nocmp_count;
|
2008-05-30 04:20:49 -07:00
|
|
|
if (n > 0)
|
|
|
|
{
|
2008-10-22 04:34:42 -07:00
|
|
|
Edje_Program *pr;
|
2010-08-04 07:25:40 -07:00
|
|
|
unsigned int i;
|
2010-07-29 05:02:36 -07:00
|
|
|
|
2008-05-30 04:20:49 -07:00
|
|
|
ed->table_programs = malloc(sizeof(Edje_Program *) * n);
|
2010-08-04 07:25:40 -07:00
|
|
|
if (ed->table_programs)
|
2004-10-12 20:43:42 -07:00
|
|
|
{
|
2010-08-04 07:25:40 -07:00
|
|
|
ed->table_programs_size = n;
|
|
|
|
|
|
|
|
#define EDJE_LOAD_BUILD_TABLE(Array, Ed, It, Tmp) \
|
|
|
|
for (It = 0; It < Ed->collection->programs.Array##_count; ++It) \
|
|
|
|
{ \
|
|
|
|
Tmp = Ed->collection->programs.Array[It]; \
|
|
|
|
Ed->table_programs[Tmp->id] = Tmp; \
|
|
|
|
}
|
|
|
|
|
|
|
|
EDJE_LOAD_BUILD_TABLE(fnmatch, ed, i, pr);
|
|
|
|
EDJE_LOAD_BUILD_TABLE(strcmp, ed, i, pr);
|
|
|
|
EDJE_LOAD_BUILD_TABLE(strncmp, ed, i, pr);
|
|
|
|
EDJE_LOAD_BUILD_TABLE(strrncmp, ed, i, pr);
|
|
|
|
EDJE_LOAD_BUILD_TABLE(nocmp, ed, i, pr);
|
2004-10-12 20:43:42 -07:00
|
|
|
}
|
2004-04-01 07:32:17 -08:00
|
|
|
}
|
2008-05-30 04:20:49 -07:00
|
|
|
_edje_ref(ed);
|
|
|
|
_edje_block(ed);
|
|
|
|
_edje_freeze(ed);
|
2010-06-03 23:45:46 -07:00
|
|
|
// if (ed->collection->script) _edje_embryo_script_init(ed);
|
2008-05-30 04:20:49 -07:00
|
|
|
_edje_var_init(ed);
|
|
|
|
for (i = 0; i < ed->table_parts_size; i++)
|
2004-04-01 07:32:17 -08:00
|
|
|
{
|
2008-05-30 04:20:49 -07:00
|
|
|
Edje_Real_Part *rp;
|
|
|
|
|
|
|
|
rp = ed->table_parts[i];
|
|
|
|
evas_object_show(rp->object);
|
|
|
|
if (_edje_block_break(ed)) break;
|
2009-08-11 05:47:00 -07:00
|
|
|
if (rp->drag)
|
|
|
|
{
|
2009-12-09 07:44:54 -08:00
|
|
|
if (rp->part->dragable.x < 0) rp->drag->val.x = FROM_DOUBLE(1.0);
|
|
|
|
if (rp->part->dragable.y < 0) rp->drag->val.x = FROM_DOUBLE(1.0);
|
2009-08-11 05:47:00 -07:00
|
|
|
_edje_dragable_pos_set(ed, rp, rp->drag->val.x, rp->drag->val.y);
|
|
|
|
}
|
2003-06-24 19:29:25 -07:00
|
|
|
}
|
2008-05-30 04:20:49 -07:00
|
|
|
ed->dirty = 1;
|
2009-08-10 08:16:51 -07:00
|
|
|
#ifdef EDJE_CALC_CACHE
|
|
|
|
ed->all_part_change = 1;
|
|
|
|
#endif
|
2008-05-30 04:20:49 -07:00
|
|
|
if ((evas_object_clipees_get(ed->clipper)) &&
|
|
|
|
(evas_object_visible_get(obj)))
|
|
|
|
evas_object_show(ed->clipper);
|
|
|
|
|
|
|
|
/* instantiate 'internal swallows' */
|
|
|
|
for (i = 0; i < ed->table_parts_size; i++)
|
2007-05-26 22:28:07 -07:00
|
|
|
{
|
2008-05-30 04:20:49 -07:00
|
|
|
Edje_Real_Part *rp;
|
2008-12-05 19:08:17 -08:00
|
|
|
/* XXX: curr_item and pack_it don't require to be NULL since
|
|
|
|
* XXX: they are just used when source != NULL and type == BOX,
|
|
|
|
* XXX: and they're always set in this case, but GCC fails to
|
|
|
|
* XXX: notice that, so let's shut it up
|
|
|
|
*/
|
2010-07-29 05:02:36 -07:00
|
|
|
Edje_Pack_Element **curr_item = NULL;
|
|
|
|
unsigned int item_count = 0;
|
2008-12-05 19:08:17 -08:00
|
|
|
Edje_Pack_Element *pack_it = NULL;
|
2008-11-23 21:15:15 -08:00
|
|
|
const char *source = NULL;
|
2008-05-30 04:20:49 -07:00
|
|
|
|
|
|
|
rp = ed->table_parts[i];
|
2009-08-11 03:06:37 -07:00
|
|
|
|
|
|
|
switch (rp->part->type)
|
2008-11-23 21:15:15 -08:00
|
|
|
{
|
2009-08-11 03:06:37 -07:00
|
|
|
case EDJE_PART_TYPE_GROUP:
|
|
|
|
source = rp->part->source;
|
|
|
|
break;
|
|
|
|
case EDJE_PART_TYPE_BOX:
|
|
|
|
case EDJE_PART_TYPE_TABLE:
|
|
|
|
if (rp->part->items)
|
|
|
|
{
|
|
|
|
curr_item = rp->part->items;
|
2010-07-29 05:02:36 -07:00
|
|
|
item_count = rp->part->items_count;
|
|
|
|
if (item_count > 0)
|
|
|
|
{
|
|
|
|
pack_it = *curr_item;
|
|
|
|
source = pack_it->source;
|
|
|
|
item_count--;
|
|
|
|
curr_item++;
|
|
|
|
}
|
2009-08-11 03:06:37 -07:00
|
|
|
}
|
|
|
|
break;
|
2009-10-26 18:08:19 -07:00
|
|
|
case EDJE_PART_TYPE_EXTERNAL:
|
|
|
|
{
|
2010-07-29 05:02:36 -07:00
|
|
|
Edje_Part_Description_External *external;
|
2009-10-26 18:08:19 -07:00
|
|
|
Evas_Object *child_obj;
|
2010-07-29 05:02:36 -07:00
|
|
|
|
|
|
|
external = (Edje_Part_Description_External *) rp->part->default_desc;
|
|
|
|
child_obj = _edje_external_type_add(rp->part->source,
|
|
|
|
evas_object_evas_get(ed->obj), ed->obj,
|
|
|
|
external->external_params, rp->part->name);
|
2009-10-31 11:07:08 -07:00
|
|
|
if (child_obj)
|
|
|
|
{
|
|
|
|
_edje_real_part_swallow(rp, child_obj);
|
2010-07-29 05:02:36 -07:00
|
|
|
rp->param1.external_params = _edje_external_params_parse(child_obj,
|
|
|
|
external->external_params);
|
2010-04-19 13:37:35 -07:00
|
|
|
_edje_external_recalc_apply(ed, rp, NULL, rp->chosen_description);
|
2009-10-31 11:07:08 -07:00
|
|
|
}
|
2009-10-26 18:08:19 -07:00
|
|
|
}
|
|
|
|
continue;
|
2009-08-11 03:06:37 -07:00
|
|
|
default:
|
|
|
|
continue;
|
2008-11-23 21:15:15 -08:00
|
|
|
}
|
2009-08-11 03:06:37 -07:00
|
|
|
|
2008-11-23 21:15:15 -08:00
|
|
|
while (source)
|
2007-05-26 22:28:07 -07:00
|
|
|
{
|
2008-10-22 04:34:42 -07:00
|
|
|
Eina_List *l;
|
2008-05-30 04:20:49 -07:00
|
|
|
Evas_Object *child_obj;
|
|
|
|
Edje *child_ed;
|
2008-11-23 21:15:15 -08:00
|
|
|
const char *group_path_entry = eina_stringshare_add(source);
|
2008-10-22 04:34:42 -07:00
|
|
|
const char *data;
|
|
|
|
|
2008-05-30 04:20:49 -07:00
|
|
|
if (!group_path)
|
|
|
|
{
|
2008-10-22 04:34:42 -07:00
|
|
|
group_path = eina_list_append(NULL, eina_stringshare_add(group));
|
2008-05-30 04:20:49 -07:00
|
|
|
group_path_started = 1;
|
|
|
|
}
|
|
|
|
/* make sure that this group isn't already in the tree of parents */
|
2008-10-22 04:34:42 -07:00
|
|
|
EINA_LIST_FOREACH(group_path, l, data)
|
2008-05-30 04:20:49 -07:00
|
|
|
{
|
2008-10-22 04:34:42 -07:00
|
|
|
if (data == group_path_entry)
|
2008-05-30 04:20:49 -07:00
|
|
|
{
|
|
|
|
_edje_thaw(ed);
|
|
|
|
_edje_unblock(ed);
|
|
|
|
_edje_unref(ed);
|
|
|
|
_edje_file_del(ed);
|
2008-10-15 07:11:11 -07:00
|
|
|
eina_stringshare_del(group_path_entry);
|
2008-05-30 04:20:49 -07:00
|
|
|
if (group_path_started)
|
|
|
|
{
|
2008-10-22 04:34:42 -07:00
|
|
|
eina_stringshare_del(eina_list_data_get(group_path));
|
|
|
|
eina_list_free(group_path);
|
2008-05-30 04:20:49 -07:00
|
|
|
}
|
|
|
|
ed->load_error = EDJE_LOAD_ERROR_RECURSIVE_REFERENCE;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
child_obj = edje_object_add(ed->evas);
|
2008-10-22 04:34:42 -07:00
|
|
|
group_path = eina_list_append(group_path, group_path_entry);
|
2008-11-23 21:15:15 -08:00
|
|
|
if (!_edje_object_file_set_internal(child_obj, file, source, group_path))
|
2007-05-26 22:28:07 -07:00
|
|
|
{
|
|
|
|
_edje_thaw(ed);
|
|
|
|
_edje_unblock(ed);
|
|
|
|
_edje_unref(ed);
|
|
|
|
_edje_file_del(ed);
|
2008-05-30 04:20:49 -07:00
|
|
|
|
2007-05-26 22:28:07 -07:00
|
|
|
if (group_path_started)
|
|
|
|
{
|
2008-05-30 04:20:49 -07:00
|
|
|
while (group_path)
|
|
|
|
{
|
2008-10-22 04:34:42 -07:00
|
|
|
eina_stringshare_del(eina_list_data_get(group_path));
|
|
|
|
group_path = eina_list_remove_list(group_path, group_path);
|
2008-05-30 04:20:49 -07:00
|
|
|
}
|
2007-05-26 22:28:07 -07:00
|
|
|
}
|
2008-05-30 04:20:49 -07:00
|
|
|
ed->load_error = edje_object_load_error_get(child_obj);
|
2007-05-26 22:28:07 -07:00
|
|
|
return 0;
|
|
|
|
}
|
2008-05-30 04:20:49 -07:00
|
|
|
child_ed = _edje_fetch(child_obj);
|
2008-10-15 07:11:11 -07:00
|
|
|
child_ed->parent = eina_stringshare_add(rp->part->name);
|
2008-05-30 04:20:49 -07:00
|
|
|
|
2008-10-22 04:34:42 -07:00
|
|
|
group_path = eina_list_remove(group_path, group_path_entry);
|
2008-10-15 07:11:11 -07:00
|
|
|
eina_stringshare_del(group_path_entry);
|
2010-02-23 05:39:19 -08:00
|
|
|
|
2008-05-30 04:20:49 -07:00
|
|
|
edje_object_signal_callback_add(child_obj, "*", "*", _cb_signal_repeat, obj);
|
2008-11-23 21:15:15 -08:00
|
|
|
if (rp->part->type == EDJE_PART_TYPE_GROUP)
|
|
|
|
{
|
|
|
|
_edje_real_part_swallow(rp, child_obj);
|
|
|
|
source = NULL;
|
|
|
|
}
|
2008-12-17 18:43:20 -08:00
|
|
|
else
|
2008-11-23 21:15:15 -08:00
|
|
|
{
|
|
|
|
_edje_object_pack_item_hints_set(child_obj, pack_it);
|
|
|
|
evas_object_show(child_obj);
|
|
|
|
if (pack_it->name)
|
|
|
|
evas_object_name_set(child_obj, pack_it->name);
|
2008-12-17 18:43:20 -08:00
|
|
|
if (rp->part->type == EDJE_PART_TYPE_BOX)
|
|
|
|
{
|
|
|
|
_edje_real_part_box_append(rp, child_obj);
|
|
|
|
evas_object_data_set(child_obj, "\377 edje.box_item", pack_it);
|
|
|
|
}
|
|
|
|
else if(rp->part->type == EDJE_PART_TYPE_TABLE)
|
|
|
|
{
|
|
|
|
_edje_real_part_table_pack(rp, child_obj, pack_it->col, pack_it->row, pack_it->colspan, pack_it->rowspan);
|
|
|
|
evas_object_data_set(child_obj, "\377 edje.table_item", pack_it);
|
|
|
|
}
|
2008-11-23 21:15:15 -08:00
|
|
|
rp->items = eina_list_append(rp->items, child_obj);
|
2010-07-29 05:02:36 -07:00
|
|
|
|
|
|
|
if (item_count > 0)
|
2008-11-23 21:15:15 -08:00
|
|
|
{
|
2010-07-29 05:02:36 -07:00
|
|
|
pack_it = *curr_item;
|
2008-11-23 21:15:15 -08:00
|
|
|
source = pack_it->source;
|
2010-07-29 05:02:36 -07:00
|
|
|
curr_item++;
|
|
|
|
item_count--;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
source = NULL;
|
|
|
|
curr_item = NULL;
|
|
|
|
pack_it = NULL;
|
2008-11-23 21:15:15 -08:00
|
|
|
}
|
|
|
|
}
|
2007-05-26 22:28:07 -07:00
|
|
|
}
|
|
|
|
}
|
2008-05-30 04:20:49 -07:00
|
|
|
|
|
|
|
if (group_path_started)
|
2007-05-26 22:28:07 -07:00
|
|
|
{
|
2009-08-11 03:06:37 -07:00
|
|
|
const char *str;
|
|
|
|
|
|
|
|
EINA_LIST_FREE(group_path, str)
|
|
|
|
eina_stringshare_del(str);
|
2007-05-26 22:28:07 -07:00
|
|
|
}
|
2008-05-30 04:20:49 -07:00
|
|
|
|
|
|
|
/* reswallow any swallows that existed before setting the file */
|
|
|
|
if (old_swallows)
|
2007-03-16 14:37:57 -07:00
|
|
|
{
|
2008-05-30 04:20:49 -07:00
|
|
|
while (old_swallows)
|
|
|
|
{
|
|
|
|
const char *name;
|
|
|
|
Evas_Object *swallow;
|
|
|
|
|
2008-10-22 04:34:42 -07:00
|
|
|
name = eina_list_data_get(old_swallows);
|
|
|
|
old_swallows = eina_list_remove_list(old_swallows, old_swallows);
|
2008-05-30 04:20:49 -07:00
|
|
|
|
2008-10-22 04:34:42 -07:00
|
|
|
swallow = eina_list_data_get(old_swallows);
|
|
|
|
old_swallows = eina_list_remove_list(old_swallows, old_swallows);
|
2008-05-30 04:20:49 -07:00
|
|
|
|
|
|
|
edje_object_part_swallow(obj, name, swallow);
|
2008-10-15 07:11:11 -07:00
|
|
|
eina_stringshare_del(name);
|
2008-05-30 04:20:49 -07:00
|
|
|
}
|
2007-03-16 14:37:57 -07:00
|
|
|
}
|
2008-05-30 04:20:49 -07:00
|
|
|
|
|
|
|
_edje_recalc(ed);
|
|
|
|
_edje_thaw(ed);
|
|
|
|
_edje_unblock(ed);
|
|
|
|
_edje_unref(ed);
|
2008-05-30 07:27:56 -07:00
|
|
|
ed->load_error = EDJE_LOAD_ERROR_NONE;
|
|
|
|
_edje_emit(ed, "load", NULL);
|
2008-11-17 17:46:56 -08:00
|
|
|
/* instantiate 'internal swallows' */
|
|
|
|
for (i = 0; i < ed->table_parts_size; i++)
|
|
|
|
{
|
|
|
|
Edje_Real_Part *rp;
|
|
|
|
|
|
|
|
rp = ed->table_parts[i];
|
|
|
|
if ((rp->part->type == EDJE_PART_TYPE_TEXTBLOCK) &&
|
|
|
|
(rp->part->default_desc))
|
|
|
|
{
|
2010-07-29 05:02:36 -07:00
|
|
|
Edje_Part_Description_Text *text;
|
2008-11-17 17:46:56 -08:00
|
|
|
Edje_Style *stl = NULL;
|
|
|
|
const char *style;
|
2010-07-29 05:02:36 -07:00
|
|
|
|
|
|
|
text = (Edje_Part_Description_Text *) rp->part->default_desc;
|
2010-08-12 05:58:54 -07:00
|
|
|
style = edje_string_get(&text->text.style);
|
2008-11-17 17:46:56 -08:00
|
|
|
if (style)
|
|
|
|
{
|
2010-07-29 05:02:36 -07:00
|
|
|
Eina_List *l;
|
|
|
|
|
2008-11-17 17:46:56 -08:00
|
|
|
EINA_LIST_FOREACH(ed->file->styles, l, stl)
|
|
|
|
{
|
|
|
|
if ((stl->name) && (!strcmp(stl->name, style))) break;
|
|
|
|
stl = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (stl)
|
|
|
|
{
|
|
|
|
if (evas_object_textblock_style_get(rp->object) != stl->style)
|
|
|
|
evas_object_textblock_style_set(rp->object, stl->style);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2007-03-16 14:37:57 -07:00
|
|
|
}
|
2010-02-17 15:43:31 -08:00
|
|
|
_edje_entry_init(ed);
|
2003-09-29 13:43:37 -07:00
|
|
|
return 1;
|
2003-06-23 19:33:04 -07:00
|
|
|
}
|
2003-10-19 23:10:09 -07:00
|
|
|
else
|
2008-02-22 02:42:50 -08:00
|
|
|
return 0;
|
2003-10-19 23:10:09 -07:00
|
|
|
ed->load_error = EDJE_LOAD_ERROR_NONE;
|
2010-02-17 15:43:31 -08:00
|
|
|
_edje_entry_init(ed);
|
2003-10-19 23:10:09 -07:00
|
|
|
return 1;
|
2003-06-23 19:33:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
_edje_file_add(Edje *ed)
|
|
|
|
{
|
2005-10-05 01:38:04 -07:00
|
|
|
if (_edje_edd_edje_file == NULL) return;
|
2008-08-14 11:04:43 -07:00
|
|
|
ed->file = _edje_cache_file_coll_open(ed->path, ed->group,
|
2007-09-08 11:31:56 -07:00
|
|
|
&(ed->load_error),
|
2005-10-05 01:38:04 -07:00
|
|
|
&(ed->collection));
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2005-04-03 04:43:00 -07:00
|
|
|
if (!ed->collection)
|
2003-06-23 19:33:04 -07:00
|
|
|
{
|
2005-10-05 01:38:04 -07:00
|
|
|
if (ed->file)
|
2003-06-26 07:04:31 -07:00
|
|
|
{
|
2005-10-05 01:38:04 -07:00
|
|
|
_edje_cache_file_unref(ed->file);
|
2003-06-26 07:04:31 -07:00
|
|
|
ed->file = NULL;
|
|
|
|
}
|
2003-06-23 19:33:04 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-10-22 04:34:42 -07:00
|
|
|
static Eina_List *
|
2007-03-16 14:37:57 -07:00
|
|
|
_edje_swallows_collect(Edje *ed)
|
|
|
|
{
|
2008-10-22 04:34:42 -07:00
|
|
|
Eina_List *swallows = NULL;
|
2010-08-12 05:58:54 -07:00
|
|
|
unsigned int i;
|
2007-03-16 14:37:57 -07:00
|
|
|
|
2008-02-22 02:42:50 -08:00
|
|
|
if (!ed->file || !ed->table_parts) return NULL;
|
2007-05-26 16:57:21 -07:00
|
|
|
for (i = 0; i < ed->table_parts_size; i++)
|
2007-03-16 14:37:57 -07:00
|
|
|
{
|
|
|
|
Edje_Real_Part *rp;
|
|
|
|
|
2007-05-26 16:57:21 -07:00
|
|
|
rp = ed->table_parts[i];
|
2007-05-26 22:28:07 -07:00
|
|
|
if (rp->part->type != EDJE_PART_TYPE_SWALLOW || !rp->swallowed_object) continue;
|
2008-10-22 04:34:42 -07:00
|
|
|
swallows = eina_list_append(swallows, eina_stringshare_add(rp->part->name));
|
|
|
|
swallows = eina_list_append(swallows, rp->swallowed_object);
|
2007-03-16 14:37:57 -07:00
|
|
|
}
|
|
|
|
return swallows;
|
|
|
|
}
|
|
|
|
|
2003-06-23 19:33:04 -07:00
|
|
|
void
|
|
|
|
_edje_file_del(Edje *ed)
|
|
|
|
{
|
2010-02-14 22:40:58 -08:00
|
|
|
if (ed->freeze_calc)
|
|
|
|
{
|
|
|
|
_edje_freeze_calc_list = eina_list_remove(_edje_freeze_calc_list, ed);
|
|
|
|
ed->freeze_calc = 0;
|
|
|
|
_edje_freeze_calc_count--;
|
|
|
|
}
|
2010-02-17 15:43:31 -08:00
|
|
|
_edje_entry_shutdown(ed);
|
2004-06-30 20:46:05 -07:00
|
|
|
_edje_message_del(ed);
|
2003-08-25 17:16:49 -07:00
|
|
|
_edje_block_violate(ed);
|
2004-03-30 02:30:35 -08:00
|
|
|
_edje_var_shutdown(ed);
|
2008-02-26 12:12:00 -08:00
|
|
|
_edje_programs_patterns_clean(ed);
|
2010-06-03 23:45:46 -07:00
|
|
|
// if (ed->collection)
|
|
|
|
// {
|
|
|
|
// if (ed->collection->script) _edje_embryo_script_shutdown(ed);
|
|
|
|
// }
|
2008-02-26 10:41:44 -08:00
|
|
|
|
2005-05-25 01:07:34 -07:00
|
|
|
if (!((ed->file) && (ed->collection))) return;
|
2007-05-26 16:57:21 -07:00
|
|
|
if (ed->table_parts)
|
2003-06-23 19:33:04 -07:00
|
|
|
{
|
2010-08-12 05:58:54 -07:00
|
|
|
unsigned int i;
|
2007-05-26 16:57:21 -07:00
|
|
|
for (i = 0; i < ed->table_parts_size; i++)
|
2003-06-23 19:33:04 -07:00
|
|
|
{
|
|
|
|
Edje_Real_Part *rp;
|
2003-11-24 23:22:19 -08:00
|
|
|
|
2007-05-26 16:57:21 -07:00
|
|
|
rp = ed->table_parts[i];
|
2008-10-13 02:19:04 -07:00
|
|
|
if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
|
|
|
|
_edje_entry_real_part_shutdown(rp);
|
2004-12-02 01:21:22 -08:00
|
|
|
if (rp->object)
|
|
|
|
{
|
2010-02-23 05:39:19 -08:00
|
|
|
_edje_callbacks_del(rp->object, ed);
|
|
|
|
_edje_callbacks_focus_del(rp->object, ed);
|
2004-12-02 01:21:22 -08:00
|
|
|
evas_object_del(rp->object);
|
|
|
|
}
|
2003-07-20 05:37:49 -07:00
|
|
|
if (rp->swallowed_object)
|
|
|
|
{
|
2009-11-09 15:47:42 -08:00
|
|
|
_edje_real_part_swallow_clear(rp);
|
2008-03-24 01:22:01 -07:00
|
|
|
/* Objects swallowed by the app do not get deleted,
|
2008-02-22 02:42:50 -08:00
|
|
|
but those internally swallowed (GROUP type) do. */
|
2009-10-31 11:07:08 -07:00
|
|
|
switch (rp->part->type)
|
|
|
|
{
|
|
|
|
case EDJE_PART_TYPE_EXTERNAL:
|
|
|
|
_edje_external_parsed_params_free(rp->swallowed_object, rp->param1.external_params);
|
|
|
|
if (rp->param2)
|
|
|
|
_edje_external_parsed_params_free(rp->swallowed_object, rp->param2->external_params);
|
|
|
|
case EDJE_PART_TYPE_GROUP:
|
|
|
|
evas_object_del(rp->swallowed_object);
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2007-09-12 10:42:21 -07:00
|
|
|
rp->swallowed_object = NULL;
|
2003-07-20 05:37:49 -07:00
|
|
|
}
|
2008-11-23 21:15:15 -08:00
|
|
|
if (rp->items)
|
|
|
|
{
|
2009-08-11 03:06:37 -07:00
|
|
|
/* evas_box/table handles deletion of objects */
|
|
|
|
rp->items = eina_list_free(rp->items);
|
2008-11-23 21:15:15 -08:00
|
|
|
}
|
2008-10-15 07:11:11 -07:00
|
|
|
if (rp->text.text) eina_stringshare_del(rp->text.text);
|
|
|
|
if (rp->text.font) eina_stringshare_del(rp->text.font);
|
|
|
|
if (rp->text.cache.in_str) eina_stringshare_del(rp->text.cache.in_str);
|
|
|
|
if (rp->text.cache.out_str) eina_stringshare_del(rp->text.cache.out_str);
|
2004-10-29 10:56:12 -07:00
|
|
|
|
2009-08-14 10:19:42 -07:00
|
|
|
if (rp->custom)
|
From: "Hanspeter Portner" <ventosus@airpost.net>
This concerns Ticket #109: Add Lua support for Edje
It adds Lua as scripting facility to Edje, letting Embryo untouched.
It should be easier to use and be more flexible than Embryo, imho ;-)
---
The patch
---
Lua 5.1 is used in sandboxed mode. Lua byte code is not
platform/architecture independent, Lua code is saved as text in the Edje
container and parsed at load time, therefore.
The patch goes in two directions
1) Analogous to Embryo for scripting logic, messaging and custom states.
The same things are implemented as in Embryo:
- messaging from and to C
- manual creation of timers, animators, pollers for custom events /
animations
- manual manipulation of Edje parts by means of the public
edje_object_part_* and internal functions and custom states
-> those routines are actually implemented as Lua
bindings to
functions in Edje.h and Ecore.h
-> the implementation is done in an object oriented way, so that the
interface gives the feel of an object description language, pretty
similar to EDC itself
-> combining custom states and custom animators allows
for fancy
animations and transitions, e.g circular/spline translations or
complex/conditional transitions, etc.
-> this is just the same as Embryo does, but implemented in Lua, so
nothing new here, actually
2) Dynamic object creation and manipulation
- this interface stems from the 'script_only' objects in
Edje. Those
objects are a kind of scriptable Edje counterparts to Evas_Smart
objects. The infrastructure for Embryo is already there, but has
never been used
- I added this in Lua and added some first bindings to
experiment
with
- I thought it would be useful to allow for a limited dynamic
creation of ui parts
- We can create instances of groups from within the same Edje
container and use them just like the main Edje object as
stated in
1)
- And there are some stand-alone bindings to dynamically create
Evas_Image, Evas_Table, Evas_Line, Evas_Polygon as examples
-> this may be useful to decouple the program from the ui
even more,
to be able to do things that have to be done in the program itself
atm, but actually belong to the user interface, but need dynamic
creation of objects or complex interactions
-> those objects are manipulated manually with Lua bindings
to the
corresponding edje_object_* and evas_object_* functions
---
Discussion points
---
Both stuff in 1) & 2) is functioning, but needs testing, feedback,
improvements, ...
Stuff in 1) can already fully replace Embryo scripting with Lua
scripting. There still is space for improvements/additions, though.
Of the stuff in 2), I think it may only make sense to add the dynamic
creation of groups defined in the same Edje container. Dynamic creation
of other Evas_Objects makes not much sense, as most of them can already
be used as Edje parts and be manipulated with custom states (apart from
polygons and lines) and it would make the whole theming potentially more
programing-like and much more susceptible for errors, etc.
Would this be useful, or drop it all?
The scripting should be there just for logic, conditionals, custom
states and animations, not for a whole dynamic canvas, imho.
There is a patch around with EXTERNAL Edje parts. Seems to be a better,
faster, more secure way to extend Edje with custom objects.
There would be the possibility of precompiling Lua code at compile time
(edje_cc) for faster loading, but we would have to patch and run our own
Lua version.
The Lua parser is pretty fast, though, and using
byte-converted/endianness-swapped byte-code does only pay off for Lua
chunks of some kilo lines.
Byte code also occupies much more space than text in the final Edje
container, as it includes debug symbols.
---
Cedric and Vincent told me, that the plan was to replace Embryo totally
by Lua before the official release of Edje at the end of the year? So it
would make sense to bring Lua to svn soon and look how it fits in, test,
debug, adapt it further to the themers needs, decide on its final shape,
GATHER SOME PEOPLE TO HELP ;-)
---
The Lua enhanced Edje is in sync with svn and can be get directly here
git clone git://repo.or.cz/edje_lua.git
cd edje_lua
git checkout -b lua_patch origin/lua_patch
or apply the attached patch
There are also some examples to show the usage of the things
mentioned
above
- showcase.edj: shows usage of custom animators, custom states,
messaging and the script_only object
- test.edj: test cases of script usage and bindings (custom states,
custom transitions, tween_states, animators, timers,
object_parts),
but most of it are experimental script_only objects
http://didgmo.sourceforge.net/showcase.edj
http://didgmo.sourceforge.net/test.edj
The source of showcase.edc is attached, too, to just have a glimpse at
Lua inside of EDC
---
So, what do you guys think?
Thanks and sry for the looong mail, hehe ;-)
SVN revision: 41802
2009-08-15 19:34:02 -07:00
|
|
|
{
|
2010-04-06 04:26:32 -07:00
|
|
|
#ifdef LUA2
|
|
|
|
// xxx: lua2
|
|
|
|
#else
|
From: "Hanspeter Portner" <ventosus@airpost.net>
This concerns Ticket #109: Add Lua support for Edje
It adds Lua as scripting facility to Edje, letting Embryo untouched.
It should be easier to use and be more flexible than Embryo, imho ;-)
---
The patch
---
Lua 5.1 is used in sandboxed mode. Lua byte code is not
platform/architecture independent, Lua code is saved as text in the Edje
container and parsed at load time, therefore.
The patch goes in two directions
1) Analogous to Embryo for scripting logic, messaging and custom states.
The same things are implemented as in Embryo:
- messaging from and to C
- manual creation of timers, animators, pollers for custom events /
animations
- manual manipulation of Edje parts by means of the public
edje_object_part_* and internal functions and custom states
-> those routines are actually implemented as Lua
bindings to
functions in Edje.h and Ecore.h
-> the implementation is done in an object oriented way, so that the
interface gives the feel of an object description language, pretty
similar to EDC itself
-> combining custom states and custom animators allows
for fancy
animations and transitions, e.g circular/spline translations or
complex/conditional transitions, etc.
-> this is just the same as Embryo does, but implemented in Lua, so
nothing new here, actually
2) Dynamic object creation and manipulation
- this interface stems from the 'script_only' objects in
Edje. Those
objects are a kind of scriptable Edje counterparts to Evas_Smart
objects. The infrastructure for Embryo is already there, but has
never been used
- I added this in Lua and added some first bindings to
experiment
with
- I thought it would be useful to allow for a limited dynamic
creation of ui parts
- We can create instances of groups from within the same Edje
container and use them just like the main Edje object as
stated in
1)
- And there are some stand-alone bindings to dynamically create
Evas_Image, Evas_Table, Evas_Line, Evas_Polygon as examples
-> this may be useful to decouple the program from the ui
even more,
to be able to do things that have to be done in the program itself
atm, but actually belong to the user interface, but need dynamic
creation of objects or complex interactions
-> those objects are manipulated manually with Lua bindings
to the
corresponding edje_object_* and evas_object_* functions
---
Discussion points
---
Both stuff in 1) & 2) is functioning, but needs testing, feedback,
improvements, ...
Stuff in 1) can already fully replace Embryo scripting with Lua
scripting. There still is space for improvements/additions, though.
Of the stuff in 2), I think it may only make sense to add the dynamic
creation of groups defined in the same Edje container. Dynamic creation
of other Evas_Objects makes not much sense, as most of them can already
be used as Edje parts and be manipulated with custom states (apart from
polygons and lines) and it would make the whole theming potentially more
programing-like and much more susceptible for errors, etc.
Would this be useful, or drop it all?
The scripting should be there just for logic, conditionals, custom
states and animations, not for a whole dynamic canvas, imho.
There is a patch around with EXTERNAL Edje parts. Seems to be a better,
faster, more secure way to extend Edje with custom objects.
There would be the possibility of precompiling Lua code at compile time
(edje_cc) for faster loading, but we would have to patch and run our own
Lua version.
The Lua parser is pretty fast, though, and using
byte-converted/endianness-swapped byte-code does only pay off for Lua
chunks of some kilo lines.
Byte code also occupies much more space than text in the final Edje
container, as it includes debug symbols.
---
Cedric and Vincent told me, that the plan was to replace Embryo totally
by Lua before the official release of Edje at the end of the year? So it
would make sense to bring Lua to svn soon and look how it fits in, test,
debug, adapt it further to the themers needs, decide on its final shape,
GATHER SOME PEOPLE TO HELP ;-)
---
The Lua enhanced Edje is in sync with svn and can be get directly here
git clone git://repo.or.cz/edje_lua.git
cd edje_lua
git checkout -b lua_patch origin/lua_patch
or apply the attached patch
There are also some examples to show the usage of the things
mentioned
above
- showcase.edj: shows usage of custom animators, custom states,
messaging and the script_only object
- test.edj: test cases of script usage and bindings (custom states,
custom transitions, tween_states, animators, timers,
object_parts),
but most of it are experimental script_only objects
http://didgmo.sourceforge.net/showcase.edj
http://didgmo.sourceforge.net/test.edj
The source of showcase.edc is attached, too, to just have a glimpse at
Lua inside of EDC
---
So, what do you guys think?
Thanks and sry for the looong mail, hehe ;-)
SVN revision: 41802
2009-08-15 19:34:02 -07:00
|
|
|
if (ed->L)
|
|
|
|
{
|
|
|
|
_edje_lua_get_reg(ed->L, rp->custom->description);
|
|
|
|
_edje_lua_free_reg(ed->L, lua_touserdata(ed->L, -1)); // created in edje_lua.c::_edje_lua_part_fn_custom_state
|
|
|
|
lua_pop(ed->L, 1);
|
|
|
|
_edje_lua_free_reg(ed->L, rp->custom->description); // created in edje_lua.c::_edje_lua_part_fn_custom_state
|
|
|
|
}
|
2010-06-28 06:56:30 -07:00
|
|
|
#endif
|
2010-07-29 05:02:36 -07:00
|
|
|
_edje_collection_free_part_description_clean(rp->part->type,
|
|
|
|
rp->custom->description,
|
|
|
|
ed->file->free_strings);
|
|
|
|
free(rp->custom->description);
|
|
|
|
rp->custom->description = NULL;
|
From: "Hanspeter Portner" <ventosus@airpost.net>
This concerns Ticket #109: Add Lua support for Edje
It adds Lua as scripting facility to Edje, letting Embryo untouched.
It should be easier to use and be more flexible than Embryo, imho ;-)
---
The patch
---
Lua 5.1 is used in sandboxed mode. Lua byte code is not
platform/architecture independent, Lua code is saved as text in the Edje
container and parsed at load time, therefore.
The patch goes in two directions
1) Analogous to Embryo for scripting logic, messaging and custom states.
The same things are implemented as in Embryo:
- messaging from and to C
- manual creation of timers, animators, pollers for custom events /
animations
- manual manipulation of Edje parts by means of the public
edje_object_part_* and internal functions and custom states
-> those routines are actually implemented as Lua
bindings to
functions in Edje.h and Ecore.h
-> the implementation is done in an object oriented way, so that the
interface gives the feel of an object description language, pretty
similar to EDC itself
-> combining custom states and custom animators allows
for fancy
animations and transitions, e.g circular/spline translations or
complex/conditional transitions, etc.
-> this is just the same as Embryo does, but implemented in Lua, so
nothing new here, actually
2) Dynamic object creation and manipulation
- this interface stems from the 'script_only' objects in
Edje. Those
objects are a kind of scriptable Edje counterparts to Evas_Smart
objects. The infrastructure for Embryo is already there, but has
never been used
- I added this in Lua and added some first bindings to
experiment
with
- I thought it would be useful to allow for a limited dynamic
creation of ui parts
- We can create instances of groups from within the same Edje
container and use them just like the main Edje object as
stated in
1)
- And there are some stand-alone bindings to dynamically create
Evas_Image, Evas_Table, Evas_Line, Evas_Polygon as examples
-> this may be useful to decouple the program from the ui
even more,
to be able to do things that have to be done in the program itself
atm, but actually belong to the user interface, but need dynamic
creation of objects or complex interactions
-> those objects are manipulated manually with Lua bindings
to the
corresponding edje_object_* and evas_object_* functions
---
Discussion points
---
Both stuff in 1) & 2) is functioning, but needs testing, feedback,
improvements, ...
Stuff in 1) can already fully replace Embryo scripting with Lua
scripting. There still is space for improvements/additions, though.
Of the stuff in 2), I think it may only make sense to add the dynamic
creation of groups defined in the same Edje container. Dynamic creation
of other Evas_Objects makes not much sense, as most of them can already
be used as Edje parts and be manipulated with custom states (apart from
polygons and lines) and it would make the whole theming potentially more
programing-like and much more susceptible for errors, etc.
Would this be useful, or drop it all?
The scripting should be there just for logic, conditionals, custom
states and animations, not for a whole dynamic canvas, imho.
There is a patch around with EXTERNAL Edje parts. Seems to be a better,
faster, more secure way to extend Edje with custom objects.
There would be the possibility of precompiling Lua code at compile time
(edje_cc) for faster loading, but we would have to patch and run our own
Lua version.
The Lua parser is pretty fast, though, and using
byte-converted/endianness-swapped byte-code does only pay off for Lua
chunks of some kilo lines.
Byte code also occupies much more space than text in the final Edje
container, as it includes debug symbols.
---
Cedric and Vincent told me, that the plan was to replace Embryo totally
by Lua before the official release of Edje at the end of the year? So it
would make sense to bring Lua to svn soon and look how it fits in, test,
debug, adapt it further to the themers needs, decide on its final shape,
GATHER SOME PEOPLE TO HELP ;-)
---
The Lua enhanced Edje is in sync with svn and can be get directly here
git clone git://repo.or.cz/edje_lua.git
cd edje_lua
git checkout -b lua_patch origin/lua_patch
or apply the attached patch
There are also some examples to show the usage of the things
mentioned
above
- showcase.edj: shows usage of custom animators, custom states,
messaging and the script_only object
- test.edj: test cases of script usage and bindings (custom states,
custom transitions, tween_states, animators, timers,
object_parts),
but most of it are experimental script_only objects
http://didgmo.sourceforge.net/showcase.edj
http://didgmo.sourceforge.net/test.edj
The source of showcase.edc is attached, too, to just have a glimpse at
Lua inside of EDC
---
So, what do you guys think?
Thanks and sry for the looong mail, hehe ;-)
SVN revision: 41802
2009-08-15 19:34:02 -07:00
|
|
|
}
|
2004-10-29 10:56:12 -07:00
|
|
|
|
2009-08-14 10:19:42 -07:00
|
|
|
/* Cleanup optional part. */
|
2009-08-11 06:07:46 -07:00
|
|
|
free(rp->drag);
|
2010-06-01 06:31:07 -07:00
|
|
|
free(rp->param1.set);
|
2009-08-11 06:07:46 -07:00
|
|
|
|
2010-06-01 06:31:07 -07:00
|
|
|
if (rp->param2)
|
|
|
|
free(rp->param2->set);
|
2009-08-14 10:19:42 -07:00
|
|
|
eina_mempool_free(_edje_real_part_state_mp, rp->param2);
|
2010-06-01 06:31:07 -07:00
|
|
|
|
|
|
|
if (rp->custom)
|
|
|
|
free(rp->custom->set);
|
2009-08-14 10:19:42 -07:00
|
|
|
eina_mempool_free(_edje_real_part_state_mp, rp->custom);
|
|
|
|
|
2007-05-26 22:28:07 -07:00
|
|
|
_edje_unref(rp->edje);
|
2009-08-14 10:19:42 -07:00
|
|
|
eina_mempool_free(_edje_real_part_mp, rp);
|
2003-06-23 19:33:04 -07:00
|
|
|
}
|
|
|
|
}
|
2008-12-08 06:23:26 -08:00
|
|
|
if ((ed->file) && (ed->collection))
|
|
|
|
{
|
|
|
|
Edje_Part *ep;
|
2010-07-29 05:02:36 -07:00
|
|
|
unsigned int i;
|
2008-12-08 06:23:26 -08:00
|
|
|
|
|
|
|
_edje_textblock_styles_del(ed);
|
2010-07-29 05:02:36 -07:00
|
|
|
for (i = 0; i < ed->collection->parts_count; ++i)
|
2009-09-10 17:48:57 -07:00
|
|
|
{
|
2010-07-29 05:02:36 -07:00
|
|
|
ep = ed->collection->parts[i];
|
|
|
|
|
|
|
|
_edje_text_part_on_del(ed, ep);
|
|
|
|
_edje_color_class_on_del(ed, ep);
|
2009-09-10 17:48:57 -07:00
|
|
|
}
|
2010-07-29 05:02:36 -07:00
|
|
|
|
2008-12-08 06:23:26 -08:00
|
|
|
_edje_cache_coll_unref(ed->file, ed->collection);
|
|
|
|
ed->collection = NULL;
|
|
|
|
}
|
2008-03-01 18:34:23 -08:00
|
|
|
if (ed->file)
|
|
|
|
{
|
|
|
|
_edje_cache_file_unref(ed->file);
|
|
|
|
ed->file = NULL;
|
|
|
|
}
|
2003-06-23 19:33:04 -07:00
|
|
|
if (ed->actions)
|
|
|
|
{
|
2009-08-11 03:06:37 -07:00
|
|
|
Edje_Running_Program *runp;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2009-08-11 03:06:37 -07:00
|
|
|
EINA_LIST_FREE(ed->actions, runp)
|
|
|
|
{
|
2003-06-26 07:04:31 -07:00
|
|
|
_edje_anim_count--;
|
|
|
|
free(runp);
|
|
|
|
}
|
2003-06-23 19:33:04 -07:00
|
|
|
}
|
2008-10-22 04:34:42 -07:00
|
|
|
_edje_animators = eina_list_remove(_edje_animators, ed);
|
2003-06-27 21:20:41 -07:00
|
|
|
if (ed->pending_actions)
|
|
|
|
{
|
2009-08-11 03:06:37 -07:00
|
|
|
Edje_Pending_Program *pp;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2009-08-11 03:06:37 -07:00
|
|
|
EINA_LIST_FREE(ed->pending_actions, pp)
|
|
|
|
{
|
2003-06-27 21:20:41 -07:00
|
|
|
ecore_timer_del(pp->timer);
|
|
|
|
free(pp);
|
|
|
|
}
|
|
|
|
}
|
From: "Hanspeter Portner" <ventosus@airpost.net>
This concerns Ticket #109: Add Lua support for Edje
It adds Lua as scripting facility to Edje, letting Embryo untouched.
It should be easier to use and be more flexible than Embryo, imho ;-)
---
The patch
---
Lua 5.1 is used in sandboxed mode. Lua byte code is not
platform/architecture independent, Lua code is saved as text in the Edje
container and parsed at load time, therefore.
The patch goes in two directions
1) Analogous to Embryo for scripting logic, messaging and custom states.
The same things are implemented as in Embryo:
- messaging from and to C
- manual creation of timers, animators, pollers for custom events /
animations
- manual manipulation of Edje parts by means of the public
edje_object_part_* and internal functions and custom states
-> those routines are actually implemented as Lua
bindings to
functions in Edje.h and Ecore.h
-> the implementation is done in an object oriented way, so that the
interface gives the feel of an object description language, pretty
similar to EDC itself
-> combining custom states and custom animators allows
for fancy
animations and transitions, e.g circular/spline translations or
complex/conditional transitions, etc.
-> this is just the same as Embryo does, but implemented in Lua, so
nothing new here, actually
2) Dynamic object creation and manipulation
- this interface stems from the 'script_only' objects in
Edje. Those
objects are a kind of scriptable Edje counterparts to Evas_Smart
objects. The infrastructure for Embryo is already there, but has
never been used
- I added this in Lua and added some first bindings to
experiment
with
- I thought it would be useful to allow for a limited dynamic
creation of ui parts
- We can create instances of groups from within the same Edje
container and use them just like the main Edje object as
stated in
1)
- And there are some stand-alone bindings to dynamically create
Evas_Image, Evas_Table, Evas_Line, Evas_Polygon as examples
-> this may be useful to decouple the program from the ui
even more,
to be able to do things that have to be done in the program itself
atm, but actually belong to the user interface, but need dynamic
creation of objects or complex interactions
-> those objects are manipulated manually with Lua bindings
to the
corresponding edje_object_* and evas_object_* functions
---
Discussion points
---
Both stuff in 1) & 2) is functioning, but needs testing, feedback,
improvements, ...
Stuff in 1) can already fully replace Embryo scripting with Lua
scripting. There still is space for improvements/additions, though.
Of the stuff in 2), I think it may only make sense to add the dynamic
creation of groups defined in the same Edje container. Dynamic creation
of other Evas_Objects makes not much sense, as most of them can already
be used as Edje parts and be manipulated with custom states (apart from
polygons and lines) and it would make the whole theming potentially more
programing-like and much more susceptible for errors, etc.
Would this be useful, or drop it all?
The scripting should be there just for logic, conditionals, custom
states and animations, not for a whole dynamic canvas, imho.
There is a patch around with EXTERNAL Edje parts. Seems to be a better,
faster, more secure way to extend Edje with custom objects.
There would be the possibility of precompiling Lua code at compile time
(edje_cc) for faster loading, but we would have to patch and run our own
Lua version.
The Lua parser is pretty fast, though, and using
byte-converted/endianness-swapped byte-code does only pay off for Lua
chunks of some kilo lines.
Byte code also occupies much more space than text in the final Edje
container, as it includes debug symbols.
---
Cedric and Vincent told me, that the plan was to replace Embryo totally
by Lua before the official release of Edje at the end of the year? So it
would make sense to bring Lua to svn soon and look how it fits in, test,
debug, adapt it further to the themers needs, decide on its final shape,
GATHER SOME PEOPLE TO HELP ;-)
---
The Lua enhanced Edje is in sync with svn and can be get directly here
git clone git://repo.or.cz/edje_lua.git
cd edje_lua
git checkout -b lua_patch origin/lua_patch
or apply the attached patch
There are also some examples to show the usage of the things
mentioned
above
- showcase.edj: shows usage of custom animators, custom states,
messaging and the script_only object
- test.edj: test cases of script usage and bindings (custom states,
custom transitions, tween_states, animators, timers,
object_parts),
but most of it are experimental script_only objects
http://didgmo.sourceforge.net/showcase.edj
http://didgmo.sourceforge.net/test.edj
The source of showcase.edc is attached, too, to just have a glimpse at
Lua inside of EDC
---
So, what do you guys think?
Thanks and sry for the looong mail, hehe ;-)
SVN revision: 41802
2009-08-15 19:34:02 -07:00
|
|
|
if (ed->L)
|
|
|
|
{
|
2010-04-06 04:26:32 -07:00
|
|
|
#ifdef LUA2
|
|
|
|
_edje_lua2_script_shutdown(ed);
|
|
|
|
#else
|
From: "Hanspeter Portner" <ventosus@airpost.net>
This concerns Ticket #109: Add Lua support for Edje
It adds Lua as scripting facility to Edje, letting Embryo untouched.
It should be easier to use and be more flexible than Embryo, imho ;-)
---
The patch
---
Lua 5.1 is used in sandboxed mode. Lua byte code is not
platform/architecture independent, Lua code is saved as text in the Edje
container and parsed at load time, therefore.
The patch goes in two directions
1) Analogous to Embryo for scripting logic, messaging and custom states.
The same things are implemented as in Embryo:
- messaging from and to C
- manual creation of timers, animators, pollers for custom events /
animations
- manual manipulation of Edje parts by means of the public
edje_object_part_* and internal functions and custom states
-> those routines are actually implemented as Lua
bindings to
functions in Edje.h and Ecore.h
-> the implementation is done in an object oriented way, so that the
interface gives the feel of an object description language, pretty
similar to EDC itself
-> combining custom states and custom animators allows
for fancy
animations and transitions, e.g circular/spline translations or
complex/conditional transitions, etc.
-> this is just the same as Embryo does, but implemented in Lua, so
nothing new here, actually
2) Dynamic object creation and manipulation
- this interface stems from the 'script_only' objects in
Edje. Those
objects are a kind of scriptable Edje counterparts to Evas_Smart
objects. The infrastructure for Embryo is already there, but has
never been used
- I added this in Lua and added some first bindings to
experiment
with
- I thought it would be useful to allow for a limited dynamic
creation of ui parts
- We can create instances of groups from within the same Edje
container and use them just like the main Edje object as
stated in
1)
- And there are some stand-alone bindings to dynamically create
Evas_Image, Evas_Table, Evas_Line, Evas_Polygon as examples
-> this may be useful to decouple the program from the ui
even more,
to be able to do things that have to be done in the program itself
atm, but actually belong to the user interface, but need dynamic
creation of objects or complex interactions
-> those objects are manipulated manually with Lua bindings
to the
corresponding edje_object_* and evas_object_* functions
---
Discussion points
---
Both stuff in 1) & 2) is functioning, but needs testing, feedback,
improvements, ...
Stuff in 1) can already fully replace Embryo scripting with Lua
scripting. There still is space for improvements/additions, though.
Of the stuff in 2), I think it may only make sense to add the dynamic
creation of groups defined in the same Edje container. Dynamic creation
of other Evas_Objects makes not much sense, as most of them can already
be used as Edje parts and be manipulated with custom states (apart from
polygons and lines) and it would make the whole theming potentially more
programing-like and much more susceptible for errors, etc.
Would this be useful, or drop it all?
The scripting should be there just for logic, conditionals, custom
states and animations, not for a whole dynamic canvas, imho.
There is a patch around with EXTERNAL Edje parts. Seems to be a better,
faster, more secure way to extend Edje with custom objects.
There would be the possibility of precompiling Lua code at compile time
(edje_cc) for faster loading, but we would have to patch and run our own
Lua version.
The Lua parser is pretty fast, though, and using
byte-converted/endianness-swapped byte-code does only pay off for Lua
chunks of some kilo lines.
Byte code also occupies much more space than text in the final Edje
container, as it includes debug symbols.
---
Cedric and Vincent told me, that the plan was to replace Embryo totally
by Lua before the official release of Edje at the end of the year? So it
would make sense to bring Lua to svn soon and look how it fits in, test,
debug, adapt it further to the themers needs, decide on its final shape,
GATHER SOME PEOPLE TO HELP ;-)
---
The Lua enhanced Edje is in sync with svn and can be get directly here
git clone git://repo.or.cz/edje_lua.git
cd edje_lua
git checkout -b lua_patch origin/lua_patch
or apply the attached patch
There are also some examples to show the usage of the things
mentioned
above
- showcase.edj: shows usage of custom animators, custom states,
messaging and the script_only object
- test.edj: test cases of script usage and bindings (custom states,
custom transitions, tween_states, animators, timers,
object_parts),
but most of it are experimental script_only objects
http://didgmo.sourceforge.net/showcase.edj
http://didgmo.sourceforge.net/test.edj
The source of showcase.edc is attached, too, to just have a glimpse at
Lua inside of EDC
---
So, what do you guys think?
Thanks and sry for the looong mail, hehe ;-)
SVN revision: 41802
2009-08-15 19:34:02 -07:00
|
|
|
_edje_lua_free_reg(ed->L, ed); // created in edje_lua.c::_edje_lua_script_fn_new/_edje_lua_group_fn_new
|
|
|
|
_edje_lua_free_reg(ed->L, ed->L); // created in edje_program.c::_edje_program_run/edje_lua_script_only.c::_edje_lua_script_only_init
|
2010-04-02 04:05:53 -07:00
|
|
|
_edje_lua_free_thread(ed, ed->L); // created in edje_program.c::_edje_program_run/edje_lua_script_only.c::_edje_lua_script_only_init
|
From: "Hanspeter Portner" <ventosus@airpost.net>
This concerns Ticket #109: Add Lua support for Edje
It adds Lua as scripting facility to Edje, letting Embryo untouched.
It should be easier to use and be more flexible than Embryo, imho ;-)
---
The patch
---
Lua 5.1 is used in sandboxed mode. Lua byte code is not
platform/architecture independent, Lua code is saved as text in the Edje
container and parsed at load time, therefore.
The patch goes in two directions
1) Analogous to Embryo for scripting logic, messaging and custom states.
The same things are implemented as in Embryo:
- messaging from and to C
- manual creation of timers, animators, pollers for custom events /
animations
- manual manipulation of Edje parts by means of the public
edje_object_part_* and internal functions and custom states
-> those routines are actually implemented as Lua
bindings to
functions in Edje.h and Ecore.h
-> the implementation is done in an object oriented way, so that the
interface gives the feel of an object description language, pretty
similar to EDC itself
-> combining custom states and custom animators allows
for fancy
animations and transitions, e.g circular/spline translations or
complex/conditional transitions, etc.
-> this is just the same as Embryo does, but implemented in Lua, so
nothing new here, actually
2) Dynamic object creation and manipulation
- this interface stems from the 'script_only' objects in
Edje. Those
objects are a kind of scriptable Edje counterparts to Evas_Smart
objects. The infrastructure for Embryo is already there, but has
never been used
- I added this in Lua and added some first bindings to
experiment
with
- I thought it would be useful to allow for a limited dynamic
creation of ui parts
- We can create instances of groups from within the same Edje
container and use them just like the main Edje object as
stated in
1)
- And there are some stand-alone bindings to dynamically create
Evas_Image, Evas_Table, Evas_Line, Evas_Polygon as examples
-> this may be useful to decouple the program from the ui
even more,
to be able to do things that have to be done in the program itself
atm, but actually belong to the user interface, but need dynamic
creation of objects or complex interactions
-> those objects are manipulated manually with Lua bindings
to the
corresponding edje_object_* and evas_object_* functions
---
Discussion points
---
Both stuff in 1) & 2) is functioning, but needs testing, feedback,
improvements, ...
Stuff in 1) can already fully replace Embryo scripting with Lua
scripting. There still is space for improvements/additions, though.
Of the stuff in 2), I think it may only make sense to add the dynamic
creation of groups defined in the same Edje container. Dynamic creation
of other Evas_Objects makes not much sense, as most of them can already
be used as Edje parts and be manipulated with custom states (apart from
polygons and lines) and it would make the whole theming potentially more
programing-like and much more susceptible for errors, etc.
Would this be useful, or drop it all?
The scripting should be there just for logic, conditionals, custom
states and animations, not for a whole dynamic canvas, imho.
There is a patch around with EXTERNAL Edje parts. Seems to be a better,
faster, more secure way to extend Edje with custom objects.
There would be the possibility of precompiling Lua code at compile time
(edje_cc) for faster loading, but we would have to patch and run our own
Lua version.
The Lua parser is pretty fast, though, and using
byte-converted/endianness-swapped byte-code does only pay off for Lua
chunks of some kilo lines.
Byte code also occupies much more space than text in the final Edje
container, as it includes debug symbols.
---
Cedric and Vincent told me, that the plan was to replace Embryo totally
by Lua before the official release of Edje at the end of the year? So it
would make sense to bring Lua to svn soon and look how it fits in, test,
debug, adapt it further to the themers needs, decide on its final shape,
GATHER SOME PEOPLE TO HELP ;-)
---
The Lua enhanced Edje is in sync with svn and can be get directly here
git clone git://repo.or.cz/edje_lua.git
cd edje_lua
git checkout -b lua_patch origin/lua_patch
or apply the attached patch
There are also some examples to show the usage of the things
mentioned
above
- showcase.edj: shows usage of custom animators, custom states,
messaging and the script_only object
- test.edj: test cases of script usage and bindings (custom states,
custom transitions, tween_states, animators, timers,
object_parts),
but most of it are experimental script_only objects
http://didgmo.sourceforge.net/showcase.edj
http://didgmo.sourceforge.net/test.edj
The source of showcase.edc is attached, too, to just have a glimpse at
Lua inside of EDC
---
So, what do you guys think?
Thanks and sry for the looong mail, hehe ;-)
SVN revision: 41802
2009-08-15 19:34:02 -07:00
|
|
|
ed->L = NULL;
|
2010-04-06 04:26:32 -07:00
|
|
|
#endif
|
From: "Hanspeter Portner" <ventosus@airpost.net>
This concerns Ticket #109: Add Lua support for Edje
It adds Lua as scripting facility to Edje, letting Embryo untouched.
It should be easier to use and be more flexible than Embryo, imho ;-)
---
The patch
---
Lua 5.1 is used in sandboxed mode. Lua byte code is not
platform/architecture independent, Lua code is saved as text in the Edje
container and parsed at load time, therefore.
The patch goes in two directions
1) Analogous to Embryo for scripting logic, messaging and custom states.
The same things are implemented as in Embryo:
- messaging from and to C
- manual creation of timers, animators, pollers for custom events /
animations
- manual manipulation of Edje parts by means of the public
edje_object_part_* and internal functions and custom states
-> those routines are actually implemented as Lua
bindings to
functions in Edje.h and Ecore.h
-> the implementation is done in an object oriented way, so that the
interface gives the feel of an object description language, pretty
similar to EDC itself
-> combining custom states and custom animators allows
for fancy
animations and transitions, e.g circular/spline translations or
complex/conditional transitions, etc.
-> this is just the same as Embryo does, but implemented in Lua, so
nothing new here, actually
2) Dynamic object creation and manipulation
- this interface stems from the 'script_only' objects in
Edje. Those
objects are a kind of scriptable Edje counterparts to Evas_Smart
objects. The infrastructure for Embryo is already there, but has
never been used
- I added this in Lua and added some first bindings to
experiment
with
- I thought it would be useful to allow for a limited dynamic
creation of ui parts
- We can create instances of groups from within the same Edje
container and use them just like the main Edje object as
stated in
1)
- And there are some stand-alone bindings to dynamically create
Evas_Image, Evas_Table, Evas_Line, Evas_Polygon as examples
-> this may be useful to decouple the program from the ui
even more,
to be able to do things that have to be done in the program itself
atm, but actually belong to the user interface, but need dynamic
creation of objects or complex interactions
-> those objects are manipulated manually with Lua bindings
to the
corresponding edje_object_* and evas_object_* functions
---
Discussion points
---
Both stuff in 1) & 2) is functioning, but needs testing, feedback,
improvements, ...
Stuff in 1) can already fully replace Embryo scripting with Lua
scripting. There still is space for improvements/additions, though.
Of the stuff in 2), I think it may only make sense to add the dynamic
creation of groups defined in the same Edje container. Dynamic creation
of other Evas_Objects makes not much sense, as most of them can already
be used as Edje parts and be manipulated with custom states (apart from
polygons and lines) and it would make the whole theming potentially more
programing-like and much more susceptible for errors, etc.
Would this be useful, or drop it all?
The scripting should be there just for logic, conditionals, custom
states and animations, not for a whole dynamic canvas, imho.
There is a patch around with EXTERNAL Edje parts. Seems to be a better,
faster, more secure way to extend Edje with custom objects.
There would be the possibility of precompiling Lua code at compile time
(edje_cc) for faster loading, but we would have to patch and run our own
Lua version.
The Lua parser is pretty fast, though, and using
byte-converted/endianness-swapped byte-code does only pay off for Lua
chunks of some kilo lines.
Byte code also occupies much more space than text in the final Edje
container, as it includes debug symbols.
---
Cedric and Vincent told me, that the plan was to replace Embryo totally
by Lua before the official release of Edje at the end of the year? So it
would make sense to bring Lua to svn soon and look how it fits in, test,
debug, adapt it further to the themers needs, decide on its final shape,
GATHER SOME PEOPLE TO HELP ;-)
---
The Lua enhanced Edje is in sync with svn and can be get directly here
git clone git://repo.or.cz/edje_lua.git
cd edje_lua
git checkout -b lua_patch origin/lua_patch
or apply the attached patch
There are also some examples to show the usage of the things
mentioned
above
- showcase.edj: shows usage of custom animators, custom states,
messaging and the script_only object
- test.edj: test cases of script usage and bindings (custom states,
custom transitions, tween_states, animators, timers,
object_parts),
but most of it are experimental script_only objects
http://didgmo.sourceforge.net/showcase.edj
http://didgmo.sourceforge.net/test.edj
The source of showcase.edc is attached, too, to just have a glimpse at
Lua inside of EDC
---
So, what do you guys think?
Thanks and sry for the looong mail, hehe ;-)
SVN revision: 41802
2009-08-15 19:34:02 -07:00
|
|
|
}
|
2004-04-01 07:32:17 -08:00
|
|
|
if (ed->table_parts) free(ed->table_parts);
|
|
|
|
ed->table_parts = NULL;
|
|
|
|
ed->table_parts_size = 0;
|
|
|
|
if (ed->table_programs) free(ed->table_programs);
|
|
|
|
ed->table_programs = NULL;
|
|
|
|
ed->table_programs_size = 0;
|
2003-06-23 19:33:04 -07:00
|
|
|
}
|
2007-03-06 04:03:34 -08:00
|
|
|
|
2003-06-23 19:33:04 -07:00
|
|
|
void
|
|
|
|
_edje_file_free(Edje_File *edf)
|
|
|
|
{
|
2009-08-11 03:06:37 -07:00
|
|
|
Edje_Color_Class *ecc;
|
|
|
|
|
2010-06-28 06:56:30 -07:00
|
|
|
#define HASH_FREE(Hash) \
|
2010-08-09 10:34:03 -07:00
|
|
|
if (Hash) eina_hash_free(Hash); \
|
2010-06-28 06:56:30 -07:00
|
|
|
Hash = NULL;
|
|
|
|
|
2010-07-29 05:02:36 -07:00
|
|
|
/* Clean cache before cleaning memory pool */
|
|
|
|
if (edf->collection_cache) _edje_cache_coll_flush(edf);
|
|
|
|
|
2010-06-28 06:56:30 -07:00
|
|
|
HASH_FREE(edf->fonts);
|
|
|
|
HASH_FREE(edf->collection);
|
|
|
|
HASH_FREE(edf->data);
|
|
|
|
|
2003-07-07 00:55:18 -07:00
|
|
|
if (edf->image_dir)
|
|
|
|
{
|
2010-06-29 06:48:03 -07:00
|
|
|
unsigned int i;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2010-06-29 06:48:03 -07:00
|
|
|
if (edf->free_strings)
|
2009-08-11 03:06:37 -07:00
|
|
|
{
|
2010-06-29 06:48:03 -07:00
|
|
|
for (i = 0; i < edf->image_dir->entries_count; ++i)
|
|
|
|
eina_stringshare_del(edf->image_dir->entries[i].entry);
|
2003-07-07 00:55:18 -07:00
|
|
|
}
|
2010-06-29 06:48:03 -07:00
|
|
|
|
|
|
|
/* Sets have been added after edje received eet dictionnary support */
|
|
|
|
for (i = 0; i < edf->image_dir->sets_count; ++i)
|
|
|
|
{
|
|
|
|
Edje_Image_Directory_Set_Entry *se;
|
|
|
|
|
|
|
|
EINA_LIST_FREE(edf->image_dir->sets[i].entries, se)
|
|
|
|
free(se);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
free(edf->image_dir->entries);
|
|
|
|
free(edf->image_dir->sets);
|
2003-07-07 00:55:18 -07:00
|
|
|
free(edf->image_dir);
|
|
|
|
}
|
2006-01-10 19:19:46 -08:00
|
|
|
|
2010-08-12 08:05:56 -07:00
|
|
|
if (edf->external_dir)
|
|
|
|
{
|
|
|
|
if (edf->external_dir->entries) free(edf->external_dir->entries);
|
|
|
|
free(edf->external_dir);
|
|
|
|
}
|
|
|
|
|
2009-08-11 03:06:37 -07:00
|
|
|
EINA_LIST_FREE(edf->color_classes, ecc)
|
2006-01-10 19:19:46 -08:00
|
|
|
{
|
2008-10-15 07:11:11 -07:00
|
|
|
if (edf->free_strings && ecc->name) eina_stringshare_del(ecc->name);
|
2006-01-10 19:19:46 -08:00
|
|
|
free(ecc);
|
|
|
|
}
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2010-06-28 10:18:47 -07:00
|
|
|
if (edf->collection_patterns) edje_match_patterns_free(edf->collection_patterns);
|
2008-10-15 07:11:11 -07:00
|
|
|
if (edf->path) eina_stringshare_del(edf->path);
|
|
|
|
if (edf->free_strings && edf->compiler) eina_stringshare_del(edf->compiler);
|
2005-10-05 01:38:04 -07:00
|
|
|
_edje_textblock_style_cleanup(edf);
|
2008-02-29 22:38:09 -08:00
|
|
|
if (edf->ef) eet_close(edf->ef);
|
2003-07-07 00:55:18 -07:00
|
|
|
free(edf);
|
2003-06-23 19:33:04 -07:00
|
|
|
}
|
|
|
|
|
2010-08-04 07:25:40 -07:00
|
|
|
static void
|
|
|
|
_edje_program_free(Edje_Program *pr, Eina_Bool free_strings)
|
|
|
|
{
|
|
|
|
Edje_Program_Target *prt;
|
|
|
|
Edje_Program_After *pa;
|
|
|
|
|
|
|
|
if (free_strings)
|
|
|
|
{
|
|
|
|
if (pr->name) eina_stringshare_del(pr->name);
|
|
|
|
if (pr->signal) eina_stringshare_del(pr->signal);
|
|
|
|
if (pr->source) eina_stringshare_del(pr->source);
|
|
|
|
if (pr->filter.part) eina_stringshare_del(pr->filter.part);
|
|
|
|
if (pr->filter.state) eina_stringshare_del(pr->filter.state);
|
|
|
|
if (pr->state) eina_stringshare_del(pr->state);
|
|
|
|
if (pr->state2) eina_stringshare_del(pr->state2);
|
|
|
|
}
|
|
|
|
EINA_LIST_FREE(pr->targets, prt)
|
|
|
|
free(prt);
|
|
|
|
EINA_LIST_FREE(pr->after, pa)
|
|
|
|
free(pa);
|
|
|
|
free(pr);
|
|
|
|
}
|
|
|
|
|
2005-04-03 04:43:00 -07:00
|
|
|
void
|
2010-07-29 05:02:36 -07:00
|
|
|
_edje_collection_free(Edje_File *edf, Edje_Part_Collection *ec, Edje_Part_Collection_Directory_Entry *ce)
|
2003-06-23 19:33:04 -07:00
|
|
|
{
|
2010-07-29 05:02:36 -07:00
|
|
|
unsigned int i;
|
2009-08-11 03:06:37 -07:00
|
|
|
|
2010-06-03 23:45:46 -07:00
|
|
|
_edje_embryo_script_shutdown(ec);
|
2010-08-04 07:25:40 -07:00
|
|
|
|
|
|
|
#define EDJE_LOAD_PROGRAM_FREE(Array, Ec, It, FreeStrings) \
|
|
|
|
for (It = 0; It < Ec->programs.Array##_count; ++It) \
|
|
|
|
_edje_program_free(Ec->programs.Array[It], FreeStrings); \
|
|
|
|
free(Ec->programs.Array);
|
|
|
|
|
|
|
|
EDJE_LOAD_PROGRAM_FREE(fnmatch, ec, i, edf->free_strings);
|
|
|
|
EDJE_LOAD_PROGRAM_FREE(strcmp, ec, i, edf->free_strings);
|
|
|
|
EDJE_LOAD_PROGRAM_FREE(strncmp, ec, i, edf->free_strings);
|
|
|
|
EDJE_LOAD_PROGRAM_FREE(strrncmp, ec, i, edf->free_strings);
|
|
|
|
EDJE_LOAD_PROGRAM_FREE(nocmp, ec, i, edf->free_strings);
|
|
|
|
|
2010-07-29 05:02:36 -07:00
|
|
|
for (i = 0; i < ec->parts_count; ++i)
|
2003-07-19 19:08:47 -07:00
|
|
|
{
|
2010-07-29 05:02:36 -07:00
|
|
|
Edje_Part *ep;
|
|
|
|
unsigned int j;
|
|
|
|
|
|
|
|
ep = ec->parts[i];
|
2003-11-24 23:22:19 -08:00
|
|
|
|
2008-10-15 07:11:11 -07:00
|
|
|
if (edf->free_strings && ep->name) eina_stringshare_del(ep->name);
|
2003-11-24 23:22:19 -08:00
|
|
|
if (ep->default_desc)
|
|
|
|
{
|
2010-07-29 05:02:36 -07:00
|
|
|
_edje_collection_free_part_description_clean(ep->type, ep->default_desc, edf->free_strings);
|
2003-11-24 23:22:19 -08:00
|
|
|
ep->default_desc = NULL;
|
|
|
|
}
|
2010-08-09 10:34:03 -07:00
|
|
|
for (j = 0; j < ep->other.desc_count; ++j)
|
|
|
|
_edje_collection_free_part_description_clean(ep->type, ep->other.desc[j], edf->free_strings);
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2010-08-09 10:34:03 -07:00
|
|
|
free(ep->other.desc);
|
2010-07-29 05:02:36 -07:00
|
|
|
free(ep->items);
|
2004-06-30 20:46:05 -07:00
|
|
|
}
|
2010-08-12 05:58:54 -07:00
|
|
|
free(ec->parts);
|
|
|
|
ec->parts = NULL;
|
|
|
|
|
2010-08-12 08:05:56 -07:00
|
|
|
if (ec->data)
|
|
|
|
{
|
|
|
|
Eina_Iterator *it;
|
|
|
|
Edje_String *es;
|
|
|
|
|
|
|
|
it = eina_hash_iterator_data_new(ec->data);
|
|
|
|
EINA_ITERATOR_FOREACH(it, es)
|
|
|
|
free(es);
|
|
|
|
eina_iterator_free(it);
|
|
|
|
|
|
|
|
eina_hash_free(ec->data);
|
|
|
|
}
|
2004-03-26 01:10:05 -08:00
|
|
|
#ifdef EDJE_PROGRAM_CACHE
|
2008-12-15 13:00:19 -08:00
|
|
|
if (ec->prog_cache.no_matches) eina_hash_free(ec->prog_cache.no_matches);
|
2003-07-19 19:08:47 -07:00
|
|
|
if (ec->prog_cache.matches)
|
|
|
|
{
|
2008-12-15 13:00:19 -08:00
|
|
|
eina_hash_foreach(ec->prog_cache.matches,
|
2007-09-08 11:31:56 -07:00
|
|
|
_edje_collection_free_prog_cache_matches_free_cb,
|
2003-07-29 19:58:22 -07:00
|
|
|
NULL);
|
2008-12-15 13:00:19 -08:00
|
|
|
eina_hash_free(ec->prog_cache.matches);
|
2003-07-19 19:08:47 -07:00
|
|
|
}
|
2007-09-08 11:31:56 -07:00
|
|
|
#endif
|
2005-04-27 01:11:58 -07:00
|
|
|
if (ec->script) embryo_program_free(ec->script);
|
2010-07-29 05:02:36 -07:00
|
|
|
#ifdef LUA2
|
2010-04-06 04:26:32 -07:00
|
|
|
_edje_lua2_script_unload(ec);
|
2010-04-06 04:32:09 -07:00
|
|
|
#endif
|
2010-07-29 05:02:36 -07:00
|
|
|
|
|
|
|
/* Destroy all part and description. */
|
|
|
|
eina_mempool_del(ce->mp.RECTANGLE);
|
|
|
|
eina_mempool_del(ce->mp.TEXT);
|
|
|
|
eina_mempool_del(ce->mp.IMAGE);
|
|
|
|
eina_mempool_del(ce->mp.SWALLOW);
|
|
|
|
eina_mempool_del(ce->mp.TEXTBLOCK);
|
|
|
|
eina_mempool_del(ce->mp.GROUP);
|
|
|
|
eina_mempool_del(ce->mp.BOX);
|
|
|
|
eina_mempool_del(ce->mp.TABLE);
|
|
|
|
eina_mempool_del(ce->mp.EXTERNAL);
|
|
|
|
eina_mempool_del(ce->mp.part);
|
|
|
|
memset(&ce->mp, 0, sizeof (ce->mp));
|
|
|
|
|
2003-07-19 19:08:47 -07:00
|
|
|
free(ec);
|
2010-07-29 05:02:36 -07:00
|
|
|
ce->ref = NULL;
|
2003-07-19 19:08:47 -07:00
|
|
|
}
|
|
|
|
|
2008-03-06 09:52:59 -08:00
|
|
|
void
|
2010-07-29 05:02:36 -07:00
|
|
|
_edje_collection_free_part_description_clean(int type, Edje_Part_Description_Common *desc, Eina_Bool free_strings)
|
2003-07-19 19:08:47 -07:00
|
|
|
{
|
2010-07-29 05:02:36 -07:00
|
|
|
if (free_strings && desc->color_class) eina_stringshare_del(desc->color_class);
|
|
|
|
|
|
|
|
switch (type)
|
|
|
|
{
|
|
|
|
case EDJE_PART_TYPE_IMAGE:
|
|
|
|
{
|
|
|
|
Edje_Part_Description_Image *img;
|
2010-08-03 05:58:31 -07:00
|
|
|
unsigned int i;
|
2010-07-29 05:02:36 -07:00
|
|
|
|
|
|
|
img = (Edje_Part_Description_Image *) desc;
|
|
|
|
|
2010-08-03 05:58:31 -07:00
|
|
|
for (i = 0; i < img->image.tweens_count; ++i)
|
|
|
|
free(img->image.tweens[i]);
|
2010-08-13 21:03:33 -07:00
|
|
|
// cedric: this array is part of the img struct - no? not separately alloced
|
|
|
|
// anymore - right? thus shouldnt be free()'d... no?
|
|
|
|
// free(img->image.tweens);
|
2010-08-03 05:58:31 -07:00
|
|
|
break;
|
2010-07-29 05:02:36 -07:00
|
|
|
}
|
|
|
|
case EDJE_PART_TYPE_EXTERNAL:
|
|
|
|
{
|
|
|
|
Edje_Part_Description_External *external;
|
|
|
|
|
|
|
|
external = (Edje_Part_Description_External *) desc;
|
|
|
|
|
|
|
|
if (external->external_params)
|
|
|
|
_edje_external_params_free(external->external_params, free_strings);
|
2010-08-03 05:58:31 -07:00
|
|
|
break;
|
2010-07-29 05:02:36 -07:00
|
|
|
}
|
|
|
|
case EDJE_PART_TYPE_TEXT:
|
|
|
|
case EDJE_PART_TYPE_TEXTBLOCK:
|
|
|
|
if (free_strings)
|
|
|
|
{
|
|
|
|
Edje_Part_Description_Text *text;
|
|
|
|
|
|
|
|
text = (Edje_Part_Description_Text *) desc;
|
|
|
|
|
2010-08-12 05:58:54 -07:00
|
|
|
if (text->text.text.str) eina_stringshare_del(text->text.text.str);
|
2010-07-29 05:02:36 -07:00
|
|
|
if (text->text.text_class) eina_stringshare_del(text->text.text_class);
|
2010-08-12 05:58:54 -07:00
|
|
|
if (text->text.style.str) eina_stringshare_del(text->text.style.str);
|
|
|
|
if (text->text.font.str) eina_stringshare_del(text->text.font.str);
|
2010-07-29 05:02:36 -07:00
|
|
|
}
|
2010-08-03 05:58:31 -07:00
|
|
|
break;
|
2010-07-29 05:02:36 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
_edje_collection_free_part_description_free(int type,
|
|
|
|
Edje_Part_Description_Common *desc,
|
|
|
|
Edje_Part_Collection_Directory_Entry *ce,
|
|
|
|
Eina_Bool free_strings)
|
|
|
|
{
|
|
|
|
#define FREE_POOL(Type, Ce, Desc) \
|
2010-08-06 12:16:43 -07:00
|
|
|
case EDJE_PART_TYPE_##Type: eina_mempool_free(Ce->mp.Type, Desc); \
|
|
|
|
ce->count.Type--; \
|
|
|
|
break;
|
2010-07-29 05:02:36 -07:00
|
|
|
|
|
|
|
_edje_collection_free_part_description_clean(type, desc, free_strings);
|
|
|
|
|
|
|
|
switch (type)
|
2008-02-29 22:38:09 -08:00
|
|
|
{
|
2010-07-29 05:02:36 -07:00
|
|
|
FREE_POOL(RECTANGLE, ce, desc);
|
|
|
|
FREE_POOL(TEXT, ce, desc);
|
|
|
|
FREE_POOL(IMAGE, ce, desc);
|
|
|
|
FREE_POOL(SWALLOW, ce, desc);
|
|
|
|
FREE_POOL(TEXTBLOCK, ce, desc);
|
|
|
|
FREE_POOL(GROUP, ce, desc);
|
|
|
|
FREE_POOL(BOX, ce, desc);
|
|
|
|
FREE_POOL(TABLE, ce, desc);
|
|
|
|
FREE_POOL(EXTERNAL, ce, desc);
|
2008-02-29 22:38:09 -08:00
|
|
|
}
|
2003-07-19 19:08:47 -07:00
|
|
|
}
|
|
|
|
|
2004-03-26 01:10:05 -08:00
|
|
|
#ifdef EDJE_PROGRAM_CACHE
|
2008-12-05 19:08:17 -08:00
|
|
|
static Eina_Bool
|
|
|
|
_edje_collection_free_prog_cache_matches_free_cb(const Eina_Hash *hash, const void *key, void *data, void *fdata)
|
2003-07-19 19:08:47 -07:00
|
|
|
{
|
2008-10-22 04:34:42 -07:00
|
|
|
eina_list_free((Eina_List *)data);
|
2010-06-05 06:07:08 -07:00
|
|
|
return EINA_TRUE;
|
2008-12-05 19:08:17 -08:00
|
|
|
key = NULL;
|
2003-10-18 19:11:06 -07:00
|
|
|
hash = NULL;
|
|
|
|
fdata = NULL;
|
2003-06-23 19:33:04 -07:00
|
|
|
}
|
2004-03-26 01:10:05 -08:00
|
|
|
#endif
|
2007-05-26 22:28:07 -07:00
|
|
|
|
2008-11-23 21:15:15 -08:00
|
|
|
static void
|
|
|
|
_edje_object_pack_item_hints_set(Evas_Object *obj, Edje_Pack_Element *it)
|
|
|
|
{
|
|
|
|
Evas_Coord w = 0, h = 0, minw, minh;
|
|
|
|
|
|
|
|
minw = it->min.w;
|
|
|
|
minh = it->min.h;
|
|
|
|
|
|
|
|
if ((minw <= 0) && (minh <= 0))
|
|
|
|
{
|
|
|
|
edje_object_size_min_get(obj, &w, &h);
|
|
|
|
if ((w <= 0) && (h <= 0))
|
|
|
|
edje_object_size_min_calc(obj, &w, &h);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
w = minw;
|
|
|
|
h = minh;
|
|
|
|
}
|
|
|
|
if (((minw <= 0) && (minh <= 0)) && ((w > 0) || (h > 0)))
|
|
|
|
evas_object_size_hint_min_set(obj, w, h);
|
|
|
|
else
|
|
|
|
evas_object_size_hint_min_set(obj, minw, minh);
|
|
|
|
|
|
|
|
evas_object_size_hint_request_set(obj, it->prefer.w, it->prefer.h);
|
|
|
|
evas_object_size_hint_max_set(obj, it->max.w, it->max.h);
|
|
|
|
evas_object_size_hint_padding_set(obj, it->padding.l, it->padding.r, it->padding.t, it->padding.b);
|
|
|
|
evas_object_size_hint_align_set(obj, it->align.x, it->align.y);
|
|
|
|
evas_object_size_hint_weight_set(obj, it->weight.x, it->weight.y);
|
|
|
|
evas_object_size_hint_aspect_set(obj, it->aspect.mode, it->aspect.w, it->aspect.h);
|
|
|
|
|
|
|
|
evas_object_resize(obj, w, h);
|
|
|
|
}
|
|
|
|
|
2007-05-26 22:28:07 -07:00
|
|
|
static void
|
|
|
|
_cb_signal_repeat(void *data, Evas_Object *obj, const char *signal, const char *source)
|
|
|
|
{
|
2008-04-10 01:58:19 -07:00
|
|
|
Evas_Object *parent;
|
|
|
|
Edje *ed;
|
|
|
|
char new_src[4096]; /* XXX is this max reasonable? */
|
2009-10-25 05:17:05 -07:00
|
|
|
size_t length_parent = 0;
|
|
|
|
size_t length_source;
|
2007-05-26 22:28:07 -07:00
|
|
|
|
|
|
|
parent = data;
|
|
|
|
ed = _edje_fetch(obj);
|
|
|
|
if (!ed) return;
|
2008-04-10 01:58:19 -07:00
|
|
|
/* Replace snprint("%s%c%s") == memcpy + *new_src + memcat */
|
2008-08-01 18:33:39 -07:00
|
|
|
if (ed->parent)
|
|
|
|
length_parent = strlen(ed->parent);
|
2008-04-10 01:58:19 -07:00
|
|
|
length_source = strlen(source);
|
|
|
|
if (length_source + length_parent + 2 > sizeof(new_src))
|
2008-11-14 09:35:05 -08:00
|
|
|
return;
|
2008-04-10 01:58:19 -07:00
|
|
|
|
2008-08-01 18:33:39 -07:00
|
|
|
if (ed->parent)
|
|
|
|
memcpy(new_src, ed->parent, length_parent);
|
2008-04-10 01:58:19 -07:00
|
|
|
new_src[length_parent] = EDJE_PART_PATH_SEPARATOR;
|
|
|
|
memcpy(new_src + length_parent + 1, source, length_source + 1);
|
|
|
|
|
2007-05-26 22:28:07 -07:00
|
|
|
edje_object_signal_emit(parent, signal, new_src);
|
|
|
|
}
|