2009-02-08 22:33:26 -08:00
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
# include "config.h"
|
|
|
|
#endif
|
|
|
|
|
2012-02-18 06:25:45 -08:00
|
|
|
#ifdef STDC_HEADERS
|
|
|
|
# include <stdlib.h>
|
|
|
|
# include <stddef.h>
|
|
|
|
#else
|
|
|
|
# ifdef HAVE_STDLIB_H
|
|
|
|
# include <stdlib.h>
|
|
|
|
# endif
|
|
|
|
#endif
|
2009-02-08 22:33:26 -08:00
|
|
|
#ifdef HAVE_ALLOCA_H
|
|
|
|
# include <alloca.h>
|
2012-02-18 06:25:45 -08:00
|
|
|
#elif !defined alloca
|
|
|
|
# ifdef __GNUC__
|
|
|
|
# define alloca __builtin_alloca
|
|
|
|
# elif defined _AIX
|
|
|
|
# define alloca __alloca
|
|
|
|
# elif defined _MSC_VER
|
|
|
|
# include <malloc.h>
|
|
|
|
# define alloca _alloca
|
|
|
|
# elif !defined HAVE_ALLOCA
|
|
|
|
# ifdef __cplusplus
|
2009-02-08 22:33:26 -08:00
|
|
|
extern "C"
|
2012-02-18 06:25:45 -08:00
|
|
|
# endif
|
2009-02-08 22:33:26 -08:00
|
|
|
void *alloca (size_t);
|
2012-02-18 06:25:45 -08:00
|
|
|
# endif
|
2009-02-08 22:33:26 -08:00
|
|
|
#endif
|
|
|
|
|
2009-10-25 04:19:12 -07:00
|
|
|
#include <string.h>
|
|
|
|
#include <limits.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
|
2008-10-26 10:18:19 -07:00
|
|
|
#include <Ecore_Evas.h>
|
|
|
|
|
2003-06-11 06:20:48 -07:00
|
|
|
#include "edje_cc.h"
|
2010-08-09 10:34:03 -07:00
|
|
|
#include "edje_convert.h"
|
2011-11-04 05:18:13 -07:00
|
|
|
#include "edje_multisense_convert.h"
|
2003-06-11 06:20:48 -07:00
|
|
|
|
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
|
|
|
#include <lua.h>
|
|
|
|
#include <lauxlib.h>
|
|
|
|
|
2009-11-23 07:03:19 -08:00
|
|
|
typedef struct _External_Lookup External_Lookup;
|
2003-06-13 20:06:36 -07:00
|
|
|
typedef struct _Part_Lookup Part_Lookup;
|
2003-06-16 06:55:13 -07:00
|
|
|
typedef struct _Program_Lookup Program_Lookup;
|
2008-04-11 16:36:35 -07:00
|
|
|
typedef struct _Group_Lookup Group_Lookup;
|
2010-06-01 06:31:07 -07:00
|
|
|
typedef struct _Image_Lookup Image_Lookup;
|
2004-10-19 09:37:20 -07:00
|
|
|
typedef struct _Slave_Lookup Slave_Lookup;
|
2004-04-01 01:30:45 -08:00
|
|
|
typedef struct _Code_Lookup Code_Lookup;
|
2003-06-13 20:06:36 -07:00
|
|
|
|
2009-11-23 07:03:19 -08:00
|
|
|
|
|
|
|
struct _External_Lookup
|
|
|
|
{
|
|
|
|
char *name;
|
|
|
|
};
|
|
|
|
|
2003-06-13 20:06:36 -07:00
|
|
|
struct _Part_Lookup
|
|
|
|
{
|
2010-08-15 11:14:33 -07:00
|
|
|
Edje_Part_Collection *pc;
|
2003-06-13 20:06:36 -07:00
|
|
|
char *name;
|
|
|
|
int *dest;
|
|
|
|
};
|
|
|
|
|
2003-06-16 06:55:13 -07:00
|
|
|
struct _Program_Lookup
|
|
|
|
{
|
2010-08-15 11:14:33 -07:00
|
|
|
Edje_Part_Collection *pc;
|
2010-08-24 09:39:51 -07:00
|
|
|
|
|
|
|
union
|
|
|
|
{
|
|
|
|
char *name;
|
|
|
|
Edje_Program *ep;
|
|
|
|
} u;
|
|
|
|
|
2003-06-16 06:55:13 -07:00
|
|
|
int *dest;
|
2010-08-24 09:39:51 -07:00
|
|
|
|
|
|
|
Eina_Bool anonymous : 1;
|
2003-06-16 06:55:13 -07:00
|
|
|
};
|
|
|
|
|
2008-04-11 16:36:35 -07:00
|
|
|
struct _Group_Lookup
|
|
|
|
{
|
|
|
|
char *name;
|
2011-12-19 09:25:00 -08:00
|
|
|
Edje_Part *part;
|
2008-04-11 16:36:35 -07:00
|
|
|
};
|
|
|
|
|
2006-08-02 03:52:44 -07:00
|
|
|
struct _String_Lookup
|
2003-06-13 20:06:36 -07:00
|
|
|
{
|
|
|
|
char *name;
|
|
|
|
int *dest;
|
|
|
|
};
|
|
|
|
|
2010-06-01 06:31:07 -07:00
|
|
|
struct _Image_Lookup
|
|
|
|
{
|
|
|
|
char *name;
|
|
|
|
int *dest;
|
|
|
|
Eina_Bool *set;
|
|
|
|
};
|
|
|
|
|
2004-10-19 09:37:20 -07:00
|
|
|
struct _Slave_Lookup
|
|
|
|
{
|
|
|
|
int *master;
|
|
|
|
int *slave;
|
|
|
|
};
|
|
|
|
|
2004-04-01 01:30:45 -08:00
|
|
|
struct _Code_Lookup
|
|
|
|
{
|
|
|
|
char *ptr;
|
|
|
|
int len;
|
|
|
|
int val;
|
2010-06-01 06:31:07 -07:00
|
|
|
Eina_Bool set;
|
2004-04-01 01:30:45 -08:00
|
|
|
};
|
|
|
|
|
2012-05-15 19:15:45 -07:00
|
|
|
typedef struct _Script_Lua_Writer Script_Lua_Writer;
|
|
|
|
|
|
|
|
struct _Script_Lua_Writer
|
|
|
|
{
|
|
|
|
char *buf;
|
|
|
|
int size;
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef struct _Script_Write Script_Write;;
|
|
|
|
typedef struct _Head_Write Head_Write;
|
|
|
|
typedef struct _Fonts_Write Fonts_Write;
|
|
|
|
typedef struct _Image_Write Image_Write;
|
|
|
|
typedef struct _Sound_Write Sound_Write;
|
|
|
|
typedef struct _Group_Write Group_Write;
|
|
|
|
|
|
|
|
struct _Script_Write
|
2012-05-15 05:29:22 -07:00
|
|
|
{
|
|
|
|
Eet_File *ef;
|
|
|
|
Code *cd;
|
|
|
|
int i;
|
|
|
|
Ecore_Exe *exe;
|
|
|
|
int tmpn_fd, tmpo_fd;
|
|
|
|
char tmpn[PATH_MAX];
|
|
|
|
char tmpo[PATH_MAX];
|
|
|
|
char *errstr;
|
2012-05-15 19:15:45 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
struct _Head_Write
|
|
|
|
{
|
|
|
|
Eet_File *ef;
|
|
|
|
char *errstr;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct _Fonts_Write
|
|
|
|
{
|
|
|
|
Eet_File *ef;
|
|
|
|
Font *fn;
|
|
|
|
char *errstr;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct _Image_Write
|
|
|
|
{
|
|
|
|
Eet_File *ef;
|
|
|
|
Edje_Image_Directory_Entry *img;
|
|
|
|
Evas_Object *im;
|
|
|
|
int w, h;
|
|
|
|
int alpha;
|
|
|
|
unsigned int *data;
|
|
|
|
char *path;
|
|
|
|
char *errstr;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct _Sound_Write
|
|
|
|
{
|
|
|
|
Eet_File *ef;
|
|
|
|
Edje_Sound_Sample *sample;
|
|
|
|
int i;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct _Group_Write
|
|
|
|
{
|
|
|
|
Eet_File *ef;
|
|
|
|
Edje_Part_Collection *pc;
|
|
|
|
char *errstr;
|
|
|
|
};
|
2012-05-15 05:29:22 -07:00
|
|
|
|
|
|
|
static int pending_threads = 0;
|
|
|
|
|
2012-01-25 01:07:36 -08:00
|
|
|
static void data_process_string(Edje_Part_Collection *pc, const char *prefix, char *s, void (*func)(Edje_Part_Collection *pc, char *name, char* ptr, int len));
|
2004-04-01 01:53:11 -08:00
|
|
|
|
2010-08-15 11:14:33 -07:00
|
|
|
Edje_File *edje_file = NULL;
|
2008-10-22 04:34:42 -07:00
|
|
|
Eina_List *edje_collections = NULL;
|
2009-11-23 07:03:19 -08:00
|
|
|
Eina_List *externals = NULL;
|
2008-10-22 04:34:42 -07:00
|
|
|
Eina_List *fonts = NULL;
|
|
|
|
Eina_List *codes = NULL;
|
|
|
|
Eina_List *code_lookups = NULL;
|
|
|
|
Eina_List *aliases = NULL;
|
2003-06-11 06:20:48 -07:00
|
|
|
|
2003-06-13 20:06:36 -07:00
|
|
|
static Eet_Data_Descriptor *edd_edje_file = NULL;
|
2003-06-16 06:55:13 -07:00
|
|
|
static Eet_Data_Descriptor *edd_edje_part_collection = NULL;
|
2003-06-13 20:06:36 -07:00
|
|
|
|
2008-10-22 04:34:42 -07:00
|
|
|
static Eina_List *part_lookups = NULL;
|
|
|
|
static Eina_List *program_lookups = NULL;
|
|
|
|
static Eina_List *group_lookups = NULL;
|
|
|
|
static Eina_List *image_lookups = NULL;
|
|
|
|
static Eina_List *part_slave_lookups = NULL;
|
|
|
|
static Eina_List *image_slave_lookups= NULL;
|
2003-06-11 06:20:48 -07:00
|
|
|
|
2010-08-09 10:34:03 -07:00
|
|
|
void
|
2012-05-26 01:41:49 -07:00
|
|
|
error_and_abort(Eet_File *ef __UNUSED__, const char *fmt, ...)
|
2008-08-20 20:58:11 -07:00
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
2012-07-31 15:42:03 -07:00
|
|
|
eina_log_vprint(_edje_cc_log_dom, EINA_LOG_LEVEL_CRITICAL,
|
|
|
|
"unknown", "unknown", 0, fmt, ap);
|
2008-08-20 20:58:11 -07:00
|
|
|
va_end(ap);
|
2012-05-26 01:41:49 -07:00
|
|
|
unlink(file_out);
|
|
|
|
exit(-1);
|
2008-08-20 20:58:11 -07:00
|
|
|
}
|
|
|
|
|
2003-06-11 06:20:48 -07:00
|
|
|
void
|
|
|
|
data_setup(void)
|
|
|
|
{
|
2003-06-17 01:15:06 -07:00
|
|
|
edd_edje_file = _edje_edd_edje_file;
|
|
|
|
edd_edje_part_collection = _edje_edd_edje_part_collection;
|
2003-06-11 06:20:48 -07:00
|
|
|
}
|
|
|
|
|
2004-10-23 10:33:27 -07:00
|
|
|
static void
|
2012-05-15 05:29:22 -07:00
|
|
|
check_image_part_desc(Edje_Part_Collection *pc, Edje_Part *ep,
|
|
|
|
Edje_Part_Description_Image *epd, Eet_File *ef)
|
2004-10-23 10:33:27 -07:00
|
|
|
{
|
2010-08-15 11:14:33 -07:00
|
|
|
unsigned int i;
|
2012-08-23 00:54:58 -07:00
|
|
|
|
2012-07-12 19:50:58 -07:00
|
|
|
if (epd->image.id == -1 && epd->common.visible)
|
|
|
|
WRN("Collection %s(%i): image attributes missing for "
|
|
|
|
"part \"%s\", description \"%s\" %f",
|
2010-08-15 11:14:33 -07:00
|
|
|
pc->part, pc->id, ep->name, epd->common.state.name, epd->common.state.value);
|
2004-10-23 10:33:27 -07:00
|
|
|
|
2010-08-15 11:14:33 -07:00
|
|
|
for (i = 0; i < epd->image.tweens_count; ++i)
|
2004-10-23 10:33:27 -07:00
|
|
|
{
|
2010-08-15 11:14:33 -07:00
|
|
|
if (epd->image.tweens[i]->id == -1)
|
2008-08-20 20:58:11 -07:00
|
|
|
error_and_abort(ef, "Collection %i: tween image id missing for "
|
2012-07-31 15:42:03 -07:00
|
|
|
"part \"%s\", description \"%s\" %f",
|
2010-07-16 04:37:58 -07:00
|
|
|
pc->id, ep->name, epd->common.state.name, epd->common.state.value);
|
2008-08-20 20:58:11 -07:00
|
|
|
}
|
2004-10-23 10:33:27 -07:00
|
|
|
}
|
|
|
|
|
2008-11-23 21:15:15 -08:00
|
|
|
static void
|
2010-08-15 11:14:33 -07:00
|
|
|
check_packed_items(Edje_Part_Collection *pc, Edje_Part *ep, Eet_File *ef)
|
2008-11-23 21:15:15 -08:00
|
|
|
{
|
2010-08-15 11:14:33 -07:00
|
|
|
unsigned int i;
|
2008-11-23 21:15:15 -08:00
|
|
|
|
2010-08-15 11:14:33 -07:00
|
|
|
for (i = 0; i < ep->items_count; ++i)
|
2008-11-23 21:15:15 -08:00
|
|
|
{
|
2010-08-15 11:14:33 -07:00
|
|
|
if (ep->items[i]->type == EDJE_PART_TYPE_GROUP && !ep->items[i]->source)
|
2008-11-23 21:15:15 -08:00
|
|
|
error_and_abort(ef, "Collection %i: missing source on packed item "
|
2012-07-31 15:42:03 -07:00
|
|
|
"of type GROUP in part \"%s\"",
|
2008-11-23 21:15:15 -08:00
|
|
|
pc->id, ep->name);
|
2010-08-15 11:14:33 -07:00
|
|
|
if (ep->type == EDJE_PART_TYPE_TABLE && (ep->items[i]->col < 0 || ep->items[i]->row < 0))
|
2008-12-17 18:43:20 -08:00
|
|
|
error_and_abort(ef, "Collection %i: missing col/row on packed item "
|
2012-07-31 15:42:03 -07:00
|
|
|
"for part \"%s\" of type TABLE",
|
2008-12-17 18:43:20 -08:00
|
|
|
pc->id, ep->name);
|
2008-11-23 21:15:15 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-09-30 14:31:00 -07:00
|
|
|
static void
|
|
|
|
check_nameless_state(Edje_Part_Collection *pc, Edje_Part *ep, Edje_Part_Description_Common *ed, Eet_File *ef)
|
|
|
|
{
|
|
|
|
if (!ed->state.name)
|
2012-07-31 15:42:03 -07:00
|
|
|
error_and_abort(ef, "Collection %i: description with state missing on part \"%s\"",
|
2010-09-30 14:31:00 -07:00
|
|
|
pc->id, ep->name);
|
|
|
|
}
|
|
|
|
|
2004-10-23 10:33:27 -07:00
|
|
|
static void
|
2012-05-15 05:29:22 -07:00
|
|
|
check_part(Edje_Part_Collection *pc, Edje_Part *ep, Eet_File *ef)
|
2004-10-23 10:33:27 -07:00
|
|
|
{
|
2010-09-30 14:31:00 -07:00
|
|
|
unsigned int i;
|
2010-06-01 06:31:07 -07:00
|
|
|
/* FIXME: check image set and sort them. */
|
2010-08-15 11:14:33 -07:00
|
|
|
if (!ep->default_desc)
|
2008-08-20 20:58:11 -07:00
|
|
|
error_and_abort(ef, "Collection %i: default description missing "
|
2012-07-31 15:42:03 -07:00
|
|
|
"for part \"%s\"", pc->id, ep->name);
|
2004-10-23 10:33:27 -07:00
|
|
|
|
2010-09-30 14:31:00 -07:00
|
|
|
for (i = 0; i < ep->other.desc_count; ++i)
|
|
|
|
check_nameless_state(pc, ep, ep->other.desc[i], ef);
|
|
|
|
|
2004-10-23 10:33:27 -07:00
|
|
|
if (ep->type == EDJE_PART_TYPE_IMAGE)
|
|
|
|
{
|
2010-08-15 11:14:33 -07:00
|
|
|
check_image_part_desc(pc, ep, (Edje_Part_Description_Image*) ep->default_desc, ef);
|
|
|
|
|
|
|
|
for (i = 0; i < ep->other.desc_count; ++i)
|
|
|
|
check_image_part_desc (pc, ep, (Edje_Part_Description_Image*) ep->other.desc[i], ef);
|
2004-10-23 10:33:27 -07:00
|
|
|
}
|
2008-12-17 18:43:20 -08:00
|
|
|
else if ((ep->type == EDJE_PART_TYPE_BOX) ||
|
|
|
|
(ep->type == EDJE_PART_TYPE_TABLE))
|
2008-11-23 21:15:15 -08:00
|
|
|
check_packed_items(pc, ep, ef);
|
2012-07-13 02:15:17 -07:00
|
|
|
|
|
|
|
/* FIXME: When mask are supported remove this check */
|
|
|
|
if (ep->clip_to_id != -1 &&
|
|
|
|
pc->parts[ep->clip_to_id]->type != EDJE_PART_TYPE_RECTANGLE)
|
2012-07-31 15:42:03 -07:00
|
|
|
error_and_abort(ef, "Collection %i: clip_to point to a non RECT part '%s' !",
|
2012-07-13 02:15:17 -07:00
|
|
|
pc->id, pc->parts[ep->clip_to_id]->name);
|
2004-10-23 10:33:27 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-05-15 05:29:22 -07:00
|
|
|
check_program(Edje_Part_Collection *pc, Edje_Program *ep, Eet_File *ef)
|
2004-10-23 10:33:27 -07:00
|
|
|
{
|
2007-08-26 05:54:51 -07:00
|
|
|
switch (ep->action)
|
2006-08-04 01:55:05 -07:00
|
|
|
{
|
2004-10-23 10:33:27 -07:00
|
|
|
case EDJE_ACTION_TYPE_STATE_SET:
|
|
|
|
case EDJE_ACTION_TYPE_ACTION_STOP:
|
|
|
|
case EDJE_ACTION_TYPE_DRAG_VAL_SET:
|
|
|
|
case EDJE_ACTION_TYPE_DRAG_VAL_STEP:
|
|
|
|
case EDJE_ACTION_TYPE_DRAG_VAL_PAGE:
|
2007-08-26 05:54:51 -07:00
|
|
|
if (!ep->targets)
|
2008-08-20 20:58:11 -07:00
|
|
|
error_and_abort(ef, "Collection %i: target missing in program "
|
2012-07-31 15:42:03 -07:00
|
|
|
"\"%s\"", pc->id, ep->name);
|
2004-10-23 10:33:27 -07:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
2006-08-04 01:55:05 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
static void
|
|
|
|
data_thread_head(void *data, Ecore_Thread *thread __UNUSED__)
|
2003-06-11 06:20:48 -07:00
|
|
|
{
|
2012-05-15 05:29:22 -07:00
|
|
|
Head_Write *hw = data;
|
2008-08-20 20:57:20 -07:00
|
|
|
int bytes = 0;
|
2012-05-15 05:29:22 -07:00
|
|
|
char buf[PATH_MAX];
|
2007-08-26 05:54:51 -07:00
|
|
|
|
2010-08-15 11:14:33 -07:00
|
|
|
if (edje_file)
|
2003-06-16 06:55:13 -07:00
|
|
|
{
|
2010-08-15 11:14:33 -07:00
|
|
|
if (edje_file->collection)
|
2006-10-11 22:35:14 -07:00
|
|
|
{
|
2010-08-09 10:34:03 -07:00
|
|
|
Edje_Part_Collection_Directory_Entry *ce;
|
|
|
|
|
|
|
|
EINA_LIST_FREE(aliases, ce)
|
2006-10-11 22:35:14 -07:00
|
|
|
{
|
2010-08-12 08:05:56 -07:00
|
|
|
Edje_Part_Collection_Directory_Entry *sce;
|
|
|
|
Eina_Iterator *it;
|
|
|
|
|
2010-08-09 10:34:03 -07:00
|
|
|
if (!ce->entry)
|
2012-05-15 05:29:22 -07:00
|
|
|
{
|
|
|
|
snprintf(buf, sizeof(buf),
|
2012-07-31 15:42:03 -07:00
|
|
|
"Collection %i: name missing.", ce->id);
|
2012-05-15 05:29:22 -07:00
|
|
|
hw->errstr = strdup(buf);
|
|
|
|
return;
|
|
|
|
}
|
2010-08-12 08:05:56 -07:00
|
|
|
|
2010-08-15 11:14:33 -07:00
|
|
|
it = eina_hash_iterator_data_new(edje_file->collection);
|
2010-08-12 08:05:56 -07:00
|
|
|
|
|
|
|
EINA_ITERATOR_FOREACH(it, sce)
|
2012-05-15 05:29:22 -07:00
|
|
|
{
|
|
|
|
if (ce->id == sce->id)
|
|
|
|
{
|
|
|
|
memcpy(&ce->count, &sce->count, sizeof (ce->count));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2010-08-12 08:05:56 -07:00
|
|
|
|
|
|
|
if (!sce)
|
2012-05-15 05:29:22 -07:00
|
|
|
{
|
|
|
|
snprintf(buf, sizeof(buf),
|
2012-07-31 15:42:03 -07:00
|
|
|
"Collection %s (%i) can't find an correct alias.",
|
2012-05-15 05:29:22 -07:00
|
|
|
ce->entry, ce->id);
|
|
|
|
hw->errstr = strdup(buf);
|
|
|
|
return;
|
|
|
|
}
|
2010-08-12 08:05:56 -07:00
|
|
|
eina_iterator_free(it);
|
2010-08-15 11:14:33 -07:00
|
|
|
eina_hash_direct_add(edje_file->collection, ce->entry, ce);
|
2006-10-11 22:35:14 -07:00
|
|
|
}
|
|
|
|
}
|
2012-05-15 05:29:22 -07:00
|
|
|
bytes = eet_data_write(hw->ef, edd_edje_file, "edje/file", edje_file,
|
|
|
|
compress_mode);
|
2003-10-18 19:11:06 -07:00
|
|
|
if (bytes <= 0)
|
2012-05-15 05:29:22 -07:00
|
|
|
{
|
|
|
|
snprintf(buf, sizeof(buf),
|
2012-07-31 15:42:03 -07:00
|
|
|
"Unable to write \"edje_file\" entry to \"%s\"",
|
2012-05-15 05:29:22 -07:00
|
|
|
file_out);
|
|
|
|
hw->errstr = strdup(buf);
|
|
|
|
return;
|
|
|
|
}
|
2003-06-16 06:55:13 -07:00
|
|
|
}
|
2008-08-20 20:57:20 -07:00
|
|
|
|
2012-07-31 15:42:03 -07:00
|
|
|
INF("Wrote %9i bytes (%4iKb) for \"edje_file\" header",
|
|
|
|
bytes, (bytes + 512) / 1024);
|
2012-05-15 05:29:22 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
data_thread_head_end(void *data, Ecore_Thread *thread __UNUSED__)
|
|
|
|
{
|
|
|
|
Head_Write *hw = data;
|
2012-08-23 00:54:58 -07:00
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
pending_threads--;
|
|
|
|
if (pending_threads <= 0) ecore_main_loop_quit();
|
|
|
|
if (hw->errstr)
|
2003-06-16 06:55:13 -07:00
|
|
|
{
|
2012-05-15 05:29:22 -07:00
|
|
|
error_and_abort(hw->ef, hw->errstr);
|
|
|
|
free(hw->errstr);
|
2003-06-16 06:55:13 -07:00
|
|
|
}
|
2012-05-15 05:29:22 -07:00
|
|
|
free(hw);
|
|
|
|
}
|
2008-08-20 20:57:20 -07:00
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
static void
|
|
|
|
data_write_header(Eet_File *ef)
|
|
|
|
{
|
|
|
|
Head_Write *hw;
|
2012-08-23 00:54:58 -07:00
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
hw = calloc(1, sizeof(Head_Write));
|
|
|
|
hw->ef = ef;
|
|
|
|
pending_threads++;
|
2012-05-16 00:43:14 -07:00
|
|
|
if (threads)
|
|
|
|
ecore_thread_run(data_thread_head, data_thread_head_end, NULL, hw);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
data_thread_head(hw, NULL);
|
|
|
|
data_thread_head_end(hw, NULL);
|
|
|
|
}
|
2008-08-20 20:57:20 -07:00
|
|
|
}
|
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
static void
|
|
|
|
data_thread_fonts(void *data, Ecore_Thread *thread __UNUSED__)
|
|
|
|
{
|
2012-05-15 19:15:45 -07:00
|
|
|
Fonts_Write *fc = data;
|
2012-05-15 05:29:22 -07:00
|
|
|
Eina_List *ll;
|
2012-05-20 00:06:57 -07:00
|
|
|
Eina_File *f = NULL;
|
|
|
|
void *m = NULL;
|
2012-05-15 05:29:22 -07:00
|
|
|
int bytes = 0;
|
|
|
|
char buf[PATH_MAX];
|
|
|
|
char buf2[PATH_MAX];
|
2012-05-20 00:06:57 -07:00
|
|
|
|
|
|
|
f = eina_file_open(fc->fn->file, 0);
|
2012-05-15 05:29:22 -07:00
|
|
|
if (f)
|
2004-01-22 18:13:42 -08:00
|
|
|
{
|
2012-05-15 05:29:22 -07:00
|
|
|
using_file(fc->fn->file);
|
2012-05-20 00:06:57 -07:00
|
|
|
m = eina_file_map_all(f, EINA_FILE_SEQUENTIAL);
|
2012-05-15 05:29:22 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
char *dat;
|
2012-05-20 00:06:57 -07:00
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
EINA_LIST_FOREACH(fnt_dirs, ll, dat)
|
|
|
|
{
|
|
|
|
snprintf(buf, sizeof(buf), "%s/%s", dat, fc->fn->file);
|
2012-05-20 00:06:57 -07:00
|
|
|
f = eina_file_open(buf, 0);
|
2012-05-15 05:29:22 -07:00
|
|
|
if (f)
|
|
|
|
{
|
|
|
|
using_file(buf);
|
2012-05-20 00:06:57 -07:00
|
|
|
m = eina_file_map_all(f, EINA_FILE_SEQUENTIAL);
|
|
|
|
if (m) break;
|
|
|
|
eina_file_close(f);
|
|
|
|
f = NULL;
|
2012-05-15 05:29:22 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-05-20 00:06:57 -07:00
|
|
|
if (!m)
|
2012-05-15 05:29:22 -07:00
|
|
|
{
|
2012-05-20 00:06:57 -07:00
|
|
|
if (f) eina_file_close(f);
|
2012-05-15 05:29:22 -07:00
|
|
|
snprintf(buf, sizeof(buf),
|
2012-07-31 15:42:03 -07:00
|
|
|
"Unable to load font part \"%s\" entry to %s",
|
2012-05-15 05:29:22 -07:00
|
|
|
fc->fn->file, file_out);
|
|
|
|
fc->errstr = strdup(buf);
|
|
|
|
return;
|
|
|
|
}
|
2012-05-20 00:06:57 -07:00
|
|
|
|
|
|
|
snprintf(buf, sizeof(buf), "edje/fonts/%s", fc->fn->name);
|
|
|
|
bytes = eet_write(fc->ef, buf, m, eina_file_size_get(f), compress_mode);
|
|
|
|
|
2012-05-22 21:22:41 -07:00
|
|
|
if ((bytes <= 0) || eina_file_map_faulted(f, m))
|
2012-05-15 05:29:22 -07:00
|
|
|
{
|
2012-05-20 00:06:57 -07:00
|
|
|
eina_file_map_free(f, m);
|
|
|
|
eina_file_close(f);
|
|
|
|
snprintf(buf2, sizeof(buf2),
|
|
|
|
"Unable to write font part \"%s\" as \"%s\" "
|
2012-07-31 15:42:03 -07:00
|
|
|
"part entry to %s", fc->fn->file, buf, file_out);
|
2012-05-20 00:06:57 -07:00
|
|
|
fc->errstr = strdup(buf2);
|
|
|
|
return;
|
2012-05-15 05:29:22 -07:00
|
|
|
}
|
2012-05-20 00:06:57 -07:00
|
|
|
|
2012-07-31 15:42:03 -07:00
|
|
|
INF("Wrote %9i bytes (%4iKb) for \"%s\" font entry \"%s\" compress: [real: %2.1f%%]",
|
|
|
|
bytes, (bytes + 512) / 1024, buf, fc->fn->file,
|
|
|
|
100 - (100 * (double)bytes) / ((double)(eina_file_size_get(f)))
|
|
|
|
);
|
2012-05-20 00:06:57 -07:00
|
|
|
eina_file_map_free(f, m);
|
|
|
|
eina_file_close(f);
|
2012-05-15 05:29:22 -07:00
|
|
|
}
|
2007-08-26 05:54:51 -07:00
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
static void
|
|
|
|
data_thread_fonts_end(void *data, Ecore_Thread *thread __UNUSED__)
|
|
|
|
{
|
2012-05-15 19:15:45 -07:00
|
|
|
Fonts_Write *fc = data;
|
2012-05-15 05:29:22 -07:00
|
|
|
pending_threads--;
|
|
|
|
if (pending_threads <= 0) ecore_main_loop_quit();
|
|
|
|
if (fc->errstr)
|
|
|
|
{
|
|
|
|
error_and_abort(fc->ef, fc->errstr);
|
|
|
|
free(fc->errstr);
|
|
|
|
}
|
|
|
|
free(fc);
|
|
|
|
}
|
2007-08-26 05:54:51 -07:00
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
static void
|
|
|
|
data_write_fonts(Eet_File *ef, int *font_num)
|
|
|
|
{
|
|
|
|
Eina_Iterator *it;
|
|
|
|
Font *fn;
|
2008-08-20 20:58:11 -07:00
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
if (!edje_file->fonts) return;
|
2008-08-20 20:58:11 -07:00
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
it = eina_hash_iterator_data_new(edje_file->fonts);
|
|
|
|
EINA_ITERATOR_FOREACH(it, fn)
|
|
|
|
{
|
2012-05-15 19:15:45 -07:00
|
|
|
Fonts_Write *fc;
|
2012-05-20 00:06:57 -07:00
|
|
|
|
2012-05-15 19:15:45 -07:00
|
|
|
fc = calloc(1, sizeof(Fonts_Write));
|
2012-05-15 05:29:22 -07:00
|
|
|
if (!fc) continue;
|
|
|
|
fc->ef = ef;
|
|
|
|
fc->fn = fn;
|
2012-05-16 00:43:14 -07:00
|
|
|
pending_threads++;
|
|
|
|
if (threads)
|
|
|
|
ecore_thread_run(data_thread_fonts, data_thread_fonts_end, NULL, fc);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
data_thread_fonts(fc, NULL);
|
|
|
|
data_thread_fonts_end(fc, NULL);
|
|
|
|
}
|
2012-05-15 05:29:22 -07:00
|
|
|
*font_num += 1;
|
2004-01-22 18:13:42 -08:00
|
|
|
}
|
2010-08-27 11:52:41 -07:00
|
|
|
eina_iterator_free(it);
|
2008-08-20 20:57:20 -07:00
|
|
|
}
|
|
|
|
|
2009-12-22 15:56:11 -08:00
|
|
|
static void
|
|
|
|
error_and_abort_image_load_error(Eet_File *ef, const char *file, int error)
|
|
|
|
{
|
|
|
|
const char *errmsg = evas_load_error_str(error);
|
|
|
|
char hint[1024] = "";
|
|
|
|
|
|
|
|
if (error == EVAS_LOAD_ERROR_DOES_NOT_EXIST)
|
|
|
|
{
|
|
|
|
snprintf
|
|
|
|
(hint, sizeof(hint),
|
|
|
|
" Check if path to file \"%s\" is correct "
|
|
|
|
"(both directory and file name).",
|
|
|
|
file);
|
|
|
|
}
|
|
|
|
else if (error == EVAS_LOAD_ERROR_CORRUPT_FILE)
|
|
|
|
{
|
|
|
|
snprintf
|
|
|
|
(hint, sizeof(hint),
|
|
|
|
" Check if file \"%s\" is consistent.",
|
|
|
|
file);
|
|
|
|
}
|
|
|
|
else if (error == EVAS_LOAD_ERROR_UNKNOWN_FORMAT)
|
|
|
|
{
|
|
|
|
const char *ext = strrchr(file, '.');
|
|
|
|
const char **itr, *known_loaders[] = {
|
|
|
|
/* list from evas_image_load.c */
|
|
|
|
"png",
|
|
|
|
"jpg",
|
|
|
|
"jpeg",
|
|
|
|
"jfif",
|
|
|
|
"eet",
|
|
|
|
"edj",
|
|
|
|
"eap",
|
|
|
|
"edb",
|
|
|
|
"xpm",
|
|
|
|
"tiff",
|
|
|
|
"tif",
|
|
|
|
"svg",
|
|
|
|
"svgz",
|
|
|
|
"gif",
|
|
|
|
"pbm",
|
|
|
|
"pgm",
|
|
|
|
"ppm",
|
|
|
|
"pnm",
|
2012-05-15 19:15:45 -07:00
|
|
|
"bmp",
|
|
|
|
"ico",
|
|
|
|
"tga",
|
2009-12-22 15:56:11 -08:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
if (!ext)
|
|
|
|
{
|
|
|
|
snprintf
|
|
|
|
(hint, sizeof(hint),
|
|
|
|
" File \"%s\" does not have an extension, "
|
|
|
|
"maybe it should?",
|
|
|
|
file);
|
|
|
|
goto show_err;
|
|
|
|
}
|
|
|
|
|
|
|
|
ext++;
|
|
|
|
for (itr = known_loaders; *itr; itr++)
|
|
|
|
{
|
|
|
|
if (strcasecmp(ext, *itr) == 0)
|
|
|
|
{
|
|
|
|
snprintf
|
|
|
|
(hint, sizeof(hint),
|
|
|
|
" Check if Evas was compiled with %s module enabled and "
|
|
|
|
"all required dependencies exist.",
|
|
|
|
ext);
|
|
|
|
goto show_err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
snprintf(hint, sizeof(hint),
|
|
|
|
" Check if Evas supports loading files of type \"%s\" (%s) "
|
|
|
|
"and this module was compiled and all its dependencies exist.",
|
|
|
|
ext, file);
|
|
|
|
}
|
|
|
|
show_err:
|
|
|
|
error_and_abort
|
2012-07-31 15:42:03 -07:00
|
|
|
(ef, "Unable to load image \"%s\" used by file \"%s\": %s.%s",
|
2009-12-22 15:56:11 -08:00
|
|
|
file, file_out, errmsg, hint);
|
|
|
|
}
|
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
static void
|
|
|
|
data_thread_image(void *data, Ecore_Thread *thread __UNUSED__)
|
|
|
|
{
|
|
|
|
Image_Write *iw = data;
|
2012-07-06 20:25:31 -07:00
|
|
|
char buf[PATH_MAX], buf2[PATH_MAX];
|
2012-05-15 05:29:22 -07:00
|
|
|
unsigned int *start, *end;
|
|
|
|
Eina_Bool opaque = EINA_TRUE;
|
2008-08-20 20:57:20 -07:00
|
|
|
int bytes = 0;
|
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
if ((iw->data) && (iw->w > 0) && (iw->h > 0))
|
2003-06-11 06:20:48 -07:00
|
|
|
{
|
2012-05-15 05:29:22 -07:00
|
|
|
int mode, qual;
|
2012-05-20 00:06:57 -07:00
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
snprintf(buf, sizeof(buf), "edje/images/%i", iw->img->id);
|
|
|
|
qual = 80;
|
|
|
|
if ((iw->img->source_type == EDJE_IMAGE_SOURCE_TYPE_INLINE_PERFECT) &&
|
|
|
|
(iw->img->source_param == 0))
|
|
|
|
mode = 0; /* RAW */
|
|
|
|
else if ((iw->img->source_type == EDJE_IMAGE_SOURCE_TYPE_INLINE_PERFECT) &&
|
|
|
|
(iw->img->source_param == 1))
|
|
|
|
mode = 1; /* COMPRESS */
|
|
|
|
else
|
|
|
|
mode = 2; /* LOSSY */
|
|
|
|
if ((mode == 0) && (no_raw))
|
|
|
|
{
|
|
|
|
mode = 1; /* promote compression */
|
|
|
|
iw->img->source_param = 95;
|
|
|
|
}
|
|
|
|
if ((mode == 2) && (no_lossy)) mode = 1; /* demote compression */
|
|
|
|
if ((mode == 1) && (no_comp))
|
|
|
|
{
|
|
|
|
if (no_lossy) mode = 0; /* demote compression */
|
|
|
|
else if (no_raw)
|
|
|
|
{
|
|
|
|
iw->img->source_param = 90;
|
|
|
|
mode = 2; /* no choice. lossy */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (mode == 2)
|
|
|
|
{
|
|
|
|
qual = iw->img->source_param;
|
|
|
|
if (qual < min_quality) qual = min_quality;
|
|
|
|
if (qual > max_quality) qual = max_quality;
|
|
|
|
}
|
|
|
|
if (iw->alpha)
|
|
|
|
{
|
|
|
|
start = (unsigned int *) iw->data;
|
|
|
|
end = start + (iw->w * iw->h);
|
|
|
|
while (start < end)
|
|
|
|
{
|
|
|
|
if ((*start & 0xff000000) != 0xff000000)
|
|
|
|
{
|
|
|
|
opaque = EINA_FALSE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
start++;
|
|
|
|
}
|
|
|
|
if (opaque) iw->alpha = 0;
|
|
|
|
}
|
|
|
|
if (mode == 0)
|
|
|
|
bytes = eet_data_image_write(iw->ef, buf,
|
|
|
|
iw->data, iw->w, iw->h,
|
|
|
|
iw->alpha,
|
|
|
|
0, 0, 0);
|
|
|
|
else if (mode == 1)
|
|
|
|
bytes = eet_data_image_write(iw->ef, buf,
|
|
|
|
iw->data, iw->w, iw->h,
|
|
|
|
iw->alpha,
|
|
|
|
compress_mode,
|
|
|
|
0, 0);
|
|
|
|
else if (mode == 2)
|
|
|
|
bytes = eet_data_image_write(iw->ef, buf,
|
|
|
|
iw->data, iw->w, iw->h,
|
|
|
|
iw->alpha,
|
|
|
|
0, qual, 1);
|
|
|
|
if (bytes <= 0)
|
|
|
|
{
|
2012-07-06 20:25:31 -07:00
|
|
|
snprintf(buf2, sizeof(buf2),
|
2012-05-15 05:29:22 -07:00
|
|
|
"Unable to write image part "
|
|
|
|
"\"%s\" as \"%s\" part entry to "
|
2012-07-31 15:42:03 -07:00
|
|
|
"%s", iw->img->entry, buf, file_out);
|
2012-07-06 20:25:31 -07:00
|
|
|
iw->errstr = strdup(buf2);
|
2012-05-15 05:29:22 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2012-08-20 00:46:51 -07:00
|
|
|
snprintf(buf, sizeof(buf), "edje/images/%i", iw->img->id);
|
2012-07-06 20:25:31 -07:00
|
|
|
snprintf(buf2, sizeof(buf2),
|
2012-05-15 05:29:22 -07:00
|
|
|
"Unable to load image part "
|
|
|
|
"\"%s\" as \"%s\" part entry to "
|
2012-07-31 15:42:03 -07:00
|
|
|
"%s", iw->img->entry, buf, file_out);
|
2012-07-06 20:25:31 -07:00
|
|
|
iw->errstr = strdup(buf2);
|
2012-05-15 05:29:22 -07:00
|
|
|
return;
|
|
|
|
}
|
2012-05-20 00:06:57 -07:00
|
|
|
|
2012-07-31 15:42:03 -07:00
|
|
|
if (eina_log_domain_level_check(_edje_cc_log_dom, EINA_LOG_LEVEL_INFO))
|
2012-05-15 05:29:22 -07:00
|
|
|
{
|
|
|
|
struct stat st;
|
2012-05-15 19:15:45 -07:00
|
|
|
|
2012-05-20 00:06:57 -07:00
|
|
|
if (!iw->path || (stat(iw->path, &st))) st.st_size = 0;
|
2012-07-31 15:42:03 -07:00
|
|
|
INF("Wrote %9i bytes (%4iKb) for \"%s\" image entry \"%s\" compress: [raw: %2.1f%%] [real: %2.1f%%]",
|
|
|
|
bytes, (bytes + 512) / 1024, buf, iw->img->entry,
|
2012-05-15 19:15:45 -07:00
|
|
|
100 - (100 * (double)bytes) / ((double)(iw->w * iw->h * 4)),
|
2012-05-15 05:29:22 -07:00
|
|
|
100 - (100 * (double)bytes) / ((double)(st.st_size))
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
2008-08-20 20:58:11 -07:00
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
static void
|
|
|
|
data_thread_image_end(void *data, Ecore_Thread *thread __UNUSED__)
|
|
|
|
{
|
|
|
|
Image_Write *iw = data;
|
2012-08-23 00:54:58 -07:00
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
pending_threads--;
|
|
|
|
if (pending_threads <= 0) ecore_main_loop_quit();
|
|
|
|
if (iw->errstr)
|
|
|
|
{
|
|
|
|
error_and_abort(iw->ef, iw->errstr);
|
|
|
|
free(iw->errstr);
|
2003-06-11 06:20:48 -07:00
|
|
|
}
|
2012-05-15 19:15:45 -07:00
|
|
|
if (iw->path) free(iw->path);
|
2012-05-15 05:29:22 -07:00
|
|
|
evas_object_del(iw->im);
|
|
|
|
free(iw);
|
|
|
|
}
|
2004-10-23 10:33:27 -07:00
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
static void
|
|
|
|
data_image_preload_done(void *data, Evas *e __UNUSED__, Evas_Object *o, void *event_info __UNUSED__)
|
|
|
|
{
|
|
|
|
Image_Write *iw = data;
|
|
|
|
|
|
|
|
evas_object_image_size_get(o, &iw->w, &iw->h);
|
|
|
|
iw->alpha = evas_object_image_alpha_get(o);
|
|
|
|
iw->data = evas_object_image_data_get(o, 0);
|
2012-05-16 00:43:14 -07:00
|
|
|
if (threads)
|
|
|
|
ecore_thread_run(data_thread_image, data_thread_image_end, NULL, iw);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
data_thread_image(iw, NULL);
|
|
|
|
data_thread_image_end(iw, NULL);
|
|
|
|
}
|
2008-08-20 20:57:20 -07:00
|
|
|
}
|
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
static void
|
|
|
|
data_write_images(Eet_File *ef, int *image_num)
|
2011-11-04 05:18:13 -07:00
|
|
|
{
|
2012-05-15 05:29:22 -07:00
|
|
|
int i;
|
|
|
|
Ecore_Evas *ee;
|
|
|
|
Evas *evas;
|
2012-08-23 00:54:58 -07:00
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
if (!((edje_file) && (edje_file->image_dir))) return;
|
|
|
|
|
|
|
|
ecore_evas_init();
|
|
|
|
ee = ecore_evas_buffer_new(1, 1);
|
|
|
|
if (!ee)
|
2012-07-31 15:42:03 -07:00
|
|
|
error_and_abort(ef, "Cannot create buffer engine canvas for image load.");
|
2012-05-15 05:29:22 -07:00
|
|
|
evas = ecore_evas_get(ee);
|
2012-08-23 00:54:58 -07:00
|
|
|
|
2012-05-15 19:15:45 -07:00
|
|
|
for (i = 0; i < (int)edje_file->image_dir->entries_count; i++)
|
2011-11-04 05:18:13 -07:00
|
|
|
{
|
2012-05-15 05:29:22 -07:00
|
|
|
Edje_Image_Directory_Entry *img;
|
2012-08-23 00:54:58 -07:00
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
img = &edje_file->image_dir->entries[i];
|
|
|
|
if ((img->source_type == EDJE_IMAGE_SOURCE_TYPE_EXTERNAL) ||
|
|
|
|
(img->entry == NULL))
|
2011-11-04 05:18:13 -07:00
|
|
|
{
|
2012-05-15 05:29:22 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
Evas_Object *im;
|
|
|
|
Eina_List *ll;
|
|
|
|
char *s;
|
|
|
|
int load_err = EVAS_LOAD_ERROR_NONE;
|
|
|
|
Image_Write *iw;
|
2012-08-23 00:54:58 -07:00
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
iw = calloc(1, sizeof(Image_Write));
|
|
|
|
iw->ef = ef;
|
|
|
|
iw->img = img;
|
|
|
|
iw->im = im = evas_object_image_add(evas);
|
2012-07-06 20:25:31 -07:00
|
|
|
if (threads)
|
|
|
|
evas_object_event_callback_add(im,
|
|
|
|
EVAS_CALLBACK_IMAGE_PRELOADED,
|
|
|
|
data_image_preload_done,
|
|
|
|
iw);
|
2012-05-15 05:29:22 -07:00
|
|
|
EINA_LIST_FOREACH(img_dirs, ll, s)
|
2011-11-04 05:18:13 -07:00
|
|
|
{
|
2012-05-15 05:29:22 -07:00
|
|
|
char buf[PATH_MAX];
|
2012-08-23 00:54:58 -07:00
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
snprintf(buf, sizeof(buf), "%s/%s", s, img->entry);
|
|
|
|
evas_object_image_file_set(im, buf, NULL);
|
|
|
|
load_err = evas_object_image_load_error_get(im);
|
|
|
|
if (load_err == EVAS_LOAD_ERROR_NONE)
|
|
|
|
{
|
2012-05-15 19:15:45 -07:00
|
|
|
*image_num += 1;
|
|
|
|
iw->path = strdup(buf);
|
2012-05-15 05:29:22 -07:00
|
|
|
pending_threads++;
|
2012-07-06 20:25:31 -07:00
|
|
|
if (threads)
|
|
|
|
evas_object_image_preload(im, 0);
|
2012-05-15 05:29:22 -07:00
|
|
|
using_file(buf);
|
2012-07-06 20:25:31 -07:00
|
|
|
if (!threads)
|
|
|
|
data_image_preload_done(iw, evas, im, NULL);
|
2012-05-15 05:29:22 -07:00
|
|
|
break;
|
|
|
|
}
|
2011-11-04 05:18:13 -07:00
|
|
|
}
|
2012-05-15 05:29:22 -07:00
|
|
|
if (load_err != EVAS_LOAD_ERROR_NONE)
|
2011-11-04 05:18:13 -07:00
|
|
|
{
|
2012-05-15 05:29:22 -07:00
|
|
|
evas_object_image_file_set(im, img->entry, NULL);
|
|
|
|
load_err = evas_object_image_load_error_get(im);
|
|
|
|
if (load_err == EVAS_LOAD_ERROR_NONE)
|
|
|
|
{
|
2012-05-15 19:15:45 -07:00
|
|
|
*image_num += 1;
|
|
|
|
iw->path = strdup(img->entry);
|
2012-05-15 05:29:22 -07:00
|
|
|
pending_threads++;
|
2012-07-06 20:25:31 -07:00
|
|
|
if (threads)
|
|
|
|
evas_object_image_preload(im, 0);
|
2012-05-15 05:29:22 -07:00
|
|
|
using_file(img->entry);
|
2012-07-06 20:25:31 -07:00
|
|
|
if (!threads)
|
|
|
|
data_image_preload_done(iw, evas, im, NULL);
|
2012-05-15 05:29:22 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
error_and_abort_image_load_error
|
|
|
|
(ef, img->entry, load_err);
|
2011-11-04 05:18:13 -07:00
|
|
|
}
|
2012-05-15 05:29:22 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
data_thread_sounds(void *data, Ecore_Thread *thread __UNUSED__)
|
|
|
|
{
|
|
|
|
Sound_Write *sw = data;
|
|
|
|
Eina_List *ll;
|
2011-11-04 05:18:13 -07:00
|
|
|
#ifdef HAVE_LIBSNDFILE
|
2012-05-15 05:29:22 -07:00
|
|
|
Edje_Sound_Encode *enc_info;
|
|
|
|
#endif
|
|
|
|
char *dir_path = NULL;
|
|
|
|
char snd_path[PATH_MAX];
|
|
|
|
char sndid_str[15];
|
2012-05-20 00:06:57 -07:00
|
|
|
Eina_File *f = NULL;
|
|
|
|
void *m = NULL;
|
2012-05-15 05:29:22 -07:00
|
|
|
int bytes = 0;
|
|
|
|
|
|
|
|
// Search the Sound file in all the -sd ( sound directory )
|
|
|
|
EINA_LIST_FOREACH(snd_dirs, ll, dir_path)
|
|
|
|
{
|
|
|
|
snprintf((char *)snd_path, sizeof(snd_path), "%s/%s", dir_path,
|
|
|
|
sw->sample->snd_src);
|
2012-05-20 00:06:57 -07:00
|
|
|
f = eina_file_open(snd_path, 0);
|
|
|
|
if (f) break;
|
2012-05-15 05:29:22 -07:00
|
|
|
}
|
2012-05-20 00:06:57 -07:00
|
|
|
if (!f)
|
2012-05-15 05:29:22 -07:00
|
|
|
{
|
|
|
|
snprintf((char *)snd_path, sizeof(snd_path), "%s",
|
|
|
|
sw->sample->snd_src);
|
2012-05-20 00:06:57 -07:00
|
|
|
f = eina_file_open(snd_path, 0);
|
2012-05-15 05:29:22 -07:00
|
|
|
}
|
|
|
|
#ifdef HAVE_LIBSNDFILE
|
2012-05-20 00:06:57 -07:00
|
|
|
if (f) eina_file_close(f);
|
2012-05-15 05:29:22 -07:00
|
|
|
enc_info = _edje_multisense_encode(snd_path, sw->sample,
|
|
|
|
sw->sample->quality);
|
2012-05-20 00:06:57 -07:00
|
|
|
f = eina_file_open(enc_info->file, 0);
|
|
|
|
if (f) using_file(enc_info->file);
|
2011-11-04 05:18:13 -07:00
|
|
|
#else
|
2012-05-20 00:06:57 -07:00
|
|
|
if (f) using_file(snd_path);
|
2011-11-04 05:18:13 -07:00
|
|
|
#endif
|
2012-05-20 00:06:57 -07:00
|
|
|
if (!f)
|
2012-05-15 05:29:22 -07:00
|
|
|
{
|
2012-07-31 15:42:03 -07:00
|
|
|
ERR("Unable to load sound data of: %s", sw->sample->name);
|
2012-05-15 05:29:22 -07:00
|
|
|
exit(-1);
|
|
|
|
}
|
2012-05-20 00:06:57 -07:00
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
snprintf(sndid_str, sizeof(sndid_str), "edje/sounds/%i", sw->sample->id);
|
2012-05-20 00:06:57 -07:00
|
|
|
m = eina_file_map_all(f, EINA_FILE_WILLNEED);
|
|
|
|
if (m)
|
2012-05-15 05:29:22 -07:00
|
|
|
{
|
2012-05-20 00:06:57 -07:00
|
|
|
bytes = eet_write(sw->ef, sndid_str, m, eina_file_size_get(f),
|
|
|
|
EET_COMPRESSION_NONE);
|
|
|
|
if (eina_file_map_faulted(f, m))
|
|
|
|
{
|
2012-07-31 15:42:03 -07:00
|
|
|
ERR("File access error when reading '%s'",
|
|
|
|
eina_file_filename_get(f));
|
2012-05-20 00:06:57 -07:00
|
|
|
exit(-1);
|
|
|
|
}
|
|
|
|
eina_file_map_free(f, m);
|
2012-05-15 05:29:22 -07:00
|
|
|
}
|
2012-05-20 00:06:57 -07:00
|
|
|
eina_file_close(f);
|
|
|
|
|
2011-11-04 05:18:13 -07:00
|
|
|
#ifdef HAVE_LIBSNDFILE
|
2012-05-15 05:29:22 -07:00
|
|
|
//If encoded temporary file, delete it.
|
|
|
|
if (enc_info->encoded) unlink(enc_info->file);
|
2011-11-04 05:18:13 -07:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_LIBSNDFILE
|
2012-07-31 15:42:03 -07:00
|
|
|
INF("Wrote %9i bytes (%4iKb) for \"%s\" %s sound entry \"%s\"",
|
|
|
|
bytes, (bytes + 512) / 1024,
|
|
|
|
sndid_str, enc_info->comp_type, sw->sample->name);
|
2011-11-04 05:18:13 -07:00
|
|
|
#else
|
2012-07-31 15:42:03 -07:00
|
|
|
INF("Wrote %9i bytes (%4iKb) for \"%s\" %s sound entry \"%s\"",
|
|
|
|
bytes, (bytes + 512) / 1024,
|
|
|
|
sndid_str, "RAW PCM", sw->sample->name);
|
2011-11-04 05:18:13 -07:00
|
|
|
#endif
|
2012-07-31 15:42:03 -07:00
|
|
|
|
2011-11-04 05:18:13 -07:00
|
|
|
#ifdef HAVE_LIBSNDFILE
|
2012-05-15 05:29:22 -07:00
|
|
|
if ((enc_info->file) && (!enc_info->encoded))
|
|
|
|
eina_stringshare_del(enc_info->file);
|
|
|
|
if (enc_info) free(enc_info);
|
|
|
|
enc_info = NULL;
|
2011-11-04 05:18:13 -07:00
|
|
|
#endif
|
2012-05-15 05:29:22 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
data_thread_sounds_end(void *data, Ecore_Thread *thread __UNUSED__)
|
|
|
|
{
|
|
|
|
Sound_Write *sw = data;
|
|
|
|
pending_threads--;
|
|
|
|
if (pending_threads <= 0) ecore_main_loop_quit();
|
|
|
|
free(sw);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
data_write_sounds(Eet_File *ef, int *sound_num)
|
|
|
|
{
|
|
|
|
if ((edje_file) && (edje_file->sound_dir))
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < (int)edje_file->sound_dir->samples_count; i++)
|
|
|
|
{
|
|
|
|
Sound_Write *sw;
|
2012-08-23 00:54:58 -07:00
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
sw = calloc(1, sizeof(Sound_Write));
|
|
|
|
if (!sw) continue;
|
|
|
|
sw->ef = ef;
|
|
|
|
sw->sample = &edje_file->sound_dir->samples[i];
|
|
|
|
sw->i = i;
|
|
|
|
*sound_num += 1;
|
|
|
|
pending_threads++;
|
2012-05-16 00:43:14 -07:00
|
|
|
if (threads)
|
|
|
|
ecore_thread_run(data_thread_sounds, data_thread_sounds_end, NULL, sw);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
data_thread_sounds(sw, NULL);
|
|
|
|
data_thread_sounds_end(sw, NULL);
|
|
|
|
}
|
2011-11-04 05:18:13 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-08-20 20:57:20 -07:00
|
|
|
static void
|
|
|
|
check_groups(Eet_File *ef)
|
|
|
|
{
|
2010-08-15 11:14:33 -07:00
|
|
|
Edje_Part_Collection *pc;
|
2008-10-22 04:34:42 -07:00
|
|
|
Eina_List *l;
|
2008-08-20 20:57:20 -07:00
|
|
|
|
2004-10-23 10:33:27 -07:00
|
|
|
/* sanity checks for parts and programs */
|
2008-10-22 04:34:42 -07:00
|
|
|
EINA_LIST_FOREACH(edje_collections, l, pc)
|
2003-06-16 06:55:13 -07:00
|
|
|
{
|
2010-08-15 11:14:33 -07:00
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
for (i = 0; i < pc->parts_count; ++i)
|
|
|
|
check_part(pc, pc->parts[i], ef);
|
2008-10-22 04:34:42 -07:00
|
|
|
|
2010-08-15 11:14:33 -07:00
|
|
|
#define CHECK_PROGRAM(Type, Pc, It) \
|
|
|
|
for (It = 0; It < Pc->programs.Type ## _count; ++It) \
|
|
|
|
check_program(Pc, Pc->programs.Type[i], ef); \
|
|
|
|
|
|
|
|
CHECK_PROGRAM(fnmatch, pc, i);
|
|
|
|
CHECK_PROGRAM(strcmp, pc, i);
|
|
|
|
CHECK_PROGRAM(strncmp, pc, i);
|
|
|
|
CHECK_PROGRAM(strrncmp, pc, i);
|
|
|
|
CHECK_PROGRAM(nocmp, pc, i);
|
2004-01-22 18:13:42 -08:00
|
|
|
}
|
2008-08-20 20:57:20 -07:00
|
|
|
}
|
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
static void
|
|
|
|
data_thread_group(void *data, Ecore_Thread *thread __UNUSED__)
|
|
|
|
{
|
|
|
|
Group_Write *gw = data;
|
|
|
|
int bytes;
|
|
|
|
char buf[PATH_MAX];
|
|
|
|
char buf2[PATH_MAX];
|
|
|
|
|
|
|
|
snprintf(buf, sizeof(buf), "edje/collections/%i", gw->pc->id);
|
|
|
|
bytes = eet_data_write(gw->ef, edd_edje_part_collection, buf, gw->pc,
|
|
|
|
compress_mode);
|
|
|
|
return;
|
|
|
|
if (bytes <= 0)
|
|
|
|
{
|
|
|
|
snprintf(buf2, sizeof(buf2),
|
2012-07-31 15:42:03 -07:00
|
|
|
"Unable to write \"%s\" part entry to %s",
|
2012-05-15 05:29:22 -07:00
|
|
|
buf, file_out);
|
|
|
|
gw->errstr = strdup(buf2);
|
|
|
|
return;
|
|
|
|
}
|
2012-07-31 15:42:03 -07:00
|
|
|
|
|
|
|
INF("Wrote %9i bytes (%4iKb) for \"%s\" aka \"%s\" collection entry",
|
|
|
|
bytes, (bytes + 512) / 1024, buf, gw->pc->part);
|
2012-05-15 05:29:22 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
data_thread_group_end(void *data, Ecore_Thread *thread __UNUSED__)
|
|
|
|
{
|
|
|
|
Group_Write *gw = data;
|
|
|
|
pending_threads--;
|
|
|
|
if (pending_threads <= 0) ecore_main_loop_quit();
|
|
|
|
if (gw->errstr)
|
|
|
|
{
|
|
|
|
error_and_abort(gw->ef, gw->errstr);
|
|
|
|
free(gw->errstr);
|
|
|
|
}
|
|
|
|
free(gw);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2008-08-20 20:57:20 -07:00
|
|
|
data_write_groups(Eet_File *ef, int *collection_num)
|
|
|
|
{
|
2008-10-22 04:34:42 -07:00
|
|
|
Eina_List *l;
|
2010-08-09 10:34:03 -07:00
|
|
|
Edje_Part_Collection *pc;
|
2008-08-20 20:57:20 -07:00
|
|
|
|
2008-10-22 04:34:42 -07:00
|
|
|
EINA_LIST_FOREACH(edje_collections, l, pc)
|
2004-01-22 18:13:42 -08:00
|
|
|
{
|
2012-05-15 05:29:22 -07:00
|
|
|
Group_Write *gw;
|
2008-08-20 20:58:11 -07:00
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
gw = calloc(1, sizeof(Group_Write));
|
|
|
|
if (!gw)
|
|
|
|
{
|
2012-07-31 15:42:03 -07:00
|
|
|
error_and_abort(ef, "Cannot allocate memory for group writer");
|
2012-05-15 05:29:22 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
gw->ef = ef;
|
|
|
|
gw->pc = pc;
|
|
|
|
pending_threads++;
|
2012-05-16 00:43:14 -07:00
|
|
|
if (threads)
|
|
|
|
ecore_thread_run(data_thread_group, data_thread_group_end, NULL, gw);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
data_thread_group(gw, NULL);
|
|
|
|
data_thread_group_end(gw, NULL);
|
|
|
|
}
|
2012-05-15 05:29:22 -07:00
|
|
|
*collection_num += 1;
|
2003-06-16 06:55:13 -07:00
|
|
|
}
|
2008-08-20 20:57:20 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-06-14 00:02:14 -07:00
|
|
|
create_script_file(Eet_File *ef, const char *filename, const Code *cd, int fd)
|
2008-08-20 20:57:20 -07:00
|
|
|
{
|
2011-06-14 00:02:14 -07:00
|
|
|
FILE *f = fdopen(fd, "wb");
|
2008-08-20 20:57:56 -07:00
|
|
|
if (!f)
|
2008-08-20 20:58:11 -07:00
|
|
|
error_and_abort(ef, "Unable to open temp file \"%s\" for script "
|
2012-07-31 15:42:03 -07:00
|
|
|
"compilation.", filename);
|
2008-08-20 20:57:20 -07:00
|
|
|
|
2008-10-22 04:34:42 -07:00
|
|
|
Eina_List *ll;
|
|
|
|
Code_Program *cp;
|
2008-08-20 20:57:56 -07:00
|
|
|
|
|
|
|
fprintf(f, "#include <edje>\n");
|
|
|
|
int ln = 2;
|
|
|
|
|
|
|
|
if (cd->shared)
|
|
|
|
{
|
|
|
|
while (ln < (cd->l1 - 1))
|
|
|
|
{
|
|
|
|
fprintf(f, " \n");
|
|
|
|
ln++;
|
|
|
|
}
|
|
|
|
{
|
|
|
|
char *sp;
|
|
|
|
int hash = 0;
|
|
|
|
int newlined = 0;
|
|
|
|
|
|
|
|
for (sp = cd->shared; *sp; sp++)
|
|
|
|
{
|
|
|
|
if ((sp[0] == '#') && (newlined))
|
|
|
|
{
|
|
|
|
hash = 1;
|
|
|
|
}
|
|
|
|
newlined = 0;
|
|
|
|
if (sp[0] == '\n') newlined = 1;
|
|
|
|
if (!hash) fputc(sp[0], f);
|
|
|
|
else if (sp[0] == '\n') hash = 0;
|
|
|
|
}
|
|
|
|
fputc('\n', f);
|
|
|
|
}
|
|
|
|
ln += cd->l2 - cd->l1 + 1;
|
|
|
|
}
|
2008-10-22 04:34:42 -07:00
|
|
|
EINA_LIST_FOREACH(cd->programs, ll, cp)
|
2008-08-20 20:57:56 -07:00
|
|
|
{
|
|
|
|
if (cp->script)
|
|
|
|
{
|
|
|
|
while (ln < (cp->l1 - 1))
|
|
|
|
{
|
|
|
|
fprintf(f, " \n");
|
|
|
|
ln++;
|
|
|
|
}
|
|
|
|
/* FIXME: this prototype needs to be */
|
|
|
|
/* formalised and set in stone */
|
|
|
|
fprintf(f, "public _p%i(sig[], src[]) {", cp->id);
|
|
|
|
{
|
|
|
|
char *sp;
|
|
|
|
int hash = 0;
|
|
|
|
int newlined = 0;
|
|
|
|
|
|
|
|
for (sp = cp->script; *sp; sp++)
|
|
|
|
{
|
|
|
|
if ((sp[0] == '#') && (newlined))
|
|
|
|
{
|
|
|
|
hash = 1;
|
|
|
|
}
|
|
|
|
newlined = 0;
|
|
|
|
if (sp[0] == '\n') newlined = 1;
|
|
|
|
if (!hash) fputc(sp[0], f);
|
|
|
|
else if (sp[0] == '\n') hash = 0;
|
|
|
|
}
|
|
|
|
}
|
2011-05-16 05:16:54 -07:00
|
|
|
fprintf(f, "}\n");
|
2008-08-20 20:57:56 -07:00
|
|
|
ln += cp->l2 - cp->l1 + 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fclose(f);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-05-15 05:29:22 -07:00
|
|
|
data_thread_script(void *data, Ecore_Thread *thread __UNUSED__)
|
2008-08-20 20:57:56 -07:00
|
|
|
{
|
2012-05-15 19:15:45 -07:00
|
|
|
Script_Write *sc = data;
|
2008-08-20 20:57:56 -07:00
|
|
|
FILE *f;
|
2012-05-15 05:29:22 -07:00
|
|
|
int size;
|
|
|
|
char buf[PATH_MAX];
|
2007-08-26 05:54:51 -07:00
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
f = fdopen(sc->tmpo_fd, "rb");
|
2008-08-20 20:57:56 -07:00
|
|
|
if (!f)
|
2012-05-15 05:29:22 -07:00
|
|
|
{
|
|
|
|
snprintf(buf, sizeof(buf),
|
2012-07-31 15:42:03 -07:00
|
|
|
"Unable to open script object \"%s\" for reading.",
|
2012-05-15 05:29:22 -07:00
|
|
|
sc->tmpo);
|
|
|
|
sc->errstr = strdup(buf);
|
|
|
|
return;
|
|
|
|
}
|
2008-08-20 20:57:56 -07:00
|
|
|
|
|
|
|
fseek(f, 0, SEEK_END);
|
2012-05-15 05:29:22 -07:00
|
|
|
size = ftell(f);
|
2008-08-20 20:57:56 -07:00
|
|
|
rewind(f);
|
|
|
|
|
|
|
|
if (size > 0)
|
|
|
|
{
|
2012-05-15 05:29:22 -07:00
|
|
|
void *dat = malloc(size);
|
2008-08-20 20:57:56 -07:00
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
if (dat)
|
2004-03-27 21:26:17 -08:00
|
|
|
{
|
2012-05-15 05:29:22 -07:00
|
|
|
if (fread(dat, size, 1, f) != 1)
|
|
|
|
{
|
|
|
|
snprintf(buf, sizeof(buf),
|
2012-07-31 15:42:03 -07:00
|
|
|
"Unable to read all of script object \"%s\"",
|
2012-05-15 05:29:22 -07:00
|
|
|
sc->tmpo);
|
|
|
|
sc->errstr = strdup(buf);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
snprintf(buf, sizeof(buf), "edje/scripts/embryo/compiled/%i",
|
|
|
|
sc->i);
|
|
|
|
eet_write(sc->ef, buf, dat, size, compress_mode);
|
|
|
|
free(dat);
|
2008-08-20 20:57:56 -07:00
|
|
|
}
|
2012-05-15 05:29:22 -07:00
|
|
|
else
|
|
|
|
{
|
|
|
|
snprintf(buf, sizeof(buf),
|
2012-07-31 15:42:03 -07:00
|
|
|
"Alloc failed for %lu bytes", (unsigned long)size);
|
2012-05-15 05:29:22 -07:00
|
|
|
sc->errstr = strdup(buf);
|
|
|
|
return;
|
|
|
|
}
|
2008-08-20 20:57:56 -07:00
|
|
|
}
|
|
|
|
fclose(f);
|
2012-05-15 05:29:22 -07:00
|
|
|
|
|
|
|
if (!no_save)
|
|
|
|
{
|
|
|
|
Eina_List *ll;
|
|
|
|
Code_Program *cp;
|
2012-08-23 00:54:58 -07:00
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
if (sc->cd->original)
|
|
|
|
{
|
|
|
|
snprintf(buf, PATH_MAX, "edje/scripts/embryo/source/%i", sc->i);
|
|
|
|
eet_write(sc->ef, buf, sc->cd->original,
|
|
|
|
strlen(sc->cd->original) + 1, compress_mode);
|
|
|
|
}
|
|
|
|
EINA_LIST_FOREACH(sc->cd->programs, ll, cp)
|
|
|
|
{
|
|
|
|
if (!cp->original) continue;
|
|
|
|
snprintf(buf, PATH_MAX, "edje/scripts/embryo/source/%i/%i",
|
|
|
|
sc->i, cp->id);
|
|
|
|
eet_write(sc->ef, buf, cp->original,
|
|
|
|
strlen(cp->original) + 1, compress_mode);
|
|
|
|
}
|
|
|
|
}
|
2012-08-23 00:54:58 -07:00
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
unlink(sc->tmpn);
|
|
|
|
unlink(sc->tmpo);
|
|
|
|
close(sc->tmpn_fd);
|
|
|
|
close(sc->tmpo_fd);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
data_thread_script_end(void *data, Ecore_Thread *thread __UNUSED__)
|
|
|
|
{
|
2012-05-15 19:15:45 -07:00
|
|
|
Script_Write *sc = data;
|
2012-05-15 05:29:22 -07:00
|
|
|
pending_threads--;
|
|
|
|
if (pending_threads <= 0) ecore_main_loop_quit();
|
|
|
|
if (sc->errstr)
|
|
|
|
{
|
|
|
|
error_and_abort(sc->ef, sc->errstr);
|
|
|
|
free(sc->errstr);
|
|
|
|
}
|
|
|
|
free(sc);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
data_scripts_exe_del_cb(void *data __UNUSED__, int evtype __UNUSED__, void *evinfo)
|
|
|
|
{
|
2012-05-15 19:15:45 -07:00
|
|
|
Script_Write *sc = data;
|
2012-05-15 05:29:22 -07:00
|
|
|
Ecore_Exe_Event_Del *ev = evinfo;
|
2012-05-23 22:37:36 -07:00
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
if (!ev->exe) return ECORE_CALLBACK_RENEW;
|
|
|
|
if (ecore_exe_data_get(ev->exe) != sc) return ECORE_CALLBACK_RENEW;
|
|
|
|
if (ev->exit_code != 0)
|
|
|
|
{
|
2012-07-31 15:42:03 -07:00
|
|
|
error_and_abort(sc->ef, "Compiling script code not clean.");
|
2012-05-15 05:29:22 -07:00
|
|
|
return ECORE_CALLBACK_CANCEL;
|
|
|
|
}
|
2012-05-16 00:43:14 -07:00
|
|
|
if (threads)
|
2012-05-23 22:37:36 -07:00
|
|
|
{
|
|
|
|
pending_threads++;
|
|
|
|
ecore_thread_run(data_thread_script, data_thread_script_end, NULL, sc);
|
|
|
|
}
|
2012-05-16 00:43:14 -07:00
|
|
|
else
|
|
|
|
{
|
2012-05-23 22:37:36 -07:00
|
|
|
pending_threads++;
|
2012-05-16 00:43:14 -07:00
|
|
|
data_thread_script(sc, NULL);
|
|
|
|
data_thread_script_end(sc, NULL);
|
|
|
|
}
|
2012-05-23 22:37:36 -07:00
|
|
|
pending_threads--;
|
|
|
|
if (pending_threads <= 0) ecore_main_loop_quit();
|
2012-05-15 05:29:22 -07:00
|
|
|
return ECORE_CALLBACK_CANCEL;
|
2008-08-20 20:57:56 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
data_write_scripts(Eet_File *ef)
|
|
|
|
{
|
2008-10-22 04:34:42 -07:00
|
|
|
Eina_List *l;
|
2008-08-20 20:57:56 -07:00
|
|
|
int i;
|
2008-06-06 11:31:49 -07:00
|
|
|
|
2009-08-25 10:25:23 -07:00
|
|
|
if (!tmp_dir)
|
2008-06-06 11:31:49 -07:00
|
|
|
#ifdef HAVE_EVIL
|
2009-10-25 04:40:06 -07:00
|
|
|
tmp_dir = (char *)evil_tmpdir_get();
|
2007-08-26 05:54:51 -07:00
|
|
|
#else
|
2009-08-25 10:25:23 -07:00
|
|
|
tmp_dir = "/tmp";
|
2008-06-06 11:31:49 -07:00
|
|
|
#endif
|
2007-08-26 05:54:51 -07:00
|
|
|
|
2008-10-22 04:34:42 -07:00
|
|
|
for (i = 0, l = codes; l; l = eina_list_next(l), i++)
|
2008-08-20 20:57:56 -07:00
|
|
|
{
|
2008-10-22 04:34:42 -07:00
|
|
|
Code *cd = eina_list_data_get(l);
|
2012-05-15 19:15:45 -07:00
|
|
|
Script_Write *sc;
|
2012-05-15 05:29:22 -07:00
|
|
|
char buf[PATH_MAX];
|
2011-10-09 19:49:50 -07:00
|
|
|
|
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 (cd->is_lua)
|
|
|
|
continue;
|
2008-08-20 20:57:56 -07:00
|
|
|
if ((!cd->shared) && (!cd->programs))
|
|
|
|
continue;
|
2012-05-15 19:15:45 -07:00
|
|
|
sc = calloc(1, sizeof(Script_Write));
|
2012-05-15 05:29:22 -07:00
|
|
|
sc->ef = ef;
|
|
|
|
sc->cd = cd;
|
|
|
|
sc->i = i;
|
|
|
|
snprintf(sc->tmpn, PATH_MAX, "%s/edje_cc.sma-tmp-XXXXXX", tmp_dir);
|
|
|
|
sc->tmpn_fd = mkstemp(sc->tmpn);
|
|
|
|
if (sc->tmpn_fd < 0)
|
|
|
|
error_and_abort(ef, "Unable to open temp file \"%s\" for script "
|
2012-07-31 15:42:03 -07:00
|
|
|
"compilation.", sc->tmpn);
|
2012-05-15 05:29:22 -07:00
|
|
|
snprintf(sc->tmpo, PATH_MAX, "%s/edje_cc.amx-tmp-XXXXXX", tmp_dir);
|
|
|
|
sc->tmpo_fd = mkstemp(sc->tmpo);
|
|
|
|
if (sc->tmpo_fd < 0)
|
2010-11-30 07:37:20 -08:00
|
|
|
{
|
2012-05-15 05:29:22 -07:00
|
|
|
unlink(sc->tmpn);
|
|
|
|
error_and_abort(ef, "Unable to open temp file \"%s\" for script "
|
2012-07-31 15:42:03 -07:00
|
|
|
"compilation.", sc->tmpn);
|
2010-11-30 07:37:20 -08:00
|
|
|
}
|
2012-05-15 05:29:22 -07:00
|
|
|
create_script_file(ef, sc->tmpn, cd, sc->tmpn_fd);
|
|
|
|
snprintf(buf, sizeof(buf),
|
2012-06-21 01:55:38 -07:00
|
|
|
"%s/embryo_cc -i %s/include -o %s %s",
|
2012-08-23 00:54:58 -07:00
|
|
|
eina_prefix_bin_get(pfx),
|
2012-06-21 01:55:38 -07:00
|
|
|
eina_prefix_data_get(pfx),
|
|
|
|
sc->tmpo, sc->tmpn);
|
2012-05-23 22:37:36 -07:00
|
|
|
pending_threads++;
|
2012-05-15 05:29:22 -07:00
|
|
|
sc->exe = ecore_exe_run(buf, sc);
|
|
|
|
ecore_event_handler_add(ECORE_EXE_EVENT_DEL,
|
|
|
|
data_scripts_exe_del_cb, sc);
|
2004-03-27 21:26:17 -08:00
|
|
|
}
|
2008-08-20 20:57:20 -07:00
|
|
|
}
|
|
|
|
|
2009-10-25 04:40:06 -07:00
|
|
|
#ifdef LUA_BINARY
|
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
|
|
|
static int
|
2010-08-24 18:09:44 -07:00
|
|
|
_edje_lua_script_writer(lua_State *L __UNUSED__, const void *chunk_buf, size_t chunk_size, void *_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
|
|
|
{
|
2012-05-15 19:15:45 -07:00
|
|
|
Script_Lua_Writer *data;
|
2009-10-25 04:40:06 -07:00
|
|
|
void *old;
|
2009-10-25 04:24:55 -07:00
|
|
|
|
2012-05-15 19:15:45 -07:00
|
|
|
data = (Script_Lua_Writer *)_data;
|
2009-10-25 04:40:06 -07:00
|
|
|
old = data->buf;
|
2012-05-15 05:29:22 -07:00
|
|
|
data->buf = malloc(data->size + chunk_size);
|
|
|
|
memcpy(data->buf, old, data->size);
|
|
|
|
memcpy(&((data->buf)[data->size]), chunk_buf, chunk_size);
|
|
|
|
if (old) free(old);
|
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->size += chunk_size;
|
2009-10-25 04:40:06 -07:00
|
|
|
|
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
|
|
|
return 0;
|
|
|
|
}
|
2009-10-25 04:40:06 -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
|
|
|
|
|
|
|
void
|
2012-05-15 19:15:45 -07:00
|
|
|
_edje_lua_error_and_abort(lua_State *L, int err_code, Script_Write *sc)
|
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
|
|
|
{
|
2012-05-15 05:29:22 -07:00
|
|
|
char buf[PATH_MAX];
|
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
|
|
|
char *err_type;
|
2012-08-23 00:54:58 -07:00
|
|
|
|
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
|
|
|
switch (err_code)
|
|
|
|
{
|
2012-05-15 05:29:22 -07:00
|
|
|
case LUA_ERRRUN:
|
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
|
|
|
err_type = "runtime";
|
|
|
|
break;
|
2012-05-15 05:29:22 -07:00
|
|
|
case LUA_ERRSYNTAX:
|
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
|
|
|
err_type = "syntax";
|
|
|
|
break;
|
2012-05-15 05:29:22 -07:00
|
|
|
case LUA_ERRMEM:
|
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
|
|
|
err_type = "memory allocation";
|
|
|
|
break;
|
2012-05-15 05:29:22 -07:00
|
|
|
case LUA_ERRERR:
|
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
|
|
|
err_type = "error handler";
|
|
|
|
break;
|
2012-05-15 05:29:22 -07:00
|
|
|
default:
|
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
|
|
|
err_type = "unknown";
|
|
|
|
break;
|
|
|
|
}
|
2012-05-15 05:29:22 -07:00
|
|
|
snprintf(buf, sizeof(buf),
|
2012-07-31 15:42:03 -07:00
|
|
|
"Lua %s error: %s", err_type, lua_tostring(L, -1));
|
2012-05-15 05:29:22 -07:00
|
|
|
sc->errstr = strdup(buf);
|
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
|
|
|
}
|
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
static void
|
|
|
|
data_thread_lua_script(void *data, Ecore_Thread *thread __UNUSED__)
|
|
|
|
{
|
2012-05-15 19:15:45 -07:00
|
|
|
Script_Write *sc = data;
|
2012-05-15 05:29:22 -07:00
|
|
|
char buf[PATH_MAX];
|
|
|
|
lua_State *L;
|
|
|
|
int ln = 1;
|
|
|
|
luaL_Buffer b;
|
2012-05-15 19:15:45 -07:00
|
|
|
Script_Lua_Writer dat;
|
2012-05-15 05:29:22 -07:00
|
|
|
Eina_List *ll;
|
|
|
|
Code_Program *cp;
|
|
|
|
#ifdef LUA_BINARY
|
|
|
|
int err_code;
|
|
|
|
#endif
|
2012-08-23 00:54:58 -07:00
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
L = luaL_newstate();
|
|
|
|
if (!L)
|
|
|
|
{
|
|
|
|
snprintf(buf, sizeof(buf),
|
2012-07-31 15:42:03 -07:00
|
|
|
"Lua error: Lua state could not be initialized");
|
2012-05-15 05:29:22 -07:00
|
|
|
sc->errstr = strdup(buf);
|
|
|
|
return;
|
|
|
|
}
|
2012-08-23 00:54:58 -07:00
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
luaL_buffinit(L, &b);
|
2012-08-23 00:54:58 -07:00
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
dat.buf = NULL;
|
|
|
|
dat.size = 0;
|
|
|
|
if (sc->cd->shared)
|
|
|
|
{
|
|
|
|
while (ln < (sc->cd->l1 - 1))
|
|
|
|
{
|
|
|
|
luaL_addchar(&b, '\n');
|
|
|
|
ln++;
|
|
|
|
}
|
|
|
|
luaL_addstring(&b, sc->cd->shared);
|
|
|
|
ln += sc->cd->l2 - sc->cd->l1;
|
|
|
|
}
|
2012-08-23 00:54:58 -07:00
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
EINA_LIST_FOREACH(sc->cd->programs, ll, cp)
|
|
|
|
{
|
|
|
|
if (cp->script)
|
|
|
|
{
|
|
|
|
while (ln < (cp->l1 - 1))
|
|
|
|
{
|
|
|
|
luaL_addchar(&b, '\n');
|
|
|
|
ln++;
|
|
|
|
}
|
|
|
|
luaL_addstring(&b, "_G[");
|
|
|
|
lua_pushnumber(L, cp->id);
|
|
|
|
luaL_addvalue(&b);
|
|
|
|
luaL_addstring(&b, "] = function (ed, signal, source)");
|
|
|
|
luaL_addstring(&b, cp->script);
|
|
|
|
luaL_addstring(&b, "end\n");
|
|
|
|
ln += cp->l2 - cp->l1 + 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
luaL_pushresult(&b);
|
|
|
|
#ifdef LUA_BINARY
|
|
|
|
if (err_code = luaL_loadstring(L, lua_tostring (L, -1)))
|
|
|
|
{
|
|
|
|
_edje_lua_error_and_abort(L, err_code, sc);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
lua_dump(L, _edje_lua_script_writer, &dat);
|
|
|
|
#else // LUA_PLAIN_TEXT
|
|
|
|
dat.buf = (char *)lua_tostring(L, -1);
|
|
|
|
dat.size = strlen(dat.buf);
|
|
|
|
#endif
|
|
|
|
//printf("lua chunk size: %d\n", dat.size);
|
2012-08-23 00:54:58 -07:00
|
|
|
|
|
|
|
/*
|
2012-05-15 05:29:22 -07:00
|
|
|
* TODO load and test Lua chunk
|
|
|
|
*/
|
2012-08-23 00:54:58 -07:00
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
/*
|
|
|
|
if (luaL_loadbuffer(L, globbuf, globbufsize, "edje_lua_script"))
|
|
|
|
printf("lua load error: %s\n", lua_tostring (L, -1));
|
|
|
|
if (lua_pcall(L, 0, 0, 0))
|
|
|
|
printf("lua call error: %s\n", lua_tostring (L, -1));
|
|
|
|
*/
|
2012-08-23 00:54:58 -07:00
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
snprintf(buf, sizeof(buf), "edje/scripts/lua/%i", sc->i);
|
|
|
|
if (eet_write(sc->ef, buf, dat.buf, dat.size, compress_mode) <= 0)
|
|
|
|
{
|
|
|
|
snprintf(buf, sizeof(buf),
|
2012-07-31 15:42:03 -07:00
|
|
|
"Unable to write script %i", sc->i);
|
2012-05-15 05:29:22 -07:00
|
|
|
sc->errstr = strdup(buf);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#ifdef LUA_BINARY
|
|
|
|
free(dat.buf);
|
|
|
|
#endif
|
|
|
|
lua_close(L);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
data_thread_lua_script_end(void *data, Ecore_Thread *thread __UNUSED__)
|
|
|
|
{
|
2012-05-15 19:15:45 -07:00
|
|
|
Script_Write *sc = data;
|
2012-05-15 05:29:22 -07:00
|
|
|
pending_threads--;
|
|
|
|
if (pending_threads <= 0) ecore_main_loop_quit();
|
|
|
|
if (sc->errstr)
|
|
|
|
{
|
|
|
|
error_and_abort(sc->ef, sc->errstr);
|
|
|
|
free(sc->errstr);
|
|
|
|
}
|
|
|
|
free(sc);
|
|
|
|
}
|
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
|
|
|
|
|
|
|
static void
|
|
|
|
data_write_lua_scripts(Eet_File *ef)
|
|
|
|
{
|
|
|
|
Eina_List *l;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0, l = codes; l; l = eina_list_next(l), i++)
|
|
|
|
{
|
2012-05-15 05:29:22 -07:00
|
|
|
Code *cd;
|
2012-05-15 19:15:45 -07:00
|
|
|
Script_Write *sc;
|
2012-08-23 00:54:58 -07:00
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
cd = (Code *)eina_list_data_get(l);
|
|
|
|
if (!cd->is_lua)
|
|
|
|
continue;
|
|
|
|
if ((!cd->shared) && (!cd->programs))
|
|
|
|
continue;
|
2012-08-23 00:54:58 -07:00
|
|
|
|
2012-05-15 19:15:45 -07:00
|
|
|
sc = calloc(1, sizeof(Script_Write));
|
2012-05-15 05:29:22 -07:00
|
|
|
sc->ef = ef;
|
|
|
|
sc->cd = cd;
|
|
|
|
sc->i = i;
|
|
|
|
pending_threads++;
|
2012-05-16 00:43:14 -07:00
|
|
|
if (threads)
|
|
|
|
ecore_thread_run(data_thread_lua_script, data_thread_lua_script_end, NULL, sc);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
data_thread_lua_script(sc, NULL);
|
|
|
|
data_thread_lua_script_end(sc, NULL);
|
|
|
|
}
|
2012-05-15 05:29:22 -07:00
|
|
|
}
|
|
|
|
}
|
2009-10-25 04:40:06 -07:00
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
static void
|
|
|
|
data_thread_source(void *data, Ecore_Thread *thread __UNUSED__)
|
|
|
|
{
|
|
|
|
Eet_File *ef = data;
|
|
|
|
source_append(ef);
|
|
|
|
}
|
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
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
static void
|
|
|
|
data_thread_source_end(void *data __UNUSED__, Ecore_Thread *thread __UNUSED__)
|
|
|
|
{
|
|
|
|
pending_threads--;
|
|
|
|
if (pending_threads <= 0) ecore_main_loop_quit();
|
|
|
|
}
|
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
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
static void
|
|
|
|
data_thread_fontmap(void *data, Ecore_Thread *thread __UNUSED__)
|
|
|
|
{
|
|
|
|
Eet_File *ef = data;
|
|
|
|
source_fontmap_save(ef, fonts);
|
|
|
|
}
|
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
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
static void
|
|
|
|
data_thread_fontmap_end(void *data __UNUSED__, Ecore_Thread *thread __UNUSED__)
|
|
|
|
{
|
|
|
|
pending_threads--;
|
|
|
|
if (pending_threads <= 0) ecore_main_loop_quit();
|
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
|
|
|
}
|
|
|
|
|
2008-08-20 20:57:20 -07:00
|
|
|
void
|
|
|
|
data_write(void)
|
|
|
|
{
|
|
|
|
Eet_File *ef;
|
|
|
|
int image_num = 0;
|
2011-11-04 05:18:13 -07:00
|
|
|
int sound_num = 0;
|
2008-08-20 20:57:20 -07:00
|
|
|
int font_num = 0;
|
|
|
|
int collection_num = 0;
|
2012-05-15 05:29:22 -07:00
|
|
|
double t;
|
2012-06-07 00:59:18 -07:00
|
|
|
|
2010-08-09 11:22:48 -07:00
|
|
|
if (!edje_file)
|
|
|
|
{
|
2012-07-31 15:42:03 -07:00
|
|
|
ERR("No data to put in \"%s\"", file_out);
|
2010-08-09 11:22:48 -07:00
|
|
|
exit(-1);
|
|
|
|
}
|
|
|
|
|
2008-08-20 20:57:20 -07:00
|
|
|
ef = eet_open(file_out, EET_FILE_MODE_WRITE);
|
|
|
|
if (!ef)
|
|
|
|
{
|
2012-07-31 15:42:03 -07:00
|
|
|
ERR("Unable to open \"%s\" for writing output", file_out);
|
2008-08-20 20:57:20 -07:00
|
|
|
exit(-1);
|
|
|
|
}
|
|
|
|
|
2010-08-09 10:34:03 -07:00
|
|
|
check_groups(ef);
|
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
ecore_thread_max_set(ecore_thread_max_get() * 2);
|
2012-05-20 00:06:57 -07:00
|
|
|
|
2012-05-23 22:37:36 -07:00
|
|
|
pending_threads++;
|
2012-05-15 05:29:22 -07:00
|
|
|
t = ecore_time_get();
|
|
|
|
data_write_header(ef);
|
2012-07-31 15:42:03 -07:00
|
|
|
|
|
|
|
INF("header: %3.5f", ecore_time_get() - t); t = ecore_time_get();
|
2012-05-15 05:29:22 -07:00
|
|
|
data_write_groups(ef, &collection_num);
|
2012-07-31 15:42:03 -07:00
|
|
|
INF("groups: %3.5f", ecore_time_get() - t); t = ecore_time_get();
|
2008-08-20 20:57:20 -07:00
|
|
|
data_write_scripts(ef);
|
2012-07-31 15:42:03 -07:00
|
|
|
INF("scripts: %3.5f", ecore_time_get() - t); t = ecore_time_get();
|
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_write_lua_scripts(ef);
|
2012-07-31 15:42:03 -07:00
|
|
|
INF("lua scripts: %3.5f", ecore_time_get() - t); t = ecore_time_get();
|
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
pending_threads++;
|
2012-05-16 00:43:14 -07:00
|
|
|
if (threads)
|
|
|
|
ecore_thread_run(data_thread_source, data_thread_source_end, NULL, ef);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
data_thread_source(ef, NULL);
|
|
|
|
data_thread_source_end(ef, NULL);
|
|
|
|
}
|
2012-07-31 15:42:03 -07:00
|
|
|
INF("source: %3.5f", ecore_time_get() - t); t = ecore_time_get();
|
2012-05-15 05:29:22 -07:00
|
|
|
pending_threads++;
|
2012-05-16 00:43:14 -07:00
|
|
|
if (threads)
|
|
|
|
ecore_thread_run(data_thread_fontmap, data_thread_fontmap_end, NULL, ef);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
data_thread_fontmap(ef, NULL);
|
|
|
|
data_thread_fontmap_end(ef, NULL);
|
|
|
|
}
|
2012-07-31 15:42:03 -07:00
|
|
|
INF("fontmap: %3.5f", ecore_time_get() - t); t = ecore_time_get();
|
2012-05-15 05:29:22 -07:00
|
|
|
data_write_images(ef, &image_num);
|
2012-07-31 15:42:03 -07:00
|
|
|
INF("images: %3.5f", ecore_time_get() - t); t = ecore_time_get();
|
2012-05-15 05:29:22 -07:00
|
|
|
data_write_fonts(ef, &font_num);
|
2012-07-31 15:42:03 -07:00
|
|
|
INF("fonts: %3.5f", ecore_time_get() - t); t = ecore_time_get();
|
2012-05-15 05:29:22 -07:00
|
|
|
data_write_sounds(ef, &sound_num);
|
2012-07-31 15:42:03 -07:00
|
|
|
INF("sounds: %3.5f", ecore_time_get() - t); t = ecore_time_get();
|
2012-05-23 22:37:36 -07:00
|
|
|
pending_threads--;
|
2012-05-30 05:51:21 -07:00
|
|
|
if (pending_threads > 0) ecore_main_loop_begin();
|
2012-07-31 15:42:03 -07:00
|
|
|
INF("THREADS: %3.5f", ecore_time_get() - t); t = ecore_time_get();
|
2012-05-16 00:43:14 -07:00
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
eet_close(ef);
|
|
|
|
|
2012-07-31 15:42:03 -07:00
|
|
|
if (eina_log_domain_level_check(_edje_cc_log_dom, EINA_LOG_LEVEL_INFO))
|
|
|
|
{
|
|
|
|
printf("Summary:\n"
|
|
|
|
" Wrote %i collections\n"
|
|
|
|
" Wrote %i images\n"
|
|
|
|
" Wrote %i sounds\n"
|
|
|
|
" Wrote %i fonts\n"
|
|
|
|
,
|
|
|
|
collection_num,
|
|
|
|
image_num,
|
|
|
|
sound_num,
|
|
|
|
font_num);
|
|
|
|
}
|
2003-06-11 06:20:48 -07:00
|
|
|
}
|
2003-06-13 20:06:36 -07:00
|
|
|
|
2011-09-28 18:29:21 -07:00
|
|
|
void
|
|
|
|
reorder_parts(void)
|
|
|
|
{
|
|
|
|
Edje_Part_Collection *pc;
|
|
|
|
Edje_Part **parts;
|
|
|
|
Edje_Part_Parser *ep, *ep2;
|
|
|
|
Eina_List *l;
|
|
|
|
|
|
|
|
/* sanity checks for parts and programs */
|
|
|
|
EINA_LIST_FOREACH(edje_collections, l, pc)
|
|
|
|
{
|
|
|
|
unsigned int i, j, k;
|
|
|
|
Eina_Bool found = EINA_FALSE;
|
|
|
|
|
|
|
|
for (i = 0; i < pc->parts_count; i++)
|
|
|
|
{
|
|
|
|
ep = (Edje_Part_Parser *)pc->parts[i];
|
|
|
|
if (ep->reorder.insert_before && ep->reorder.insert_after)
|
2012-07-31 15:42:03 -07:00
|
|
|
ERR("Unable to use together insert_before and insert_after in part \"%s\".", pc->parts[i]->name);
|
2011-09-28 18:29:21 -07:00
|
|
|
|
|
|
|
if (ep->reorder.done)
|
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (ep->reorder.insert_before || ep->reorder.insert_after)
|
|
|
|
{
|
|
|
|
found = EINA_FALSE;
|
|
|
|
for (j = 0; j < pc->parts_count; j++)
|
|
|
|
{
|
|
|
|
if (ep->reorder.insert_before &&
|
|
|
|
!strcmp(ep->reorder.insert_before, pc->parts[j]->name))
|
|
|
|
{
|
|
|
|
ep2 = (Edje_Part_Parser *)pc->parts[j];
|
|
|
|
if (ep2->reorder.after)
|
2012-07-31 15:42:03 -07:00
|
|
|
ERR("The part \"%s\" is ambiguous ordered part.",
|
|
|
|
pc->parts[i]->name);
|
2011-09-28 18:29:21 -07:00
|
|
|
if (ep2->reorder.linked_prev)
|
2012-07-31 15:42:03 -07:00
|
|
|
ERR("Unable to insert two or more parts in same part \"%s\".",
|
|
|
|
pc->parts[j]->name);
|
2011-09-28 18:29:21 -07:00
|
|
|
k = j - 1;
|
|
|
|
found = EINA_TRUE;
|
|
|
|
ep2->reorder.linked_prev += ep->reorder.linked_prev + 1;
|
|
|
|
ep->reorder.before = (Edje_Part_Parser *)pc->parts[j];
|
|
|
|
while (ep2->reorder.before)
|
|
|
|
{
|
|
|
|
ep2->reorder.before->reorder.linked_prev = ep2->reorder.linked_prev + 1;
|
|
|
|
ep2 = ep2->reorder.before;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
else if (ep->reorder.insert_after &&
|
|
|
|
!strcmp(ep->reorder.insert_after, pc->parts[j]->name))
|
|
|
|
{
|
|
|
|
ep2 = (Edje_Part_Parser *)pc->parts[j];
|
|
|
|
if (ep2->reorder.before)
|
2012-07-31 15:42:03 -07:00
|
|
|
ERR("The part \"%s\" is ambiguous ordered part.", pc->parts[i]->name);
|
2011-09-28 18:29:21 -07:00
|
|
|
if (ep2->reorder.linked_next)
|
2012-07-31 15:42:03 -07:00
|
|
|
ERR("Unable to insert two or more parts in same part \"%s\".", pc->parts[j]->name);
|
2011-09-28 18:29:21 -07:00
|
|
|
k = j;
|
|
|
|
found = EINA_TRUE;
|
|
|
|
ep2->reorder.linked_next += ep->reorder.linked_next + 1;
|
|
|
|
ep->reorder.after = (Edje_Part_Parser *)pc->parts[j];
|
|
|
|
while (ep2->reorder.after)
|
|
|
|
{
|
|
|
|
ep2->reorder.after->reorder.linked_next = ep2->reorder.linked_next + 1;
|
|
|
|
ep2 = ep2->reorder.after;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (found)
|
|
|
|
{
|
|
|
|
unsigned int amount, linked;
|
|
|
|
|
|
|
|
if (((i > k) && ((i - ep->reorder.linked_prev) <= k))
|
|
|
|
|| ((i < k) && ((i + ep->reorder.linked_next) >= k)))
|
2012-07-31 15:42:03 -07:00
|
|
|
ERR("The part order is wrong. It has circular dependency.");
|
2011-09-28 18:29:21 -07:00
|
|
|
|
|
|
|
amount = ep->reorder.linked_prev + ep->reorder.linked_next + 1;
|
|
|
|
linked = i - ep->reorder.linked_prev;
|
|
|
|
parts = malloc(amount * sizeof(Edje_Part));
|
|
|
|
for (j = 0 ; j < amount ; j++)
|
|
|
|
{
|
|
|
|
parts[j] = pc->parts[linked];
|
|
|
|
linked++;
|
|
|
|
}
|
|
|
|
if (i > k)
|
|
|
|
{
|
|
|
|
for (j = i - ep->reorder.linked_prev - 1 ; j >= k ; j--)
|
|
|
|
{
|
|
|
|
pc->parts[j + amount] = pc->parts[j];
|
|
|
|
pc->parts[j + amount]->id = j + amount;
|
|
|
|
}
|
|
|
|
for (j = 0 ; j < amount ; j++)
|
|
|
|
{
|
|
|
|
pc->parts[j + k] = parts[j];
|
|
|
|
pc->parts[j + k]->id = j + k;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (i < k)
|
|
|
|
{
|
|
|
|
for (j = i + ep->reorder.linked_next + 1 ; j <= k ; j++)
|
|
|
|
{
|
|
|
|
pc->parts[j - amount] = pc->parts[j];
|
|
|
|
pc->parts[j - amount]->id = j - amount;
|
|
|
|
}
|
|
|
|
for (j = 0 ; j < amount ; j++)
|
|
|
|
{
|
|
|
|
pc->parts[j + k - amount + 1] = parts[j];
|
|
|
|
pc->parts[j + k - amount + 1]->id = j + k - amount + 1;
|
|
|
|
}
|
|
|
|
i -= amount;
|
|
|
|
}
|
|
|
|
ep->reorder.done = EINA_TRUE;
|
|
|
|
free(parts);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-04-11 16:36:35 -07:00
|
|
|
void
|
2011-12-19 09:25:00 -08:00
|
|
|
data_queue_group_lookup(const char *name, Edje_Part *part)
|
2008-04-11 16:36:35 -07:00
|
|
|
{
|
|
|
|
Group_Lookup *gl;
|
|
|
|
|
2011-12-21 12:09:23 -08:00
|
|
|
if (!name || !name[0]) return;
|
2011-12-19 09:25:00 -08:00
|
|
|
|
2008-04-11 16:36:35 -07:00
|
|
|
gl = mem_alloc(SZ(Group_Lookup));
|
2008-10-22 04:34:42 -07:00
|
|
|
group_lookups = eina_list_append(group_lookups, gl);
|
2008-04-11 16:36:35 -07:00
|
|
|
gl->name = mem_strdup(name);
|
2011-12-19 09:25:00 -08:00
|
|
|
gl->part = part;
|
2008-04-11 16:36:35 -07:00
|
|
|
}
|
|
|
|
|
2012-05-22 20:12:25 -07:00
|
|
|
//#define NEWPARTLOOKUP 1
|
2012-05-26 01:41:49 -07:00
|
|
|
#ifdef NEWPARTLOOKUP
|
2012-05-15 05:29:22 -07:00
|
|
|
static Eina_Hash *_part_lookups_hash = NULL;
|
|
|
|
static Eina_Hash *_part_lookups_dest_hash = NULL;
|
2012-05-26 01:41:49 -07:00
|
|
|
#endif
|
2012-05-15 05:29:22 -07:00
|
|
|
|
2003-06-13 20:06:36 -07:00
|
|
|
void
|
2010-08-15 11:14:33 -07:00
|
|
|
data_queue_part_lookup(Edje_Part_Collection *pc, const char *name, int *dest)
|
2003-06-13 20:06:36 -07:00
|
|
|
{
|
2012-05-15 05:29:22 -07:00
|
|
|
Part_Lookup *pl = NULL;
|
2011-09-28 18:29:21 -07:00
|
|
|
Eina_List *l;
|
2012-05-26 01:41:49 -07:00
|
|
|
#ifdef NEWPARTLOOKUP
|
|
|
|
char buf[256];
|
|
|
|
#endif
|
2012-05-22 20:12:25 -07:00
|
|
|
|
2012-08-23 00:54:58 -07:00
|
|
|
#ifdef NEWPARTLOOKUP
|
|
|
|
snprintf(buf, sizeof(buf), "%lu-%lu",
|
2012-05-15 05:29:22 -07:00
|
|
|
(unsigned long)name, (unsigned long)dest);
|
|
|
|
if (_part_lookups_hash) pl = eina_hash_find(_part_lookups_hash, buf);
|
|
|
|
if (pl)
|
2011-09-28 18:29:21 -07:00
|
|
|
{
|
2012-05-15 05:29:22 -07:00
|
|
|
free(pl->name);
|
|
|
|
if (name[0])
|
|
|
|
pl->name = mem_strdup(name);
|
|
|
|
else
|
2011-09-28 18:29:21 -07:00
|
|
|
{
|
2012-05-15 05:29:22 -07:00
|
|
|
eina_hash_del(_part_lookups_hash, buf, pl);
|
|
|
|
snprintf(buf, sizeof(buf), "%lu", (unsigned long)dest);
|
|
|
|
eina_hash_del(_part_lookups_dest_hash, buf, pl);
|
|
|
|
part_lookups = eina_list_remove(part_lookups, pl);
|
|
|
|
free(pl);
|
2011-09-28 18:29:21 -07:00
|
|
|
}
|
2012-05-15 05:29:22 -07:00
|
|
|
return;
|
2011-09-28 18:29:21 -07:00
|
|
|
}
|
2012-05-22 20:12:25 -07:00
|
|
|
#else
|
|
|
|
EINA_LIST_FOREACH(part_lookups, l, pl)
|
|
|
|
{
|
|
|
|
if ((pl->pc == pc) && (pl->dest == dest))
|
|
|
|
{
|
|
|
|
free(pl->name);
|
|
|
|
if (name[0])
|
|
|
|
pl->name = mem_strdup(name);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
part_lookups = eina_list_remove(part_lookups, pl);
|
|
|
|
free(pl);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2012-08-23 00:54:58 -07:00
|
|
|
#endif
|
2011-12-15 16:29:05 -08:00
|
|
|
if (!name[0]) return;
|
2011-09-28 18:29:21 -07:00
|
|
|
|
2003-06-13 20:06:36 -07:00
|
|
|
pl = mem_alloc(SZ(Part_Lookup));
|
2012-05-15 05:29:22 -07:00
|
|
|
part_lookups = eina_list_prepend(part_lookups, pl);
|
2003-06-13 20:06:36 -07:00
|
|
|
pl->pc = pc;
|
|
|
|
pl->name = mem_strdup(name);
|
|
|
|
pl->dest = dest;
|
2012-08-23 00:54:58 -07:00
|
|
|
#ifdef NEWPARTLOOKUP
|
2012-05-15 05:29:22 -07:00
|
|
|
if (!_part_lookups_hash)
|
|
|
|
_part_lookups_hash = eina_hash_string_superfast_new(NULL);
|
|
|
|
eina_hash_add(_part_lookups_hash, buf, pl);
|
2012-08-23 00:54:58 -07:00
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
snprintf(buf, sizeof(buf), "%lu", (unsigned long)dest);
|
|
|
|
if (!_part_lookups_dest_hash)
|
|
|
|
_part_lookups_dest_hash = eina_hash_string_superfast_new(NULL);
|
|
|
|
l = eina_hash_find(_part_lookups_dest_hash, buf);
|
|
|
|
if (l)
|
|
|
|
{
|
|
|
|
l = eina_list_append(l, pl);
|
|
|
|
eina_hash_modify(_part_lookups_dest_hash, buf, l);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
l = eina_list_append(l, pl);
|
|
|
|
eina_hash_add(_part_lookups_dest_hash, buf, l);
|
|
|
|
}
|
2012-08-23 00:54:58 -07:00
|
|
|
#endif
|
2003-06-13 20:06:36 -07:00
|
|
|
}
|
|
|
|
|
2011-09-28 18:29:21 -07:00
|
|
|
void
|
|
|
|
data_queue_copied_part_lookup(Edje_Part_Collection *pc, int *src, int *dest)
|
|
|
|
{
|
2012-05-26 01:41:49 -07:00
|
|
|
Eina_List *l;
|
2011-09-28 18:29:21 -07:00
|
|
|
Part_Lookup *pl;
|
2012-05-26 01:41:49 -07:00
|
|
|
#ifdef NEWPARTLOOKUP
|
|
|
|
Eina_List *list;
|
2012-05-15 05:29:22 -07:00
|
|
|
char buf[256];
|
2012-05-26 01:41:49 -07:00
|
|
|
#endif
|
2011-09-28 18:29:21 -07:00
|
|
|
|
2012-05-22 20:12:25 -07:00
|
|
|
#ifdef NEWPARTLOOKUP
|
2012-05-15 05:29:22 -07:00
|
|
|
if (!_part_lookups_dest_hash) return;
|
|
|
|
snprintf(buf, sizeof(buf), "%lu", (unsigned long)src);
|
|
|
|
list = eina_hash_find(_part_lookups_dest_hash, buf);
|
|
|
|
EINA_LIST_FOREACH(list, l, pl)
|
2011-09-28 18:29:21 -07:00
|
|
|
{
|
2012-05-15 05:29:22 -07:00
|
|
|
data_queue_part_lookup(pc, pl->name, dest);
|
2011-09-28 18:29:21 -07:00
|
|
|
}
|
2012-08-23 00:54:58 -07:00
|
|
|
#else
|
2012-05-22 20:12:25 -07:00
|
|
|
EINA_LIST_FOREACH(part_lookups, l, pl)
|
|
|
|
{
|
|
|
|
if (pl->dest == src)
|
|
|
|
data_queue_part_lookup(pc, pl->name, dest);
|
|
|
|
}
|
|
|
|
#endif
|
2011-09-28 18:29:21 -07:00
|
|
|
}
|
|
|
|
|
2010-08-24 09:39:51 -07:00
|
|
|
void
|
|
|
|
data_queue_anonymous_lookup(Edje_Part_Collection *pc, Edje_Program *ep, int *dest)
|
|
|
|
{
|
2011-09-28 18:29:21 -07:00
|
|
|
Eina_List *l, *l2;
|
2010-08-24 09:39:51 -07:00
|
|
|
Program_Lookup *pl;
|
|
|
|
|
|
|
|
if (!ep) return ; /* FIXME: should we stop compiling ? */
|
|
|
|
|
2011-09-28 18:29:21 -07:00
|
|
|
EINA_LIST_FOREACH(program_lookups, l, pl)
|
|
|
|
{
|
|
|
|
if (pl->u.ep == ep)
|
|
|
|
{
|
|
|
|
Code *cd;
|
|
|
|
Code_Program *cp;
|
|
|
|
|
|
|
|
cd = eina_list_data_get(eina_list_last(codes));
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH(cd->programs, l2, cp)
|
|
|
|
{
|
|
|
|
if (&(cp->id) == pl->dest)
|
|
|
|
{
|
|
|
|
cd->programs = eina_list_remove(cd->programs, cp);
|
|
|
|
free(cp);
|
|
|
|
cp = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
program_lookups = eina_list_remove(program_lookups, pl);
|
|
|
|
free(pl);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dest)
|
|
|
|
{
|
|
|
|
pl = mem_alloc(SZ(Program_Lookup));
|
|
|
|
program_lookups = eina_list_append(program_lookups, pl);
|
|
|
|
pl->pc = pc;
|
|
|
|
pl->u.ep = ep;
|
|
|
|
pl->dest = dest;
|
|
|
|
pl->anonymous = EINA_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
data_queue_copied_anonymous_lookup(Edje_Part_Collection *pc, int *src, int *dest)
|
|
|
|
{
|
|
|
|
Eina_List *l;
|
|
|
|
Program_Lookup *pl;
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH(program_lookups, l, pl)
|
|
|
|
{
|
|
|
|
if (pl->dest == src)
|
|
|
|
{
|
|
|
|
for (i = 0 ; i < pc->programs.fnmatch_count ; i++)
|
|
|
|
{
|
|
|
|
if (!strcmp(pl->u.ep->name, pc->programs.fnmatch[i]->name))
|
|
|
|
data_queue_anonymous_lookup(pc, pc->programs.fnmatch[i], dest);
|
|
|
|
}
|
|
|
|
for (i = 0 ; i < pc->programs.strcmp_count ; i++)
|
|
|
|
{
|
|
|
|
if (!strcmp(pl->u.ep->name, pc->programs.strcmp[i]->name))
|
|
|
|
data_queue_anonymous_lookup(pc, pc->programs.strcmp[i], dest);
|
|
|
|
}
|
|
|
|
for (i = 0 ; i < pc->programs.strncmp_count ; i++)
|
|
|
|
{
|
|
|
|
if (!strcmp(pl->u.ep->name, pc->programs.strncmp[i]->name))
|
|
|
|
data_queue_anonymous_lookup(pc, pc->programs.strncmp[i], dest);
|
|
|
|
}
|
|
|
|
for (i = 0 ; i < pc->programs.strrncmp_count ; i++)
|
|
|
|
{
|
|
|
|
if (!strcmp(pl->u.ep->name, pc->programs.strrncmp[i]->name))
|
|
|
|
data_queue_anonymous_lookup(pc, pc->programs.strrncmp[i], dest);
|
|
|
|
}
|
|
|
|
for (i = 0 ; i < pc->programs.nocmp_count ; i++)
|
|
|
|
{
|
|
|
|
if (!strcmp(pl->u.ep->name, pc->programs.nocmp[i]->name))
|
|
|
|
data_queue_anonymous_lookup(pc, pc->programs.nocmp[i], dest);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2010-08-24 09:39:51 -07:00
|
|
|
}
|
|
|
|
|
2003-06-16 06:55:13 -07:00
|
|
|
void
|
2010-08-15 11:14:33 -07:00
|
|
|
data_queue_program_lookup(Edje_Part_Collection *pc, const char *name, int *dest)
|
2003-06-16 06:55:13 -07:00
|
|
|
{
|
|
|
|
Program_Lookup *pl;
|
2007-08-26 05:54:51 -07:00
|
|
|
|
2010-08-24 09:39:51 -07:00
|
|
|
if (!name) return ; /* FIXME: should we stop compiling ? */
|
|
|
|
|
2003-06-16 06:55:13 -07:00
|
|
|
pl = mem_alloc(SZ(Program_Lookup));
|
2008-10-22 04:34:42 -07:00
|
|
|
program_lookups = eina_list_append(program_lookups, pl);
|
2003-06-16 06:55:13 -07:00
|
|
|
pl->pc = pc;
|
2010-08-24 09:39:51 -07:00
|
|
|
pl->u.name = mem_strdup(name);
|
2003-06-16 06:55:13 -07:00
|
|
|
pl->dest = dest;
|
2010-08-24 09:39:51 -07:00
|
|
|
pl->anonymous = EINA_FALSE;
|
2003-06-16 06:55:13 -07:00
|
|
|
}
|
|
|
|
|
2011-09-28 18:29:21 -07:00
|
|
|
void
|
|
|
|
data_queue_copied_program_lookup(Edje_Part_Collection *pc, int *src, int *dest)
|
|
|
|
{
|
|
|
|
Eina_List *l;
|
|
|
|
Program_Lookup *pl;
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH(program_lookups, l, pl)
|
|
|
|
{
|
|
|
|
if (pl->dest == src)
|
|
|
|
data_queue_program_lookup(pc, pl->u.name, dest);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-06-13 20:06:36 -07:00
|
|
|
void
|
2010-06-01 06:31:07 -07:00
|
|
|
data_queue_image_lookup(char *name, int *dest, Eina_Bool *set)
|
2003-06-13 20:06:36 -07:00
|
|
|
{
|
|
|
|
Image_Lookup *il;
|
2007-08-26 05:54:51 -07:00
|
|
|
|
2003-06-13 20:06:36 -07:00
|
|
|
il = mem_alloc(SZ(Image_Lookup));
|
2008-10-22 04:34:42 -07:00
|
|
|
image_lookups = eina_list_append(image_lookups, il);
|
2003-06-13 20:06:36 -07:00
|
|
|
il->name = mem_strdup(name);
|
|
|
|
il->dest = dest;
|
2010-06-01 06:31:07 -07:00
|
|
|
il->set = set;
|
2003-06-13 20:06:36 -07:00
|
|
|
}
|
|
|
|
|
2012-01-25 01:07:36 -08:00
|
|
|
void
|
|
|
|
data_queue_image_remove(int *dest, Eina_Bool *set)
|
|
|
|
{
|
|
|
|
Eina_List *l;
|
|
|
|
Image_Lookup *il;
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH(image_lookups, l, il)
|
|
|
|
{
|
|
|
|
if (il->dest == dest && il->set == set)
|
|
|
|
{
|
|
|
|
image_lookups = eina_list_remove_list(image_lookups, l);
|
2012-07-13 01:33:26 -07:00
|
|
|
free(il->name);
|
2012-01-25 08:47:38 -08:00
|
|
|
free(il);
|
2012-01-25 01:07:36 -08:00
|
|
|
return ;
|
|
|
|
}
|
|
|
|
}
|
2012-01-25 08:47:38 -08:00
|
|
|
}
|
2012-01-25 01:07:36 -08:00
|
|
|
|
2011-09-28 18:29:21 -07:00
|
|
|
void
|
|
|
|
data_queue_copied_image_lookup(int *src, int *dest, Eina_Bool *set)
|
|
|
|
{
|
|
|
|
Eina_List *l;
|
|
|
|
Image_Lookup *il;
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH(image_lookups, l, il)
|
|
|
|
{
|
|
|
|
if (il->dest == src)
|
|
|
|
data_queue_image_lookup(il->name, dest, set);
|
|
|
|
}
|
|
|
|
}
|
2004-10-19 09:37:20 -07:00
|
|
|
void
|
|
|
|
data_queue_part_slave_lookup(int *master, int *slave)
|
|
|
|
{
|
|
|
|
Slave_Lookup *sl;
|
|
|
|
|
|
|
|
sl = mem_alloc(SZ(Slave_Lookup));
|
2008-10-22 04:34:42 -07:00
|
|
|
part_slave_lookups = eina_list_append(part_slave_lookups, sl);
|
2004-10-19 09:37:20 -07:00
|
|
|
sl->master = master;
|
|
|
|
sl->slave = slave;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
data_queue_image_slave_lookup(int *master, int *slave)
|
|
|
|
{
|
|
|
|
Slave_Lookup *sl;
|
|
|
|
|
|
|
|
sl = mem_alloc(SZ(Slave_Lookup));
|
2008-10-22 04:34:42 -07:00
|
|
|
image_slave_lookups = eina_list_append(image_slave_lookups, sl);
|
2004-10-19 09:37:20 -07:00
|
|
|
sl->master = master;
|
|
|
|
sl->slave = slave;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2008-10-22 04:34:42 -07:00
|
|
|
handle_slave_lookup(Eina_List *list, int *master, int value)
|
2004-10-19 09:37:20 -07:00
|
|
|
{
|
2008-10-22 04:34:42 -07:00
|
|
|
Eina_List *l;
|
|
|
|
Slave_Lookup *sl;
|
2004-10-19 09:37:20 -07:00
|
|
|
|
2008-10-22 04:34:42 -07:00
|
|
|
EINA_LIST_FOREACH(list, l, sl)
|
|
|
|
if (sl->master == master)
|
|
|
|
*sl->slave = value;
|
2004-10-19 09:37:20 -07:00
|
|
|
}
|
|
|
|
|
2003-06-13 20:06:36 -07:00
|
|
|
void
|
|
|
|
data_process_lookups(void)
|
|
|
|
{
|
2010-08-15 11:14:33 -07:00
|
|
|
Edje_Part_Collection *pc;
|
|
|
|
Part_Lookup *part;
|
|
|
|
Program_Lookup *program;
|
|
|
|
Group_Lookup *group;
|
|
|
|
Image_Lookup *image;
|
2012-01-25 08:47:38 -08:00
|
|
|
Eina_List *l2;
|
2008-10-22 04:34:42 -07:00
|
|
|
Eina_List *l;
|
2012-01-25 01:07:36 -08:00
|
|
|
Eina_Hash *images_in_use;
|
2010-08-15 11:14:33 -07:00
|
|
|
void *data;
|
2012-03-01 08:42:03 -08:00
|
|
|
Eina_Bool is_lua = EINA_FALSE;
|
2007-08-26 05:54:51 -07:00
|
|
|
|
2012-01-25 08:47:38 -08:00
|
|
|
/* remove all unreferenced Edje_Part_Collection */
|
|
|
|
EINA_LIST_FOREACH_SAFE(edje_collections, l, l2, pc)
|
|
|
|
{
|
|
|
|
Edje_Part_Collection_Directory_Entry *alias;
|
|
|
|
Edje_Part_Collection_Directory_Entry *find;
|
|
|
|
Eina_List *l3;
|
|
|
|
unsigned int id = 0;
|
|
|
|
unsigned int i;
|
|
|
|
|
2012-08-09 01:57:35 -07:00
|
|
|
if (!pc->part)
|
|
|
|
{
|
|
|
|
ERR("A collection without a name was detected, that's not allowed.");
|
|
|
|
exit(-1);
|
|
|
|
}
|
2012-01-25 08:47:38 -08:00
|
|
|
find = eina_hash_find(edje_file->collection, pc->part);
|
|
|
|
if (find && find->id == pc->id)
|
|
|
|
continue ;
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH(aliases, l3, alias)
|
|
|
|
if (alias->id == pc->id)
|
|
|
|
continue ;
|
|
|
|
|
|
|
|
/* This Edje_Part_Collection is not used at all */
|
|
|
|
edje_collections = eina_list_remove_list(edje_collections, l);
|
|
|
|
l3 = eina_list_nth_list(codes, pc->id);
|
|
|
|
codes = eina_list_remove_list(codes, l3);
|
|
|
|
|
|
|
|
/* Unref all image used by that group */
|
|
|
|
for (i = 0; i < pc->parts_count; ++i)
|
|
|
|
part_description_image_cleanup(pc->parts[i]);
|
|
|
|
|
|
|
|
/* Correct all id */
|
|
|
|
EINA_LIST_FOREACH(edje_collections, l3, pc)
|
|
|
|
{
|
|
|
|
Eina_List *l4;
|
|
|
|
|
|
|
|
/* Some group could be removed from the collection, but still be referenced by alias */
|
|
|
|
find = eina_hash_find(edje_file->collection, pc->part);
|
|
|
|
if (pc->id != find->id) find = NULL;
|
|
|
|
|
|
|
|
/* Update all matching alias */
|
|
|
|
EINA_LIST_FOREACH(aliases, l4, alias)
|
|
|
|
if (pc->id == alias->id)
|
|
|
|
alias->id = id;
|
|
|
|
|
|
|
|
pc->id = id++;
|
|
|
|
if (find) find->id = pc->id;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-15 11:14:33 -07:00
|
|
|
EINA_LIST_FOREACH(edje_collections, l, pc)
|
2003-06-13 20:06:36 -07:00
|
|
|
{
|
2012-04-19 01:41:47 -07:00
|
|
|
unsigned int count = 0;
|
|
|
|
unsigned int i;
|
2007-08-26 05:54:51 -07:00
|
|
|
|
2012-03-01 07:46:33 -08:00
|
|
|
if (pc->lua_script_only)
|
2012-04-19 01:41:47 -07:00
|
|
|
is_lua = EINA_TRUE;
|
2010-08-15 11:14:33 -07:00
|
|
|
#define PROGRAM_ID_SET(Type, Pc, It, Count) \
|
2012-04-19 01:41:47 -07:00
|
|
|
for (It = 0; It < Pc->programs.Type ## _count; ++It) \
|
|
|
|
{ \
|
|
|
|
Pc->programs.Type[It]->id = Count++; \
|
|
|
|
}
|
2010-08-15 11:14:33 -07:00
|
|
|
|
2012-04-19 01:41:47 -07:00
|
|
|
PROGRAM_ID_SET(fnmatch, pc, i, count);
|
|
|
|
PROGRAM_ID_SET(strcmp, pc, i, count);
|
|
|
|
PROGRAM_ID_SET(strncmp, pc, i, count);
|
|
|
|
PROGRAM_ID_SET(strrncmp, pc, i, count);
|
|
|
|
PROGRAM_ID_SET(nocmp, pc, i, count);
|
2010-08-15 11:14:33 -07:00
|
|
|
|
|
|
|
#undef PROGRAM_ID_SET
|
|
|
|
}
|
2007-08-26 05:54:51 -07:00
|
|
|
|
2010-08-15 11:14:33 -07:00
|
|
|
EINA_LIST_FREE(part_lookups, part)
|
|
|
|
{
|
2012-04-19 01:41:47 -07:00
|
|
|
Edje_Part *ep;
|
|
|
|
unsigned int i;
|
2010-08-15 11:14:33 -07:00
|
|
|
|
2012-04-18 20:35:29 -07:00
|
|
|
if (!strcmp(part->name, "-"))
|
|
|
|
{
|
|
|
|
*(part->dest) = -1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2012-06-23 23:01:12 -07:00
|
|
|
char *alias;
|
|
|
|
alias = eina_hash_find(part->pc->alias, part->name);
|
|
|
|
if (!alias)
|
|
|
|
alias = part->name;
|
2012-04-18 20:35:29 -07:00
|
|
|
for (i = 0; i < part->pc->parts_count; ++i)
|
|
|
|
{
|
|
|
|
ep = part->pc->parts[i];
|
2012-04-19 01:41:47 -07:00
|
|
|
|
2012-06-23 23:01:12 -07:00
|
|
|
if ((ep->name) && (!strcmp(ep->name, alias)))
|
2012-04-18 20:35:29 -07:00
|
|
|
{
|
|
|
|
handle_slave_lookup(part_slave_lookups, part->dest, ep->id);
|
|
|
|
*(part->dest) = ep->id;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2010-08-15 11:14:33 -07:00
|
|
|
|
2012-04-18 20:35:29 -07:00
|
|
|
if (i == part->pc->parts_count)
|
|
|
|
{
|
2012-07-31 15:42:03 -07:00
|
|
|
ERR("Unable to find part name \"%s\" needed in group '%s'.",
|
|
|
|
alias, part->pc->part);
|
2012-04-18 20:35:29 -07:00
|
|
|
exit(-1);
|
|
|
|
}
|
|
|
|
}
|
2010-08-15 11:14:33 -07:00
|
|
|
|
2012-04-19 01:41:47 -07:00
|
|
|
free(part->name);
|
|
|
|
free(part);
|
2003-06-13 20:06:36 -07:00
|
|
|
}
|
|
|
|
|
2010-08-15 11:14:33 -07:00
|
|
|
EINA_LIST_FREE(program_lookups, program)
|
2003-06-16 06:55:13 -07:00
|
|
|
{
|
2012-04-19 01:41:47 -07:00
|
|
|
unsigned int i;
|
|
|
|
Eina_Bool find = EINA_FALSE;
|
2010-08-15 11:14:33 -07:00
|
|
|
|
|
|
|
#define PROGRAM_MATCH(Type, Pl, It) \
|
2012-04-19 01:41:47 -07:00
|
|
|
for (It = 0; It < Pl->pc->programs.Type ## _count; ++It) \
|
|
|
|
{ \
|
|
|
|
Edje_Program *ep; \
|
|
|
|
\
|
|
|
|
ep = Pl->pc->programs.Type[It]; \
|
|
|
|
\
|
|
|
|
if ((Pl->anonymous && ep == Pl->u.ep) || \
|
|
|
|
((!Pl->anonymous) && (ep->name) && (!strcmp(ep->name, Pl->u.name)))) \
|
|
|
|
{ \
|
|
|
|
*(Pl->dest) = ep->id; \
|
|
|
|
find = EINA_TRUE; \
|
|
|
|
break; \
|
|
|
|
} \
|
|
|
|
}
|
2007-08-26 05:54:51 -07:00
|
|
|
|
2012-04-19 01:41:47 -07:00
|
|
|
PROGRAM_MATCH(fnmatch, program, i);
|
|
|
|
PROGRAM_MATCH(strcmp, program, i);
|
|
|
|
PROGRAM_MATCH(strncmp, program, i);
|
|
|
|
PROGRAM_MATCH(strrncmp, program, i);
|
|
|
|
PROGRAM_MATCH(nocmp, program, i);
|
2007-08-26 05:54:51 -07:00
|
|
|
|
2010-08-15 11:14:33 -07:00
|
|
|
#undef PROGRAM_MATCH
|
|
|
|
|
2012-04-19 01:41:47 -07:00
|
|
|
if (!find)
|
|
|
|
{
|
|
|
|
if (!program->anonymous)
|
2012-07-31 15:42:03 -07:00
|
|
|
ERR("Unable to find program name \"%s\".",
|
|
|
|
program->u.name);
|
2012-04-19 01:41:47 -07:00
|
|
|
else
|
2012-07-31 15:42:03 -07:00
|
|
|
ERR("Unable to find anonymous program.");
|
2012-04-19 01:41:47 -07:00
|
|
|
exit(-1);
|
|
|
|
}
|
2010-08-15 11:14:33 -07:00
|
|
|
|
2012-04-19 01:41:47 -07:00
|
|
|
if (!program->anonymous)
|
|
|
|
free(program->u.name);
|
|
|
|
free(program);
|
2003-06-16 06:55:13 -07:00
|
|
|
}
|
2007-08-26 05:54:51 -07:00
|
|
|
|
2010-08-15 11:14:33 -07:00
|
|
|
EINA_LIST_FREE(group_lookups, group)
|
2008-04-11 16:36:35 -07:00
|
|
|
{
|
2012-04-19 01:41:47 -07:00
|
|
|
Edje_Part_Collection_Directory_Entry *de;
|
2008-10-22 04:34:42 -07:00
|
|
|
|
2011-12-20 02:28:30 -08:00
|
|
|
if (group->part)
|
2012-04-19 01:41:47 -07:00
|
|
|
{
|
|
|
|
if (group->part->type != EDJE_PART_TYPE_GROUP
|
|
|
|
&& group->part->type != EDJE_PART_TYPE_TEXTBLOCK
|
|
|
|
&& group->part->type != EDJE_PART_TYPE_BOX
|
|
|
|
&& group->part->type != EDJE_PART_TYPE_TABLE)
|
|
|
|
goto free_group;
|
|
|
|
}
|
2011-12-19 09:25:00 -08:00
|
|
|
|
2012-04-19 01:41:47 -07:00
|
|
|
de = eina_hash_find(edje_file->collection, group->name);
|
2008-04-11 16:36:35 -07:00
|
|
|
|
2012-04-19 01:41:47 -07:00
|
|
|
if (!de)
|
|
|
|
{
|
2011-12-19 09:25:00 -08:00
|
|
|
Eina_Bool found = EINA_FALSE;
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH(aliases, l, de)
|
|
|
|
if (strcmp(de->entry, group->name) == 0)
|
|
|
|
{
|
|
|
|
found = EINA_TRUE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!found) de = NULL;
|
2012-04-19 01:41:47 -07:00
|
|
|
}
|
2011-12-19 09:25:00 -08:00
|
|
|
|
2012-04-19 01:41:47 -07:00
|
|
|
if (!de)
|
2008-04-11 16:36:35 -07:00
|
|
|
{
|
2012-07-31 15:42:03 -07:00
|
|
|
ERR("Unable to find group name \"%s\".", group->name);
|
2008-04-11 16:36:35 -07:00
|
|
|
exit(-1);
|
|
|
|
}
|
2010-08-15 11:14:33 -07:00
|
|
|
|
2012-04-19 01:41:47 -07:00
|
|
|
free_group:
|
2010-08-15 11:14:33 -07:00
|
|
|
free(group->name);
|
|
|
|
free(group);
|
2008-04-11 16:36:35 -07:00
|
|
|
}
|
|
|
|
|
2012-01-25 01:07:36 -08:00
|
|
|
images_in_use = eina_hash_string_superfast_new(NULL);
|
|
|
|
|
2010-08-15 11:14:33 -07:00
|
|
|
EINA_LIST_FREE(image_lookups, image)
|
2003-06-13 20:06:36 -07:00
|
|
|
{
|
2012-04-19 01:41:47 -07:00
|
|
|
Eina_Bool find = EINA_FALSE;
|
2007-08-26 05:54:51 -07:00
|
|
|
|
2012-04-19 01:41:47 -07:00
|
|
|
if (edje_file->image_dir)
|
|
|
|
{
|
2012-01-25 01:07:36 -08:00
|
|
|
Edje_Image_Directory_Entry *de;
|
2012-04-19 01:41:47 -07:00
|
|
|
unsigned int i;
|
2010-08-15 11:14:33 -07:00
|
|
|
|
2012-04-19 01:41:47 -07:00
|
|
|
for (i = 0; i < edje_file->image_dir->entries_count; ++i)
|
|
|
|
{
|
|
|
|
de = edje_file->image_dir->entries + i;
|
2010-08-15 11:14:33 -07:00
|
|
|
|
2012-04-19 01:41:47 -07:00
|
|
|
if ((de->entry) && (!strcmp(de->entry, image->name)))
|
|
|
|
{
|
|
|
|
handle_slave_lookup(image_slave_lookups, image->dest, de->id);
|
|
|
|
if (de->source_type == EDJE_IMAGE_SOURCE_TYPE_EXTERNAL)
|
|
|
|
*(image->dest) = -de->id - 1;
|
|
|
|
else
|
|
|
|
*(image->dest) = de->id;
|
|
|
|
*(image->set) = EINA_FALSE;
|
|
|
|
find = EINA_TRUE;
|
2012-01-25 01:07:36 -08:00
|
|
|
|
|
|
|
if (!eina_hash_find(images_in_use, image->name))
|
|
|
|
eina_hash_direct_add(images_in_use, de->entry, de);
|
2012-04-19 01:41:47 -07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2010-06-01 06:31:07 -07:00
|
|
|
|
2012-04-19 01:41:47 -07:00
|
|
|
if (!find)
|
|
|
|
{
|
|
|
|
Edje_Image_Directory_Set *set;
|
2007-08-26 05:54:51 -07:00
|
|
|
|
2012-04-19 01:41:47 -07:00
|
|
|
for (i = 0; i < edje_file->image_dir->sets_count; ++i)
|
|
|
|
{
|
|
|
|
set = edje_file->image_dir->sets + i;
|
|
|
|
|
|
|
|
if ((set->name) && (!strcmp(set->name, image->name)))
|
|
|
|
{
|
|
|
|
Edje_Image_Directory_Set_Entry *child;
|
|
|
|
Eina_List *lc;
|
|
|
|
|
|
|
|
handle_slave_lookup(image_slave_lookups, image->dest, set->id);
|
|
|
|
*(image->dest) = set->id;
|
|
|
|
*(image->set) = EINA_TRUE;
|
|
|
|
find = EINA_TRUE;
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH(set->entries, lc, child)
|
|
|
|
if (!eina_hash_find(images_in_use, child->name))
|
|
|
|
eina_hash_direct_add(images_in_use, child->name, child);
|
|
|
|
|
|
|
|
if (!eina_hash_find(images_in_use, image->name))
|
|
|
|
eina_hash_direct_add(images_in_use, set->name, set);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!find)
|
|
|
|
{
|
2012-07-31 15:42:03 -07:00
|
|
|
ERR("Unable to find image name \"%s\".", image->name);
|
2012-04-19 01:41:47 -07:00
|
|
|
exit(-1);
|
|
|
|
}
|
2004-10-19 09:37:20 -07:00
|
|
|
|
2012-04-19 01:41:47 -07:00
|
|
|
free(image->name);
|
|
|
|
free(image);
|
2004-10-19 09:37:20 -07:00
|
|
|
}
|
|
|
|
|
2012-03-01 07:46:33 -08:00
|
|
|
if (edje_file->image_dir && !is_lua)
|
2012-01-25 01:07:36 -08:00
|
|
|
{
|
2012-04-19 01:41:47 -07:00
|
|
|
Edje_Image_Directory_Entry *de;
|
2012-01-25 01:07:36 -08:00
|
|
|
Edje_Image_Directory_Set *set;
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
for (i = 0; i < edje_file->image_dir->entries_count; ++i)
|
|
|
|
{
|
|
|
|
de = edje_file->image_dir->entries + i;
|
|
|
|
|
|
|
|
if (de->entry && eina_hash_find(images_in_use, de->entry))
|
|
|
|
continue ;
|
|
|
|
|
2012-07-31 15:42:03 -07:00
|
|
|
INF("Image '%s' in resource 'edje/image/%i' will not be included as it is unused.",
|
|
|
|
de->entry, de->id);
|
2012-01-25 01:07:36 -08:00
|
|
|
|
|
|
|
de->entry = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < edje_file->image_dir->sets_count; ++i)
|
|
|
|
{
|
|
|
|
set = edje_file->image_dir->sets + i;
|
|
|
|
|
|
|
|
if (set->name && eina_hash_find(images_in_use, set->name))
|
|
|
|
continue ;
|
|
|
|
|
2012-07-31 15:42:03 -07:00
|
|
|
INF("Set '%s' will not be included as it is unused.", set->name);
|
2012-01-25 01:07:36 -08:00
|
|
|
|
|
|
|
set->name = NULL;
|
|
|
|
set->entries = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
eina_hash_free(images_in_use);
|
|
|
|
|
2010-08-15 11:14:33 -07:00
|
|
|
EINA_LIST_FREE(part_slave_lookups, data)
|
|
|
|
free(data);
|
|
|
|
|
|
|
|
EINA_LIST_FREE(image_slave_lookups, data)
|
|
|
|
free(data);
|
2003-06-13 20:06:36 -07:00
|
|
|
}
|
2004-04-01 01:30:45 -08:00
|
|
|
|
|
|
|
static void
|
2010-08-15 11:14:33 -07:00
|
|
|
data_process_string(Edje_Part_Collection *pc, const char *prefix, char *s, void (*func)(Edje_Part_Collection *pc, char *name, char* ptr, int len))
|
2004-04-01 01:30:45 -08:00
|
|
|
{
|
|
|
|
char *p;
|
|
|
|
char *key;
|
|
|
|
int keyl;
|
|
|
|
int quote, escape;
|
2007-08-26 05:54:51 -07:00
|
|
|
|
2004-04-01 01:30:45 -08:00
|
|
|
key = alloca(strlen(prefix) + 2 + 1);
|
|
|
|
if (!key) return;
|
|
|
|
strcpy(key, prefix);
|
|
|
|
strcat(key, ":\"");
|
|
|
|
keyl = strlen(key);
|
|
|
|
quote = 0;
|
|
|
|
escape = 0;
|
|
|
|
for (p = s; (p) && (*p); p++)
|
|
|
|
{
|
|
|
|
if (!quote)
|
|
|
|
{
|
|
|
|
if (*p == '\"')
|
|
|
|
{
|
|
|
|
quote = 1;
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!quote)
|
|
|
|
{
|
|
|
|
if (!strncmp(p, key, keyl))
|
|
|
|
{
|
2008-04-11 16:36:35 -07:00
|
|
|
char *ptr;
|
|
|
|
int len;
|
|
|
|
int inesc = 0;
|
|
|
|
char *name;
|
|
|
|
|
|
|
|
ptr = p;
|
|
|
|
p += keyl;
|
|
|
|
while ((*p))
|
2004-04-01 01:30:45 -08:00
|
|
|
{
|
2008-04-11 16:36:35 -07:00
|
|
|
if (!inesc)
|
|
|
|
{
|
2012-08-23 00:54:58 -07:00
|
|
|
if (*p == '\\') inesc = 1;
|
2008-04-11 16:36:35 -07:00
|
|
|
else if (*p == '\"')
|
2004-04-01 01:30:45 -08:00
|
|
|
{
|
2008-04-11 16:36:35 -07:00
|
|
|
/* string concatenation, see below */
|
|
|
|
if (*(p + 1) != '\"')
|
|
|
|
break;
|
|
|
|
else
|
|
|
|
p++;
|
2004-04-01 01:30:45 -08:00
|
|
|
}
|
|
|
|
}
|
2008-04-11 16:36:35 -07:00
|
|
|
else
|
|
|
|
inesc = 0;
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
len = p - ptr + 1;
|
|
|
|
name = alloca(len);
|
|
|
|
if (name)
|
|
|
|
{
|
|
|
|
char *pp;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
name[0] = 0;
|
|
|
|
pp = ptr + keyl;
|
|
|
|
inesc = 0;
|
|
|
|
i = 0;
|
|
|
|
while (*pp)
|
|
|
|
{
|
2012-08-23 00:54:58 -07:00
|
|
|
if (!inesc)
|
2004-04-01 01:30:45 -08:00
|
|
|
{
|
2008-04-11 16:36:35 -07:00
|
|
|
if (*pp == '\\') inesc = 1;
|
|
|
|
else if (*pp == '\"')
|
2012-08-23 00:54:58 -07:00
|
|
|
{
|
2008-04-11 16:36:35 -07:00
|
|
|
/* concat strings like "foo""bar" to "foobar" */
|
|
|
|
if (*(pp + 1) == '\"')
|
|
|
|
pp++;
|
2004-04-01 01:30:45 -08:00
|
|
|
else
|
2008-04-11 16:36:35 -07:00
|
|
|
{
|
2012-08-23 00:54:58 -07:00
|
|
|
name[i] = 0;
|
2008-04-11 16:36:35 -07:00
|
|
|
break;
|
2004-04-01 01:30:45 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
2008-04-11 16:36:35 -07:00
|
|
|
{
|
|
|
|
name[i] = *pp;
|
|
|
|
name[i + 1] = 0;
|
|
|
|
i++;
|
|
|
|
}
|
2004-04-01 01:30:45 -08:00
|
|
|
}
|
2008-04-11 16:36:35 -07:00
|
|
|
else
|
|
|
|
inesc = 0;
|
|
|
|
pp++;
|
|
|
|
}
|
|
|
|
func(pc, name, ptr, len);
|
|
|
|
}
|
|
|
|
}
|
2004-04-01 01:30:45 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (!escape)
|
|
|
|
{
|
|
|
|
if (*p == '\"') quote = 0;
|
|
|
|
else if (*p == '\\') escape = 1;
|
|
|
|
}
|
|
|
|
else if (escape)
|
|
|
|
{
|
|
|
|
escape = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-04-01 01:53:11 -08:00
|
|
|
static void
|
2010-08-15 11:14:33 -07:00
|
|
|
_data_queue_part_lookup(Edje_Part_Collection *pc, char *name, char *ptr, int len)
|
2004-04-01 01:30:45 -08:00
|
|
|
{
|
2008-04-11 16:36:35 -07:00
|
|
|
Code_Lookup *cl;
|
|
|
|
cl = mem_alloc(SZ(Code_Lookup));
|
|
|
|
cl->ptr = ptr;
|
|
|
|
cl->len = len;
|
|
|
|
|
|
|
|
data_queue_part_lookup(pc, name, &(cl->val));
|
|
|
|
|
2008-10-22 04:34:42 -07:00
|
|
|
code_lookups = eina_list_append(code_lookups, cl);
|
2008-04-11 16:36:35 -07:00
|
|
|
}
|
|
|
|
static void
|
2010-08-15 11:14:33 -07:00
|
|
|
_data_queue_program_lookup(Edje_Part_Collection *pc, char *name, char *ptr, int len)
|
2008-04-11 16:36:35 -07:00
|
|
|
{
|
|
|
|
Code_Lookup *cl;
|
2009-10-25 04:24:55 -07:00
|
|
|
|
2008-04-11 16:36:35 -07:00
|
|
|
cl = mem_alloc(SZ(Code_Lookup));
|
|
|
|
cl->ptr = ptr;
|
|
|
|
cl->len = len;
|
|
|
|
|
|
|
|
data_queue_program_lookup(pc, name, &(cl->val));
|
|
|
|
|
2008-10-22 04:34:42 -07:00
|
|
|
code_lookups = eina_list_append(code_lookups, cl);
|
2008-04-11 16:36:35 -07:00
|
|
|
}
|
|
|
|
static void
|
2010-08-15 11:14:33 -07:00
|
|
|
_data_queue_group_lookup(Edje_Part_Collection *pc __UNUSED__, char *name, char *ptr __UNUSED__, int len __UNUSED__)
|
2008-04-11 16:36:35 -07:00
|
|
|
{
|
2011-12-19 09:25:00 -08:00
|
|
|
data_queue_group_lookup(name, NULL);
|
2008-04-11 16:36:35 -07:00
|
|
|
}
|
|
|
|
static void
|
2010-08-15 11:14:33 -07:00
|
|
|
_data_queue_image_pc_lookup(Edje_Part_Collection *pc __UNUSED__, char *name, char *ptr, int len)
|
2008-04-11 16:36:35 -07:00
|
|
|
{
|
|
|
|
Code_Lookup *cl;
|
2009-10-25 04:24:55 -07:00
|
|
|
|
2008-04-11 16:36:35 -07:00
|
|
|
cl = mem_alloc(SZ(Code_Lookup));
|
|
|
|
cl->ptr = ptr;
|
|
|
|
cl->len = len;
|
|
|
|
|
2010-06-01 06:31:07 -07:00
|
|
|
data_queue_image_lookup(name, &(cl->val), &(cl->set));
|
2008-04-11 16:36:35 -07:00
|
|
|
|
2008-10-22 04:34:42 -07:00
|
|
|
code_lookups = eina_list_append(code_lookups, cl);
|
2004-04-01 01:30:45 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
data_process_scripts(void)
|
|
|
|
{
|
2008-10-22 04:34:42 -07:00
|
|
|
Eina_List *l, *l2;
|
2007-08-26 05:54:51 -07:00
|
|
|
|
2008-10-22 04:34:42 -07:00
|
|
|
for (l = codes, l2 = edje_collections; (l) && (l2); l = eina_list_next(l), l2 = eina_list_next(l2))
|
2004-04-01 01:30:45 -08:00
|
|
|
{
|
2010-08-15 11:14:33 -07:00
|
|
|
Edje_Part_Collection *pc;
|
2004-04-01 01:30:45 -08:00
|
|
|
Code *cd;
|
2007-08-26 05:54:51 -07:00
|
|
|
|
2008-10-22 04:34:42 -07:00
|
|
|
cd = eina_list_data_get(l);
|
|
|
|
pc = eina_list_data_get(l2);
|
2010-08-15 11:14:33 -07:00
|
|
|
|
|
|
|
if ((cd->shared) && (!cd->is_lua))
|
|
|
|
{
|
|
|
|
data_process_string(pc, "PART", cd->shared, _data_queue_part_lookup);
|
|
|
|
data_process_string(pc, "PROGRAM", cd->shared, _data_queue_program_lookup);
|
|
|
|
data_process_string(pc, "IMAGE", cd->shared, _data_queue_image_pc_lookup);
|
|
|
|
data_process_string(pc, "GROUP", cd->shared, _data_queue_group_lookup);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cd->programs)
|
2004-04-01 01:30:45 -08:00
|
|
|
{
|
2008-10-22 04:34:42 -07:00
|
|
|
Code_Program *cp;
|
2010-08-15 11:14:33 -07:00
|
|
|
Eina_List *ll;
|
2007-08-26 05:54:51 -07:00
|
|
|
|
2008-10-22 04:34:42 -07:00
|
|
|
EINA_LIST_FOREACH(cd->programs, ll, cp)
|
2004-04-01 01:30:45 -08:00
|
|
|
{
|
|
|
|
if (cp->script)
|
|
|
|
{
|
2008-04-11 16:36:35 -07:00
|
|
|
data_process_string(pc, "PART", cp->script, _data_queue_part_lookup);
|
|
|
|
data_process_string(pc, "PROGRAM", cp->script, _data_queue_program_lookup);
|
|
|
|
data_process_string(pc, "IMAGE", cp->script, _data_queue_image_pc_lookup);
|
|
|
|
data_process_string(pc, "GROUP", cp->script, _data_queue_group_lookup);
|
2004-04-01 01:30:45 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
data_process_script_lookups(void)
|
|
|
|
{
|
2008-10-22 04:34:42 -07:00
|
|
|
Eina_List *l;
|
|
|
|
Code_Lookup *cl;
|
2007-08-26 05:54:51 -07:00
|
|
|
|
2008-10-22 04:34:42 -07:00
|
|
|
EINA_LIST_FOREACH(code_lookups, l, cl)
|
2004-04-01 01:30:45 -08:00
|
|
|
{
|
2009-02-25 09:08:17 -08:00
|
|
|
char buf[12];
|
|
|
|
int n;
|
2004-04-01 01:30:45 -08:00
|
|
|
|
2010-06-01 06:31:07 -07:00
|
|
|
/* FIXME !! Handle set in program */
|
2009-02-25 09:08:17 -08:00
|
|
|
n = eina_convert_itoa(cl->val, buf);
|
2004-04-01 01:30:45 -08:00
|
|
|
if (n > cl->len)
|
|
|
|
{
|
2012-07-31 15:42:03 -07:00
|
|
|
ERR("The unexpected happened. A numeric replacement string was larger than the original!");
|
2004-04-01 01:30:45 -08:00
|
|
|
exit(-1);
|
|
|
|
}
|
2009-02-25 09:08:17 -08:00
|
|
|
memset(cl->ptr, ' ', cl->len);
|
2004-04-01 01:30:45 -08:00
|
|
|
strncpy(cl->ptr, buf, n);
|
|
|
|
}
|
|
|
|
}
|
2012-05-08 03:35:57 -07:00
|
|
|
|
|
|
|
void
|
|
|
|
using_file(const char *filename)
|
|
|
|
{
|
2012-05-15 05:29:22 -07:00
|
|
|
FILE *f;
|
2012-05-08 03:35:57 -07:00
|
|
|
|
2012-05-15 05:29:22 -07:00
|
|
|
if (!watchfile) return;
|
2012-07-28 09:22:15 -07:00
|
|
|
f = fopen(watchfile, "ab");
|
2012-05-15 05:29:22 -07:00
|
|
|
if (!f) return ;
|
|
|
|
fputs(filename, f);
|
|
|
|
fputc('\n', f);
|
|
|
|
fclose(f);
|
2012-05-08 03:35:57 -07:00
|
|
|
}
|