2005-10-05 01:38:04 -07:00
|
|
|
#include "edje_private.h"
|
|
|
|
|
2015-06-08 11:43:00 -07:00
|
|
|
Eina_Hash *_edje_file_hash = NULL;
|
2018-02-26 15:54:38 -08:00
|
|
|
Eina_Hash *_edje_id_hash = NULL;
|
2015-03-31 14:23:32 -07:00
|
|
|
|
2018-02-26 15:54:38 -08:00
|
|
|
static Eina_Hash *_edje_requires_pending;
|
2015-06-08 11:43:00 -07:00
|
|
|
static int _edje_file_cache_size = 16;
|
|
|
|
static Eina_List *_edje_file_cache = NULL;
|
2005-10-05 01:38:04 -07:00
|
|
|
|
2015-06-08 11:43:00 -07:00
|
|
|
static int _edje_collection_cache_size = 16;
|
2005-10-05 01:38:04 -07:00
|
|
|
|
2012-12-05 23:54:54 -08:00
|
|
|
EAPI void
|
|
|
|
edje_cache_emp_alloc(Edje_Part_Collection_Directory_Entry *ce)
|
2016-08-20 19:14:28 -07:00
|
|
|
{
|
|
|
|
/* Init Eina Mempools this is also used in edje_pick.c */
|
|
|
|
char *buffer;
|
|
|
|
ce->mp = calloc(1, sizeof(Edje_Part_Collection_Directory_Entry_Mp));
|
|
|
|
if (!ce->mp) return;
|
2015-06-08 11:43:00 -07:00
|
|
|
|
2016-08-20 19:14:28 -07:00
|
|
|
#define INIT_EMP(Tp, Sz, Ce) \
|
|
|
|
buffer = alloca(strlen(ce->entry) + strlen(#Tp) + 2); \
|
|
|
|
sprintf(buffer, "%s/%s", ce->entry, #Tp); \
|
|
|
|
Ce->mp->mp.Tp = eina_mempool_add("one_big", buffer, NULL, sizeof (Sz), Ce->count.Tp); \
|
|
|
|
_emp_##Tp = Ce->mp->mp.Tp;
|
|
|
|
|
|
|
|
#define INIT_EMP_BOTH(Tp, Sz, Ce) \
|
|
|
|
INIT_EMP(Tp, Sz, Ce) \
|
|
|
|
Ce->mp->mp_rtl.Tp = eina_mempool_add("one_big", buffer, NULL, \
|
|
|
|
sizeof(Sz), Ce->count.Tp);
|
2015-06-08 11:43:00 -07:00
|
|
|
|
|
|
|
INIT_EMP_BOTH(RECTANGLE, Edje_Part_Description_Common, ce);
|
|
|
|
INIT_EMP_BOTH(TEXT, Edje_Part_Description_Text, ce);
|
|
|
|
INIT_EMP_BOTH(IMAGE, Edje_Part_Description_Image, ce);
|
|
|
|
INIT_EMP_BOTH(PROXY, Edje_Part_Description_Proxy, ce);
|
|
|
|
INIT_EMP_BOTH(SWALLOW, Edje_Part_Description_Common, ce);
|
|
|
|
INIT_EMP_BOTH(TEXTBLOCK, Edje_Part_Description_Text, ce);
|
|
|
|
INIT_EMP_BOTH(GROUP, Edje_Part_Description_Common, ce);
|
|
|
|
INIT_EMP_BOTH(BOX, Edje_Part_Description_Box, ce);
|
|
|
|
INIT_EMP_BOTH(TABLE, Edje_Part_Description_Table, ce);
|
|
|
|
INIT_EMP_BOTH(EXTERNAL, Edje_Part_Description_External, ce);
|
|
|
|
INIT_EMP_BOTH(SPACER, Edje_Part_Description_Common, ce);
|
2015-09-07 01:22:07 -07:00
|
|
|
INIT_EMP_BOTH(SNAPSHOT, Edje_Part_Description_Snapshot, ce);
|
2016-02-04 23:19:40 -08:00
|
|
|
INIT_EMP_BOTH(MESH_NODE, Edje_Part_Description_Mesh_Node, ce);
|
|
|
|
INIT_EMP_BOTH(LIGHT, Edje_Part_Description_Light, ce);
|
|
|
|
INIT_EMP_BOTH(CAMERA, Edje_Part_Description_Camera, ce);
|
2016-06-08 11:26:07 -07:00
|
|
|
INIT_EMP_BOTH(VECTOR, Edje_Part_Description_Vector, ce);
|
2015-06-08 11:43:00 -07:00
|
|
|
INIT_EMP(part, Edje_Part, ce);
|
2012-12-05 23:54:54 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
edje_cache_emp_free(Edje_Part_Collection_Directory_Entry *ce)
|
|
|
|
{ /* Free Eina Mempools this is also used in edje_pick.c */
|
|
|
|
/* Destroy all part and description. */
|
2016-08-20 19:14:28 -07:00
|
|
|
ce->ref = NULL;
|
|
|
|
|
|
|
|
if (!ce->mp) return;
|
|
|
|
eina_mempool_del(ce->mp->mp.RECTANGLE);
|
|
|
|
eina_mempool_del(ce->mp->mp.TEXT);
|
|
|
|
eina_mempool_del(ce->mp->mp.IMAGE);
|
|
|
|
eina_mempool_del(ce->mp->mp.PROXY);
|
|
|
|
eina_mempool_del(ce->mp->mp.SWALLOW);
|
|
|
|
eina_mempool_del(ce->mp->mp.TEXTBLOCK);
|
|
|
|
eina_mempool_del(ce->mp->mp.GROUP);
|
|
|
|
eina_mempool_del(ce->mp->mp.BOX);
|
|
|
|
eina_mempool_del(ce->mp->mp.TABLE);
|
|
|
|
eina_mempool_del(ce->mp->mp.EXTERNAL);
|
|
|
|
eina_mempool_del(ce->mp->mp.SPACER);
|
|
|
|
eina_mempool_del(ce->mp->mp.SNAPSHOT);
|
|
|
|
eina_mempool_del(ce->mp->mp.MESH_NODE);
|
|
|
|
eina_mempool_del(ce->mp->mp.LIGHT);
|
|
|
|
eina_mempool_del(ce->mp->mp.CAMERA);
|
|
|
|
eina_mempool_del(ce->mp->mp.VECTOR);
|
|
|
|
eina_mempool_del(ce->mp->mp.part);
|
|
|
|
memset(&ce->mp->mp, 0, sizeof(ce->mp->mp));
|
2015-06-08 11:43:00 -07:00
|
|
|
|
2016-08-20 19:14:28 -07:00
|
|
|
eina_mempool_del(ce->mp->mp_rtl.RECTANGLE);
|
|
|
|
eina_mempool_del(ce->mp->mp_rtl.TEXT);
|
|
|
|
eina_mempool_del(ce->mp->mp_rtl.IMAGE);
|
|
|
|
eina_mempool_del(ce->mp->mp_rtl.PROXY);
|
|
|
|
eina_mempool_del(ce->mp->mp_rtl.SWALLOW);
|
|
|
|
eina_mempool_del(ce->mp->mp_rtl.TEXTBLOCK);
|
|
|
|
eina_mempool_del(ce->mp->mp_rtl.GROUP);
|
|
|
|
eina_mempool_del(ce->mp->mp_rtl.BOX);
|
|
|
|
eina_mempool_del(ce->mp->mp_rtl.TABLE);
|
|
|
|
eina_mempool_del(ce->mp->mp_rtl.EXTERNAL);
|
|
|
|
eina_mempool_del(ce->mp->mp_rtl.SPACER);
|
|
|
|
eina_mempool_del(ce->mp->mp_rtl.SNAPSHOT);
|
|
|
|
eina_mempool_del(ce->mp->mp_rtl.MESH_NODE);
|
|
|
|
eina_mempool_del(ce->mp->mp_rtl.LIGHT);
|
|
|
|
eina_mempool_del(ce->mp->mp_rtl.CAMERA);
|
2016-08-20 19:30:45 -07:00
|
|
|
eina_mempool_del(ce->mp->mp_rtl.VECTOR);
|
2016-08-20 19:14:28 -07:00
|
|
|
memset(&ce->mp->mp_rtl, 0, sizeof(ce->mp->mp_rtl));
|
2016-10-11 23:07:25 -07:00
|
|
|
|
|
|
|
free(ce->mp);
|
2012-12-05 23:54:54 -08:00
|
|
|
}
|
|
|
|
|
2013-02-13 19:36:13 -08:00
|
|
|
void
|
|
|
|
_edje_programs_patterns_init(Edje_Part_Collection *edc)
|
|
|
|
{
|
|
|
|
Edje_Signals_Sources_Patterns *ssp = &edc->patterns.programs;
|
|
|
|
Edje_Program **all;
|
|
|
|
unsigned int i, j;
|
|
|
|
|
|
|
|
if (ssp->signals_patterns)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (getenv("EDJE_DUMP_PROGRAMS"))
|
|
|
|
{
|
2015-06-08 11:43:00 -07:00
|
|
|
INF("Group '%s' programs:", edc->part);
|
|
|
|
#define EDJE_DUMP_PROGRAM(Section) \
|
|
|
|
for (i = 0; i < edc->programs.Section##_count; i++) \
|
|
|
|
INF(#Section " for ('%s', '%s')", edc->programs.Section[i]->signal, edc->programs.Section[i]->source);
|
|
|
|
|
|
|
|
EDJE_DUMP_PROGRAM(strcmp);
|
|
|
|
EDJE_DUMP_PROGRAM(strncmp);
|
|
|
|
EDJE_DUMP_PROGRAM(strrncmp);
|
|
|
|
EDJE_DUMP_PROGRAM(fnmatch);
|
|
|
|
EDJE_DUMP_PROGRAM(nocmp);
|
2013-02-13 19:36:13 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
edje_match_program_hash_build(edc->programs.strcmp,
|
2015-06-08 11:43:00 -07:00
|
|
|
edc->programs.strcmp_count,
|
|
|
|
&ssp->exact_match);
|
2013-02-13 19:36:13 -08:00
|
|
|
|
|
|
|
j = edc->programs.strncmp_count
|
|
|
|
+ edc->programs.strrncmp_count
|
|
|
|
+ edc->programs.fnmatch_count
|
|
|
|
+ edc->programs.nocmp_count;
|
2013-06-20 04:28:18 -07:00
|
|
|
if (j == 0) return;
|
2013-02-13 19:36:13 -08:00
|
|
|
|
|
|
|
all = malloc(sizeof (Edje_Program *) * j);
|
2013-06-20 04:28:18 -07:00
|
|
|
if (!all) return;
|
2013-02-13 19:36:13 -08:00
|
|
|
j = 0;
|
|
|
|
|
|
|
|
/* FIXME: Build specialized data type for each case */
|
2015-06-08 11:43:00 -07:00
|
|
|
#define EDJE_LOAD_PROGRAMS_ADD(Array, Edc, It, Git, All) \
|
|
|
|
for (It = 0; It < Edc->programs.Array##_count; ++It, ++Git) \
|
|
|
|
All[Git] = Edc->programs.Array[It];
|
2013-02-13 19:36:13 -08:00
|
|
|
|
|
|
|
EDJE_LOAD_PROGRAMS_ADD(fnmatch, edc, i, j, all);
|
|
|
|
EDJE_LOAD_PROGRAMS_ADD(strncmp, edc, i, j, all);
|
|
|
|
EDJE_LOAD_PROGRAMS_ADD(strrncmp, edc, i, j, all);
|
|
|
|
/* FIXME: Do a special pass for that one */
|
|
|
|
EDJE_LOAD_PROGRAMS_ADD(nocmp, edc, 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);
|
|
|
|
}
|
|
|
|
|
2005-10-05 01:38:04 -07:00
|
|
|
static Edje_Part_Collection *
|
2008-02-29 22:38:09 -08:00
|
|
|
_edje_file_coll_open(Edje_File *edf, const char *coll)
|
2005-10-05 01:38:04 -07:00
|
|
|
{
|
|
|
|
Edje_Part_Collection *edc = NULL;
|
2008-10-22 04:34:42 -07:00
|
|
|
Edje_Part_Collection_Directory_Entry *ce;
|
2008-02-29 22:38:09 -08:00
|
|
|
int id = -1, size = 0;
|
2013-02-13 19:36:13 -08:00
|
|
|
unsigned int n;
|
2010-06-28 06:56:30 -07:00
|
|
|
Eina_List *l;
|
2005-10-05 01:38:04 -07:00
|
|
|
char buf[256];
|
|
|
|
void *data;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2010-06-28 06:56:30 -07:00
|
|
|
ce = eina_hash_find(edf->collection, coll);
|
|
|
|
if (!ce) return NULL;
|
|
|
|
|
|
|
|
if (ce->ref)
|
2005-10-05 01:38:04 -07:00
|
|
|
{
|
2015-06-08 11:43:00 -07:00
|
|
|
ce->ref->references++;
|
|
|
|
return ce->ref;
|
2010-06-28 06:56:30 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH(edf->collection_cache, l, edc)
|
|
|
|
{
|
2015-06-08 11:43:00 -07:00
|
|
|
if (!strcmp(edc->part, coll))
|
|
|
|
{
|
|
|
|
edc->references = 1;
|
|
|
|
ce->ref = edc;
|
|
|
|
|
|
|
|
edf->collection_cache = eina_list_remove_list(edf->collection_cache, l);
|
|
|
|
return ce->ref;
|
|
|
|
}
|
2005-10-05 01:38:04 -07:00
|
|
|
}
|
2010-06-28 06:56:30 -07:00
|
|
|
|
|
|
|
id = ce->id;
|
2005-10-05 01:38:04 -07:00
|
|
|
if (id < 0) return NULL;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2012-12-05 23:54:54 -08:00
|
|
|
edje_cache_emp_alloc(ce);
|
2010-08-09 10:34:03 -07:00
|
|
|
snprintf(buf, sizeof(buf), "edje/collections/%i", id);
|
|
|
|
edc = eet_data_read(edf->ef, _edje_edd_edje_part_collection, buf);
|
|
|
|
if (!edc) return NULL;
|
2010-07-29 05:02:36 -07:00
|
|
|
|
|
|
|
edc->references = 1;
|
2010-08-09 14:08:08 -07:00
|
|
|
edc->part = ce->entry;
|
2010-07-29 05:02:36 -07:00
|
|
|
|
2012-02-14 06:07:39 -08:00
|
|
|
/* For Edje file build with Edje 1.0 */
|
2011-04-07 05:34:18 -07:00
|
|
|
if (edf->version <= 3 && edf->minor <= 1)
|
|
|
|
{
|
|
|
|
/* This will preserve previous rendering */
|
|
|
|
unsigned int i;
|
|
|
|
|
2015-06-08 11:43:00 -07:00
|
|
|
/* people expect signal to not be broadcasted */
|
|
|
|
edc->broadcast_signal = EINA_FALSE;
|
2012-02-14 06:07:39 -08:00
|
|
|
|
2015-06-08 11:43:00 -07:00
|
|
|
/* people expect text.align to be 0.0 0.0 */
|
2011-04-07 05:34:18 -07:00
|
|
|
for (i = 0; i < edc->parts_count; ++i)
|
|
|
|
{
|
|
|
|
if (edc->parts[i]->type == EDJE_PART_TYPE_TEXTBLOCK)
|
|
|
|
{
|
|
|
|
Edje_Part_Description_Text *text;
|
|
|
|
unsigned int j;
|
|
|
|
|
2015-06-08 11:43:00 -07:00
|
|
|
text = (Edje_Part_Description_Text *)edc->parts[i]->default_desc;
|
2011-04-07 05:34:18 -07:00
|
|
|
text->text.align.x = TO_DOUBLE(0.0);
|
|
|
|
text->text.align.y = TO_DOUBLE(0.0);
|
|
|
|
|
|
|
|
for (j = 0; j < edc->parts[i]->other.desc_count; ++j)
|
|
|
|
{
|
2015-06-08 11:43:00 -07:00
|
|
|
text = (Edje_Part_Description_Text *)edc->parts[i]->other.desc[j];
|
2011-04-07 05:34:18 -07:00
|
|
|
text->text.align.x = TO_DOUBLE(0.0);
|
|
|
|
text->text.align.y = TO_DOUBLE(0.0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-09 10:34:03 -07:00
|
|
|
snprintf(buf, sizeof(buf), "edje/scripts/embryo/compiled/%i", id);
|
2008-02-29 22:38:09 -08:00
|
|
|
data = eet_read(edf->ef, buf, &size);
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2005-10-05 01:38:04 -07:00
|
|
|
if (data)
|
|
|
|
{
|
2015-06-08 11:43:00 -07:00
|
|
|
edc->script = embryo_program_new(data, size);
|
|
|
|
_edje_embryo_script_init(edc);
|
|
|
|
free(data);
|
2005-10-05 01:38:04 -07:00
|
|
|
}
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2010-08-09 10:34:03 -07:00
|
|
|
snprintf(buf, sizeof(buf), "edje/scripts/lua/%i", id);
|
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
|
|
|
data = eet_read(edf->ef, buf, &size);
|
|
|
|
|
|
|
|
if (data)
|
|
|
|
{
|
2010-07-29 05:02:36 -07:00
|
|
|
_edje_lua2_script_load(edc, data, size);
|
2015-06-08 11:43:00 -07:00
|
|
|
free(data);
|
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
|
|
|
}
|
2005-10-05 01:38:04 -07:00
|
|
|
|
2010-08-09 14:08:08 -07:00
|
|
|
ce->ref = edc;
|
|
|
|
|
2013-02-13 19:36:13 -08:00
|
|
|
_edje_programs_patterns_init(edc);
|
|
|
|
|
|
|
|
n = edc->programs.fnmatch_count +
|
|
|
|
edc->programs.strcmp_count +
|
|
|
|
edc->programs.strncmp_count +
|
|
|
|
edc->programs.strrncmp_count +
|
|
|
|
edc->programs.nocmp_count;
|
|
|
|
|
|
|
|
if (n > 0)
|
|
|
|
{
|
2015-06-08 11:43:00 -07:00
|
|
|
Edje_Program *pr;
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
edc->patterns.table_programs = malloc(sizeof(Edje_Program *) * n);
|
|
|
|
if (edc->patterns.table_programs)
|
|
|
|
{
|
|
|
|
edc->patterns.table_programs_size = n;
|
|
|
|
|
|
|
|
#define EDJE_LOAD_BUILD_TABLE(Array, Edc, It, Tmp) \
|
|
|
|
for (It = 0; It < Edc->programs.Array##_count; ++It) \
|
|
|
|
{ \
|
|
|
|
Tmp = Edc->programs.Array[It]; \
|
|
|
|
Edc->patterns.table_programs[Tmp->id] = Tmp; \
|
|
|
|
}
|
|
|
|
|
|
|
|
EDJE_LOAD_BUILD_TABLE(fnmatch, edc, i, pr);
|
|
|
|
EDJE_LOAD_BUILD_TABLE(strcmp, edc, i, pr);
|
|
|
|
EDJE_LOAD_BUILD_TABLE(strncmp, edc, i, pr);
|
|
|
|
EDJE_LOAD_BUILD_TABLE(strrncmp, edc, i, pr);
|
|
|
|
EDJE_LOAD_BUILD_TABLE(nocmp, edc, i, pr);
|
|
|
|
}
|
2013-02-13 19:36:13 -08:00
|
|
|
}
|
|
|
|
|
2010-06-28 06:56:30 -07:00
|
|
|
return edc;
|
2007-04-04 06:25:55 -07:00
|
|
|
}
|
|
|
|
|
2017-02-02 21:39:57 -08:00
|
|
|
// XXX: this is not pretty. some oooooold edje files do not store strings
|
|
|
|
// in their dictionary for hashes. this works around crashes loading such
|
|
|
|
// files
|
|
|
|
extern size_t _edje_data_string_mapping_size;
|
|
|
|
extern void *_edje_data_string_mapping;
|
|
|
|
|
2005-10-05 01:38:04 -07:00
|
|
|
static Edje_File *
|
2016-02-03 15:23:34 -08:00
|
|
|
_edje_file_open(const Eina_File *f, int *error_ret, time_t mtime, Eina_Bool coll)
|
2005-10-05 01:38:04 -07:00
|
|
|
{
|
2016-02-04 22:55:46 -08:00
|
|
|
Edje_Color_Tree_Node *ctn;
|
2012-08-09 01:27:04 -07:00
|
|
|
Edje_Color_Class *cc;
|
2015-12-23 22:55:17 -08:00
|
|
|
Edje_Text_Class *tc;
|
2015-12-07 19:15:48 -08:00
|
|
|
Edje_Size_Class *sc;
|
2005-10-05 01:38:04 -07:00
|
|
|
Edje_File *edf;
|
2016-02-04 22:55:46 -08:00
|
|
|
Eina_List *l, *ll;
|
2005-10-05 01:38:04 -07:00
|
|
|
Eet_File *ef;
|
2016-02-04 22:55:46 -08:00
|
|
|
char *name;
|
2017-02-02 21:39:57 -08:00
|
|
|
void *mapping;
|
|
|
|
size_t mapping_size;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2013-05-08 17:37:55 -07:00
|
|
|
ef = eet_mmap(f);
|
2005-10-05 01:38:04 -07:00
|
|
|
if (!ef)
|
|
|
|
{
|
2015-06-08 11:43:00 -07:00
|
|
|
*error_ret = EDJE_LOAD_ERROR_UNKNOWN_FORMAT;
|
|
|
|
return NULL;
|
2005-10-05 01:38:04 -07:00
|
|
|
}
|
2017-02-02 21:39:57 -08:00
|
|
|
// XXX: ancient edje file workaround
|
|
|
|
mapping = eina_file_map_all((Eina_File *)f, EINA_FILE_SEQUENTIAL);
|
|
|
|
if (mapping)
|
|
|
|
{
|
|
|
|
mapping_size = eina_file_size_get(f);
|
|
|
|
_edje_data_string_mapping = mapping;
|
|
|
|
_edje_data_string_mapping_size = mapping_size;
|
|
|
|
}
|
2010-08-09 10:34:03 -07:00
|
|
|
edf = eet_data_read(ef, _edje_edd_edje_file, "edje/file");
|
2017-02-02 21:39:57 -08:00
|
|
|
// XXX: ancient edje file workaround
|
|
|
|
if (mapping)
|
|
|
|
{
|
|
|
|
eina_file_map_free((Eina_File *)f, mapping);
|
|
|
|
_edje_data_string_mapping = NULL;
|
|
|
|
}
|
2010-08-09 10:34:03 -07:00
|
|
|
if (!edf)
|
2005-10-05 01:38:04 -07:00
|
|
|
{
|
2015-06-08 11:43:00 -07:00
|
|
|
*error_ret = EDJE_LOAD_ERROR_CORRUPT_FILE;
|
|
|
|
eet_close(ef);
|
|
|
|
return NULL;
|
2005-10-05 01:38:04 -07:00
|
|
|
}
|
2008-02-29 22:38:09 -08:00
|
|
|
|
2013-08-11 16:42:55 -07:00
|
|
|
edf->f = eina_file_dup(f);
|
2008-02-29 22:38:09 -08:00
|
|
|
edf->ef = ef;
|
2012-01-05 06:31:27 -08:00
|
|
|
edf->mtime = mtime;
|
2008-02-29 22:38:09 -08:00
|
|
|
|
2005-10-05 01:38:04 -07:00
|
|
|
if (edf->version != EDJE_FILE_VERSION)
|
|
|
|
{
|
2015-06-08 11:43:00 -07:00
|
|
|
*error_ret = EDJE_LOAD_ERROR_INCOMPATIBLE_FILE;
|
|
|
|
_edje_file_free(edf);
|
|
|
|
return NULL;
|
2005-10-05 01:38:04 -07:00
|
|
|
}
|
2016-02-03 15:23:34 -08:00
|
|
|
if (!edf->collection && coll)
|
2005-10-05 01:38:04 -07:00
|
|
|
{
|
2015-06-08 11:43:00 -07:00
|
|
|
*error_ret = EDJE_LOAD_ERROR_CORRUPT_FILE;
|
|
|
|
_edje_file_free(edf);
|
|
|
|
return NULL;
|
2005-10-05 01:38:04 -07:00
|
|
|
}
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2010-08-25 02:56:20 -07:00
|
|
|
if (edf->minor > EDJE_FILE_MINOR)
|
|
|
|
{
|
2015-06-08 11:43:00 -07:00
|
|
|
WRN("`%s` may use feature from a newer edje and could not show up as expected.",
|
2013-05-08 17:37:55 -07:00
|
|
|
eina_file_filename_get(f));
|
2010-08-25 02:56:20 -07:00
|
|
|
}
|
edje: Add dpi feature.
Summary:
This dpi is used to get the scale for each collection.
If each collection has a described dpi, it calculates a proper scale
based on the dpi and dpi which is described in the collection.
@feature
Test Plan:
If add dpi to collection of edc, the edje will save the value as the dpi of the collection.
For example, if the dpi of your device is 100, you just set dpi: 100 in the collection of edc.
If the edj is loaded in another device(dpi is 200), it will scaled 2 times.
It is possible that the described dpi of application and theme are different.
In that case, application and theme have a different scale.
It makes the edj that made in different environment works in one device.
Reviewers: seoz, zmike, JackDanielZ, Hermet, woohyun, cedric, raster
Reviewed By: raster
Subscribers: cedric
Differential Revision: https://phab.enlightenment.org/D1190
2014-07-23 22:50:25 -07:00
|
|
|
if (edf->base_scale <= ZERO)
|
|
|
|
{
|
|
|
|
edf->base_scale = FROM_INT(1);
|
|
|
|
WRN("The base_scale can not be a 0.0. It is changed the default value(1.0)");
|
|
|
|
}
|
2010-08-25 02:56:20 -07:00
|
|
|
|
2017-06-14 14:24:04 -07:00
|
|
|
/* Set default efl_version if there is no version information */
|
|
|
|
if ((edf->efl_version.major == 0) && (edf->efl_version.minor == 0))
|
|
|
|
{
|
|
|
|
edf->efl_version.major = 1;
|
edje: support legacy Textblock calculation logic for 1.18 edje file
Summary:
From EFL 1.19, Edje Textblock calculation logic was fixed according to
Edje documents. But, it broke old edje files which ignored text.min
option for minimum width. Even if the old edje files were wrong,
we need to support them as discussed from T5548.
Also, this patch will change default efl_version to 1.18 from 1.19.
So, without efl_version property, edje file will run on the legacy logic.
Fixes T5548
Test Plan: Turn on/off presentation mode in Enlightenment.
Reviewers: herdsman, cedric, jpeg, zmike, raster
Subscribers: stefan_schmidt
Maniphest Tasks: T5548
Differential Revision: https://phab.enlightenment.org/D4967
Adjusted by @jpeg
2017-07-03 21:53:59 -07:00
|
|
|
edf->efl_version.minor = 18;
|
2017-06-14 14:24:04 -07:00
|
|
|
}
|
|
|
|
|
2013-05-08 17:37:55 -07:00
|
|
|
edf->path = eina_stringshare_add(eina_file_filename_get(f));
|
2005-10-05 01:38:04 -07:00
|
|
|
edf->references = 1;
|
|
|
|
|
2010-06-28 06:56:30 -07:00
|
|
|
/* This should be done at edje generation time */
|
2005-10-05 01:38:04 -07:00
|
|
|
_edje_textblock_style_parse_and_fix(edf);
|
2016-02-04 22:55:46 -08:00
|
|
|
|
|
|
|
edf->color_tree_hash = eina_hash_string_small_new(NULL);
|
|
|
|
EINA_LIST_FOREACH(edf->color_tree, l, ctn)
|
|
|
|
EINA_LIST_FOREACH(ctn->color_classes, ll, name)
|
|
|
|
eina_hash_add(edf->color_tree_hash, name, ctn);
|
|
|
|
|
2012-08-09 01:27:04 -07:00
|
|
|
edf->color_hash = eina_hash_string_small_new(NULL);
|
|
|
|
EINA_LIST_FOREACH(edf->color_classes, l, cc)
|
|
|
|
if (cc->name)
|
|
|
|
eina_hash_direct_add(edf->color_hash, cc->name, cc);
|
2007-03-06 04:03:34 -08:00
|
|
|
|
2015-12-23 22:55:17 -08:00
|
|
|
edf->text_hash = eina_hash_string_small_new(NULL);
|
|
|
|
EINA_LIST_FOREACH(edf->text_classes, l, tc)
|
|
|
|
if (tc->name)
|
|
|
|
eina_hash_direct_add(edf->text_hash, tc->name, tc);
|
|
|
|
|
2015-12-07 19:15:48 -08:00
|
|
|
edf->size_hash = eina_hash_string_small_new(NULL);
|
|
|
|
EINA_LIST_FOREACH(edf->size_classes, l, sc)
|
|
|
|
if (sc->name)
|
|
|
|
eina_hash_direct_add(edf->size_hash, sc->name, sc);
|
|
|
|
|
2018-02-26 15:54:38 -08:00
|
|
|
if (edf->requires_count)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
Edje_File *required_edf;
|
|
|
|
char **requires = (char**)edf->requires;
|
|
|
|
|
|
|
|
/* EET_DATA_DESCRIPTOR_ADD_VAR_ARRAY_STRING returns an mmapped blob, not stringshares */
|
|
|
|
edf->requires = malloc(edf->requires_count * sizeof(char*));
|
|
|
|
for (i = 0; i < edf->requires_count; i++)
|
|
|
|
{
|
|
|
|
char *str = (char*)requires[i];
|
|
|
|
|
|
|
|
edf->requires[i] = eina_stringshare_add(str);
|
|
|
|
required_edf = eina_hash_find(_edje_id_hash, edf->requires[i]);
|
|
|
|
if (required_edf)
|
|
|
|
{
|
|
|
|
required_edf->references++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
ERR("edje file '%s' REQUIRES file '%s' which is not loaded", edf->path, edf->requires[i]);
|
|
|
|
if (!_edje_requires_pending)
|
|
|
|
_edje_requires_pending = eina_hash_stringshared_new(NULL);
|
|
|
|
eina_hash_list_append(_edje_requires_pending, edf->requires[i], edf);
|
|
|
|
}
|
|
|
|
free(requires);
|
|
|
|
}
|
|
|
|
if (_edje_requires_pending && edf->id)
|
|
|
|
{
|
|
|
|
l = eina_hash_set(_edje_requires_pending, edf->id, NULL);
|
|
|
|
|
|
|
|
edf->references += eina_list_count(l);
|
|
|
|
eina_list_free(l);
|
|
|
|
|
|
|
|
if (!eina_hash_population(_edje_requires_pending))
|
|
|
|
{
|
|
|
|
eina_hash_free(_edje_requires_pending);
|
|
|
|
_edje_requires_pending = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-10-05 01:38:04 -07:00
|
|
|
return edf;
|
|
|
|
}
|
|
|
|
|
2013-05-08 17:37:55 -07:00
|
|
|
#if 0
|
|
|
|
// FIXME: find a way to remove dangling file earlier
|
2010-02-26 19:47:04 -08:00
|
|
|
static void
|
|
|
|
_edje_file_dangling(Edje_File *edf)
|
|
|
|
{
|
|
|
|
if (edf->dangling) return;
|
|
|
|
edf->dangling = EINA_TRUE;
|
|
|
|
|
2013-11-20 03:04:58 -08:00
|
|
|
eina_hash_del(_edje_file_hash, &edf->f, edf);
|
2010-02-26 19:47:04 -08:00
|
|
|
if (!eina_hash_population(_edje_file_hash))
|
|
|
|
{
|
2015-06-08 11:43:00 -07:00
|
|
|
eina_hash_free(_edje_file_hash);
|
|
|
|
_edje_file_hash = NULL;
|
2010-02-26 19:47:04 -08:00
|
|
|
}
|
|
|
|
}
|
2015-06-08 11:43:00 -07:00
|
|
|
|
2013-05-08 17:37:55 -07:00
|
|
|
#endif
|
2010-02-26 19:47:04 -08:00
|
|
|
|
2005-10-05 01:38:04 -07:00
|
|
|
Edje_File *
|
2014-07-01 19:28:42 -07:00
|
|
|
_edje_cache_file_coll_open(const Eina_File *file, const char *coll, int *error_ret, Edje_Part_Collection **edc_ret, Edje *ed EINA_UNUSED)
|
2005-10-05 01:38:04 -07:00
|
|
|
{
|
2010-09-10 04:24:49 -07:00
|
|
|
Edje_File *edf;
|
2008-10-22 04:34:42 -07:00
|
|
|
Eina_List *l, *hist;
|
2005-10-05 01:38:04 -07:00
|
|
|
Edje_Part_Collection *edc;
|
2008-10-22 04:34:42 -07:00
|
|
|
Edje_Part *ep;
|
2010-02-26 19:47:04 -08:00
|
|
|
|
2018-02-26 15:54:38 -08:00
|
|
|
if (!_edje_id_hash)
|
|
|
|
_edje_id_hash = eina_hash_stringshared_new(NULL);
|
2008-12-17 06:26:47 -08:00
|
|
|
if (!_edje_file_hash)
|
2010-04-05 07:05:21 -07:00
|
|
|
{
|
2015-06-08 11:43:00 -07:00
|
|
|
_edje_file_hash = eina_hash_pointer_new(NULL);
|
|
|
|
goto find_list;
|
2010-04-05 07:05:21 -07:00
|
|
|
}
|
2008-12-17 06:26:47 -08:00
|
|
|
|
2013-11-20 03:04:58 -08:00
|
|
|
edf = eina_hash_find(_edje_file_hash, &file);
|
2005-10-05 01:38:04 -07:00
|
|
|
if (edf)
|
|
|
|
{
|
2015-06-08 11:43:00 -07:00
|
|
|
edf->references++;
|
|
|
|
goto open;
|
2005-10-05 01:38:04 -07:00
|
|
|
}
|
2015-06-08 11:43:00 -07:00
|
|
|
|
2013-01-29 05:48:15 -08:00
|
|
|
find_list:
|
2010-04-05 07:05:21 -07:00
|
|
|
EINA_LIST_FOREACH(_edje_file_cache, l, edf)
|
2005-10-05 01:38:04 -07:00
|
|
|
{
|
2015-06-08 11:43:00 -07:00
|
|
|
if (edf->f == file)
|
|
|
|
{
|
|
|
|
edf->references = 1;
|
|
|
|
_edje_file_cache = eina_list_remove_list(_edje_file_cache, l);
|
|
|
|
eina_hash_direct_add(_edje_file_hash, &edf->f, edf);
|
|
|
|
goto open;
|
|
|
|
}
|
2005-10-05 01:38:04 -07:00
|
|
|
}
|
2010-02-26 19:47:04 -08:00
|
|
|
|
2016-02-03 15:23:34 -08:00
|
|
|
edf = _edje_file_open(file, error_ret, eina_file_mtime_get(file), !!coll);
|
2013-08-09 04:49:52 -07:00
|
|
|
if (!edf) return NULL;
|
2010-09-10 04:25:05 -07:00
|
|
|
|
2013-11-20 03:04:58 -08:00
|
|
|
eina_hash_direct_add(_edje_file_hash, &edf->f, edf);
|
2018-02-26 15:54:38 -08:00
|
|
|
if (edf->id)
|
|
|
|
eina_hash_list_append(_edje_id_hash, edf->id, edf);
|
2013-05-08 17:37:55 -07:00
|
|
|
/* return edf; */
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2010-09-10 04:25:05 -07:00
|
|
|
open:
|
|
|
|
if (!coll)
|
2015-06-08 11:43:00 -07:00
|
|
|
return edf;
|
2009-04-26 19:41:33 -07:00
|
|
|
|
2010-06-28 06:56:30 -07:00
|
|
|
edc = _edje_file_coll_open(edf, coll);
|
|
|
|
if (!edc)
|
2005-10-05 01:38:04 -07:00
|
|
|
{
|
2015-06-08 11:43:00 -07:00
|
|
|
*error_ret = EDJE_LOAD_ERROR_UNKNOWN_COLLECTION;
|
2005-10-05 01:38:04 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2015-06-08 11:43:00 -07:00
|
|
|
if (!edc->checked)
|
|
|
|
{
|
|
|
|
unsigned int j;
|
|
|
|
|
|
|
|
for (j = 0; j < edc->parts_count; ++j)
|
|
|
|
{
|
|
|
|
Edje_Part *ep2;
|
|
|
|
|
|
|
|
ep = edc->parts[j];
|
|
|
|
|
|
|
|
/* Register any color classes in this parts descriptions. */
|
|
|
|
hist = NULL;
|
|
|
|
hist = eina_list_append(hist, ep);
|
|
|
|
ep2 = ep;
|
|
|
|
while (ep2->dragable.confine_id >= 0)
|
|
|
|
{
|
|
|
|
if (ep2->dragable.confine_id >= (int)edc->parts_count)
|
|
|
|
{
|
|
|
|
ERR("confine_to above limit. invalidating it.");
|
|
|
|
ep2->dragable.confine_id = -1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
ep2 = edc->parts[ep2->dragable.confine_id];
|
|
|
|
if (eina_list_data_find(hist, ep2))
|
|
|
|
{
|
|
|
|
ERR("confine_to loops. invalidating loop.");
|
|
|
|
ep2->dragable.confine_id = -1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
hist = eina_list_append(hist, ep2);
|
|
|
|
}
|
|
|
|
eina_list_free(hist);
|
|
|
|
hist = NULL;
|
|
|
|
hist = eina_list_append(hist, ep);
|
|
|
|
ep2 = ep;
|
|
|
|
while (ep2->dragable.event_id >= 0)
|
|
|
|
{
|
|
|
|
Edje_Part *prev;
|
|
|
|
|
|
|
|
if (ep2->dragable.event_id >= (int)edc->parts_count)
|
|
|
|
{
|
|
|
|
ERR("event_id above limit. invalidating it.");
|
|
|
|
ep2->dragable.event_id = -1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
prev = ep2;
|
|
|
|
|
|
|
|
ep2 = edc->parts[ep2->dragable.event_id];
|
|
|
|
/* events_to may be used only with dragable */
|
|
|
|
if (!ep2->dragable.x && !ep2->dragable.y)
|
|
|
|
{
|
|
|
|
prev->dragable.event_id = -1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (eina_list_data_find(hist, ep2))
|
|
|
|
{
|
|
|
|
ERR("events_to loops. invalidating loop.");
|
|
|
|
ep2->dragable.event_id = -1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
hist = eina_list_append(hist, ep2);
|
|
|
|
}
|
|
|
|
eina_list_free(hist);
|
|
|
|
hist = NULL;
|
|
|
|
hist = eina_list_append(hist, ep);
|
|
|
|
ep2 = ep;
|
|
|
|
while (ep2->clip_to_id >= 0)
|
|
|
|
{
|
|
|
|
if (ep2->clip_to_id >= (int)edc->parts_count)
|
|
|
|
{
|
|
|
|
ERR("clip_to_id above limit. invalidating it.");
|
|
|
|
ep2->clip_to_id = -1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
ep2 = edc->parts[ep2->clip_to_id];
|
|
|
|
if (eina_list_data_find(hist, ep2))
|
|
|
|
{
|
|
|
|
ERR("clip_to loops. invalidating loop.");
|
|
|
|
ep2->clip_to_id = -1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
hist = eina_list_append(hist, ep2);
|
|
|
|
}
|
|
|
|
eina_list_free(hist);
|
|
|
|
hist = NULL;
|
|
|
|
}
|
|
|
|
edc->checked = 1;
|
|
|
|
}
|
2005-10-05 01:38:04 -07:00
|
|
|
}
|
2012-05-09 02:16:52 -07:00
|
|
|
|
2005-10-05 01:38:04 -07:00
|
|
|
if (edc_ret) *edc_ret = edc;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2005-10-05 01:38:04 -07:00
|
|
|
return edf;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
_edje_cache_coll_clean(Edje_File *edf)
|
|
|
|
{
|
2010-08-09 14:08:08 -07:00
|
|
|
while ((edf->collection_cache) &&
|
2015-06-08 11:43:00 -07:00
|
|
|
(eina_list_count(edf->collection_cache) > (unsigned int)_edje_collection_cache_size))
|
2005-10-05 01:38:04 -07:00
|
|
|
{
|
2015-06-08 11:43:00 -07:00
|
|
|
Edje_Part_Collection_Directory_Entry *ce;
|
|
|
|
Edje_Part_Collection *edc;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2015-06-08 11:43:00 -07:00
|
|
|
edc = eina_list_data_get(eina_list_last(edf->collection_cache));
|
|
|
|
edf->collection_cache = eina_list_remove_list(edf->collection_cache, eina_list_last(edf->collection_cache));
|
2010-07-29 05:02:36 -07:00
|
|
|
|
2015-06-08 11:43:00 -07:00
|
|
|
ce = eina_hash_find(edf->collection, edc->part);
|
|
|
|
_edje_collection_free(edf, edc, ce);
|
2005-10-05 01:38:04 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-11-02 00:13:56 -08:00
|
|
|
void
|
|
|
|
_edje_cache_coll_flush(Edje_File *edf)
|
|
|
|
{
|
|
|
|
while (edf->collection_cache)
|
|
|
|
{
|
2015-06-08 11:43:00 -07:00
|
|
|
Edje_Part_Collection_Directory_Entry *ce;
|
|
|
|
Edje_Part_Collection *edc;
|
|
|
|
Eina_List *last;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2015-06-08 11:43:00 -07:00
|
|
|
last = eina_list_last(edf->collection_cache);
|
|
|
|
edc = eina_list_data_get(last);
|
|
|
|
edf->collection_cache = eina_list_remove_list(edf->collection_cache,
|
|
|
|
last);
|
2010-07-29 05:02:36 -07:00
|
|
|
|
2015-06-08 11:43:00 -07:00
|
|
|
ce = eina_hash_find(edf->collection, edc->part);
|
|
|
|
_edje_collection_free(edf, edc, ce);
|
2005-11-02 00:13:56 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-10-05 01:38:04 -07:00
|
|
|
void
|
|
|
|
_edje_cache_coll_unref(Edje_File *edf, Edje_Part_Collection *edc)
|
|
|
|
{
|
2010-06-28 06:56:30 -07:00
|
|
|
Edje_Part_Collection_Directory_Entry *ce;
|
|
|
|
|
2005-10-05 01:38:04 -07:00
|
|
|
edc->references--;
|
|
|
|
if (edc->references != 0) return;
|
2010-06-28 06:56:30 -07:00
|
|
|
|
|
|
|
ce = eina_hash_find(edf->collection, edc->part);
|
2010-08-17 09:37:01 -07:00
|
|
|
if (!ce)
|
|
|
|
{
|
2015-06-08 11:43:00 -07:00
|
|
|
ERR("Something is wrong with reference count of '%s'.", edc->part);
|
2010-08-17 09:37:01 -07:00
|
|
|
}
|
|
|
|
else if (ce->ref)
|
2010-08-09 14:08:08 -07:00
|
|
|
{
|
2015-06-08 11:43:00 -07:00
|
|
|
ce->ref = NULL;
|
|
|
|
|
|
|
|
if (edf->dangling)
|
|
|
|
{
|
|
|
|
/* No need to keep the collection around if the file is dangling */
|
|
|
|
_edje_collection_free(edf, edc, ce);
|
|
|
|
_edje_cache_coll_flush(edf);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
edf->collection_cache = eina_list_prepend(edf->collection_cache, edc);
|
|
|
|
_edje_cache_coll_clean(edf);
|
|
|
|
}
|
2010-08-09 14:08:08 -07:00
|
|
|
}
|
2005-10-05 01:38:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_edje_cache_file_clean(void)
|
|
|
|
{
|
|
|
|
int count;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2008-10-22 04:34:42 -07:00
|
|
|
count = eina_list_count(_edje_file_cache);
|
2005-10-05 01:38:04 -07:00
|
|
|
while ((_edje_file_cache) && (count > _edje_file_cache_size))
|
|
|
|
{
|
2015-06-08 11:43:00 -07:00
|
|
|
Eina_List *last;
|
|
|
|
Edje_File *edf;
|
|
|
|
|
|
|
|
last = eina_list_last(_edje_file_cache);
|
|
|
|
edf = eina_list_data_get(last);
|
|
|
|
_edje_file_cache = eina_list_remove_list(_edje_file_cache, last);
|
|
|
|
_edje_file_free(edf);
|
|
|
|
count = eina_list_count(_edje_file_cache);
|
2005-10-05 01:38:04 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-16 02:43:26 -07:00
|
|
|
EAPI void
|
2005-10-05 01:38:04 -07:00
|
|
|
_edje_cache_file_unref(Edje_File *edf)
|
|
|
|
{
|
|
|
|
edf->references--;
|
|
|
|
if (edf->references != 0) return;
|
2008-12-17 06:26:47 -08:00
|
|
|
|
2018-02-26 15:54:38 -08:00
|
|
|
if (edf->requires_count)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
for (i = 0; i < edf->requires_count; i++)
|
|
|
|
{
|
|
|
|
Edje_File *required_edf = eina_hash_find(_edje_id_hash, edf->requires[i]);
|
|
|
|
|
|
|
|
if (required_edf)
|
|
|
|
_edje_cache_file_unref(edf);
|
|
|
|
else if (_edje_requires_pending)
|
|
|
|
{
|
|
|
|
eina_hash_list_remove(_edje_requires_pending, edf->requires[i], edf);
|
|
|
|
if (!eina_hash_population(_edje_requires_pending))
|
|
|
|
{
|
|
|
|
eina_hash_free(_edje_requires_pending);
|
|
|
|
_edje_requires_pending = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-02-26 19:47:04 -08:00
|
|
|
if (edf->dangling)
|
|
|
|
{
|
2015-06-08 11:43:00 -07:00
|
|
|
_edje_file_free(edf);
|
|
|
|
return;
|
2010-02-26 19:47:04 -08:00
|
|
|
}
|
|
|
|
|
2018-02-26 15:54:38 -08:00
|
|
|
if (edf->id)
|
|
|
|
eina_hash_list_remove(_edje_id_hash, edf->id, edf);
|
|
|
|
if (!eina_hash_population(_edje_id_hash))
|
|
|
|
{
|
|
|
|
eina_hash_free(_edje_id_hash);
|
|
|
|
_edje_id_hash = NULL;
|
|
|
|
}
|
2013-11-20 03:04:58 -08:00
|
|
|
eina_hash_del(_edje_file_hash, &edf->f, edf);
|
2008-12-17 06:26:47 -08:00
|
|
|
if (!eina_hash_population(_edje_file_hash))
|
|
|
|
{
|
2015-06-08 11:43:00 -07:00
|
|
|
eina_hash_free(_edje_file_hash);
|
|
|
|
_edje_file_hash = NULL;
|
2008-12-17 06:26:47 -08:00
|
|
|
}
|
2008-10-22 04:34:42 -07:00
|
|
|
_edje_file_cache = eina_list_prepend(_edje_file_cache, edf);
|
2005-10-05 01:38:04 -07:00
|
|
|
_edje_cache_file_clean();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
_edje_file_cache_shutdown(void)
|
|
|
|
{
|
|
|
|
edje_file_cache_flush();
|
|
|
|
}
|
|
|
|
|
2009-09-17 15:38:35 -07:00
|
|
|
/*============================================================================*
|
2015-06-08 11:43:00 -07:00
|
|
|
* Global *
|
|
|
|
*============================================================================*/
|
2009-09-17 15:38:35 -07:00
|
|
|
|
|
|
|
/*============================================================================*
|
2015-06-08 11:43:00 -07:00
|
|
|
* API *
|
|
|
|
*============================================================================*/
|
2005-10-05 01:38:04 -07:00
|
|
|
|
2006-01-07 00:54:30 -08:00
|
|
|
EAPI void
|
2005-10-05 01:38:04 -07:00
|
|
|
edje_file_cache_set(int count)
|
|
|
|
{
|
|
|
|
if (count < 0) count = 0;
|
|
|
|
_edje_file_cache_size = count;
|
|
|
|
_edje_cache_file_clean();
|
|
|
|
}
|
|
|
|
|
2006-01-07 00:54:30 -08:00
|
|
|
EAPI int
|
2005-10-05 01:38:04 -07:00
|
|
|
edje_file_cache_get(void)
|
|
|
|
{
|
|
|
|
return _edje_file_cache_size;
|
|
|
|
}
|
|
|
|
|
2006-01-07 00:54:30 -08:00
|
|
|
EAPI void
|
2005-10-05 01:38:04 -07:00
|
|
|
edje_file_cache_flush(void)
|
|
|
|
{
|
|
|
|
int ps;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2005-10-05 01:38:04 -07:00
|
|
|
ps = _edje_file_cache_size;
|
|
|
|
_edje_file_cache_size = 0;
|
|
|
|
_edje_cache_file_clean();
|
|
|
|
_edje_file_cache_size = ps;
|
|
|
|
}
|
|
|
|
|
2006-01-07 00:54:30 -08:00
|
|
|
EAPI void
|
2005-10-05 01:38:04 -07:00
|
|
|
edje_collection_cache_set(int count)
|
|
|
|
{
|
2008-10-22 04:34:42 -07:00
|
|
|
Eina_List *l;
|
|
|
|
Edje_File *edf;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2005-10-05 01:38:04 -07:00
|
|
|
if (count < 0) count = 0;
|
|
|
|
_edje_collection_cache_size = count;
|
2008-10-22 04:34:42 -07:00
|
|
|
EINA_LIST_FOREACH(_edje_file_cache, l, edf)
|
|
|
|
_edje_cache_coll_clean(edf);
|
2005-10-05 01:38:04 -07:00
|
|
|
/* FIXME: freach in file hash too! */
|
|
|
|
}
|
|
|
|
|
2006-01-07 00:54:30 -08:00
|
|
|
EAPI int
|
2005-10-05 01:38:04 -07:00
|
|
|
edje_collection_cache_get(void)
|
|
|
|
{
|
|
|
|
return _edje_collection_cache_size;
|
|
|
|
}
|
|
|
|
|
2006-01-07 00:54:30 -08:00
|
|
|
EAPI void
|
2005-10-05 01:38:04 -07:00
|
|
|
edje_collection_cache_flush(void)
|
|
|
|
{
|
|
|
|
int ps;
|
2008-10-22 04:34:42 -07:00
|
|
|
Eina_List *l;
|
|
|
|
Edje_File *edf;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2005-10-05 01:38:04 -07:00
|
|
|
ps = _edje_collection_cache_size;
|
|
|
|
_edje_collection_cache_size = 0;
|
2008-10-22 04:34:42 -07:00
|
|
|
EINA_LIST_FOREACH(_edje_file_cache, l, edf)
|
|
|
|
_edje_cache_coll_flush(edf);
|
2005-10-05 01:38:04 -07:00
|
|
|
/* FIXME: freach in file hash too! */
|
|
|
|
_edje_collection_cache_size = ps;
|
|
|
|
}
|
2015-06-08 11:43:00 -07:00
|
|
|
|