2004-08-29 02:40:02 -07:00
/*
2004-10-19 09:50:27 -07:00
* vim : ts = 8 : sw = 3 : sts = 8 : noexpandtab : cino = > 5 n - 3f 0 ^ - 2 { 2
2004-08-29 02:40:02 -07:00
*/
2009-02-08 22:33:26 -08:00
# ifdef HAVE_CONFIG_H
# include "config.h"
# endif
# ifdef HAVE_ALLOCA_H
# include <alloca.h>
# elif defined __GNUC__
# define alloca __builtin_alloca
# elif defined _AIX
# define alloca __alloca
# elif defined _MSC_VER
# include <malloc.h>
# define alloca _alloca
# else
# include <stddef.h>
# ifdef __cplusplus
extern " C "
# endif
void * alloca ( size_t ) ;
# 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"
2008-10-26 10:18:19 -07:00
# include "edje_prefix.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 ;
2006-08-02 03:52:44 -07:00
typedef struct _String_Lookup Image_Lookup ;
typedef struct _String_Lookup Spectrum_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
{
Edje_Part_Collection * pc ;
char * name ;
int * dest ;
} ;
2003-06-16 06:55:13 -07:00
struct _Program_Lookup
{
Edje_Part_Collection * pc ;
char * name ;
int * dest ;
} ;
2008-04-11 16:36:35 -07:00
struct _Group_Lookup
{
char * name ;
} ;
2006-08-02 03:52:44 -07:00
struct _String_Lookup
2003-06-13 20:06:36 -07:00
{
char * name ;
int * dest ;
} ;
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 ;
} ;
2008-04-11 16:36:35 -07: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
2003-06-11 06:20:48 -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 ;
static Eet_Data_Descriptor * edd_edje_image_directory = NULL ;
static Eet_Data_Descriptor * edd_edje_image_directory_entry = NULL ;
2006-08-02 03:52:44 -07:00
static Eet_Data_Descriptor * edd_edje_spectrum_directory = NULL ;
static Eet_Data_Descriptor * edd_edje_spectrum_directory_entry = NULL ;
2003-06-16 06:55:13 -07:00
static Eet_Data_Descriptor * edd_edje_program = NULL ;
static Eet_Data_Descriptor * edd_edje_program_target = NULL ;
static Eet_Data_Descriptor * edd_edje_part_collection_directory = NULL ;
static Eet_Data_Descriptor * edd_edje_part_collection_directory_entry = NULL ;
static Eet_Data_Descriptor * edd_edje_part_collection = NULL ;
static Eet_Data_Descriptor * edd_edje_part = NULL ;
static Eet_Data_Descriptor * edd_edje_part_description = NULL ;
static Eet_Data_Descriptor * edd_edje_part_image_id = NULL ;
2006-08-02 03:52:44 -07:00
static Eet_Data_Descriptor * edd_edje_spectrum_color = 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 * spectrum_lookups = NULL ;
static Eina_List * part_slave_lookups = NULL ;
static Eina_List * image_slave_lookups = NULL ;
static Eina_List * spectrum_slave_lookups = NULL ;
2003-06-11 06:20:48 -07:00
2004-03-06 02:21:15 -08:00
# define ABORT_WRITE(eet_file, file) \
eet_close ( eet_file ) ; \
unlink ( file ) ; \
exit ( - 1 ) ;
2008-08-20 20:58:11 -07:00
static void
error_and_abort ( Eet_File * ef , const char * fmt , . . . )
{
va_list ap ;
2009-12-22 05:46:00 -08:00
ERR ( " %s: Error. " , progname ) ;
2008-08-20 20:58:11 -07:00
va_start ( ap , fmt ) ;
vfprintf ( stderr , fmt , ap ) ;
va_end ( ap ) ;
ABORT_WRITE ( ef , file_out ) ;
}
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_image_directory = _edje_edd_edje_image_directory ;
edd_edje_image_directory_entry = _edje_edd_edje_image_directory_entry ;
2006-08-02 03:52:44 -07:00
edd_edje_spectrum_directory = _edje_edd_edje_spectrum_directory ;
edd_edje_spectrum_directory_entry = _edje_edd_edje_spectrum_directory_entry ;
2003-06-17 01:15:06 -07:00
edd_edje_program = _edje_edd_edje_program ;
edd_edje_program_target = _edje_edd_edje_program_target ;
edd_edje_part_collection_directory = _edje_edd_edje_part_collection_directory ;
edd_edje_part_collection_directory_entry = _edje_edd_edje_part_collection_directory_entry ;
edd_edje_part_collection = _edje_edd_edje_part_collection ;
edd_edje_part = _edje_edd_edje_part ;
edd_edje_part_description = _edje_edd_edje_part_description ;
edd_edje_part_image_id = _edje_edd_edje_part_image_id ;
2006-08-02 03:52:44 -07:00
edd_edje_spectrum_color = _edje_edd_edje_spectrum_color ;
2003-06-11 06:20:48 -07:00
}
2004-10-23 10:33:27 -07:00
static void
2004-10-23 10:58:14 -07:00
check_image_part_desc ( Edje_Part_Collection * pc , Edje_Part * ep ,
Edje_Part_Description * epd , Eet_File * ef )
2004-10-23 10:33:27 -07:00
{
2008-10-22 04:34:42 -07:00
Eina_List * l ;
Edje_Part_Image_Id * iid ;
2004-10-23 10:33:27 -07:00
2006-11-17 06:47:30 -08:00
return ;
2004-10-23 10:33:27 -07:00
if ( epd - > image . id = = - 1 )
2008-08-20 20:58:11 -07:00
error_and_abort ( ef , " Collection %i: image attributes missing for "
" part \" %s \" , description \" %s \" %f \n " ,
pc - > id , ep - > name , epd - > state . name , epd - > state . value ) ;
2004-10-23 10:33:27 -07:00
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( epd - > image . tween_list , l , iid )
2004-10-23 10:33:27 -07:00
{
if ( iid - > id = = - 1 )
2008-08-20 20:58:11 -07:00
error_and_abort ( ef , " Collection %i: tween image id missing for "
" part \" %s \" , description \" %s \" %f \n " ,
pc - > id , ep - > name , epd - > state . name , epd - > state . value ) ;
}
2004-10-23 10:33:27 -07:00
}
2008-11-23 21:15:15 -08:00
static void
2008-12-05 19:08:17 -08:00
check_packed_items ( Edje_Part_Collection * pc , Edje_Part * ep , Eet_File * ef )
2008-11-23 21:15:15 -08:00
{
Eina_List * l ;
Edje_Pack_Element * it ;
EINA_LIST_FOREACH ( ep - > items , l , it )
{
if ( it - > type = = EDJE_PART_TYPE_GROUP & & ! it - > source )
error_and_abort ( ef , " Collection %i: missing source on packed item "
" of type GROUP in part \" %s \" \n " ,
pc - > id , ep - > name ) ;
2008-12-17 18:43:20 -08:00
if ( ep - > type = = EDJE_PART_TYPE_TABLE & & ( it - > col < 0 | | it - > row < 0 ) )
error_and_abort ( ef , " Collection %i: missing col/row on packed item "
" for part \" %s \" of type TABLE \n " ,
pc - > id , ep - > name ) ;
2008-11-23 21:15:15 -08:00
}
}
2004-10-23 10:33:27 -07:00
static void
2004-10-23 10:58:14 -07:00
check_part ( Edje_Part_Collection * pc , Edje_Part * ep , Eet_File * ef )
2004-10-23 10:33:27 -07:00
{
Edje_Part_Description * epd = ep - > default_desc ;
2008-10-22 04:34:42 -07:00
Eina_List * l ;
Edje_Part_Description * data ;
2004-10-23 10:33:27 -07:00
if ( ! epd )
2008-08-20 20:58:11 -07:00
error_and_abort ( ef , " Collection %i: default description missing "
" for part \" %s \" \n " , pc - > id , ep - > name ) ;
2004-10-23 10:33:27 -07:00
if ( ep - > type = = EDJE_PART_TYPE_IMAGE )
{
2004-10-23 10:58:14 -07:00
check_image_part_desc ( pc , ep , epd , ef ) ;
2004-10-23 10:33:27 -07:00
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ep - > other_desc , l , data )
check_image_part_desc ( pc , ep , data , 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 ) ;
2004-10-23 10:33:27 -07:00
}
static void
2004-10-23 10:58:14 -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 "
" \" %s \" \n " , pc - > id , ep - > name ) ;
2004-10-23 10:33:27 -07:00
break ;
default :
break ;
2006-08-04 01:55:05 -07:00
}
}
static void
check_spectrum ( Edje_Spectrum_Directory_Entry * se , Eet_File * ef )
{
2007-08-26 05:54:51 -07:00
if ( ! se - > entry )
2008-08-20 20:58:11 -07:00
error_and_abort ( ef , " Spectrum missing a name. \n " ) ;
2006-08-04 01:55:05 -07:00
else if ( ! se - > color_list )
2008-08-20 20:58:11 -07:00
error_and_abort ( ef , " Spectrum %s is empty. At least one color must be "
" given. " , se - > entry ) ;
2004-10-23 10:33:27 -07:00
}
2008-08-20 20:57:20 -07:00
static int
data_write_header ( Eet_File * ef )
2003-06-11 06:20:48 -07:00
{
2008-08-20 20:57:20 -07:00
int bytes = 0 ;
2007-08-26 05:54:51 -07:00
2003-10-18 19:11:06 -07:00
if ( edje_file )
2003-06-16 06:55:13 -07:00
{
2006-10-11 22:35:14 -07:00
2007-08-26 05:54:51 -07:00
if ( edje_file - > collection_dir )
2006-10-11 22:35:14 -07:00
{
/* copy aliases into collection directory */
while ( aliases )
{
2008-10-22 04:34:42 -07:00
edje_file - > collection_dir - > entries = eina_list_append ( edje_file - > collection_dir - > entries , eina_list_data_get ( aliases ) ) ;
aliases = eina_list_remove_list ( aliases , aliases ) ;
2006-10-11 22:35:14 -07:00
}
}
2003-10-18 19:11:06 -07:00
bytes = eet_data_write ( ef , edd_edje_file , " edje_file " , edje_file , 1 ) ;
if ( bytes < = 0 )
2008-08-20 20:58:11 -07:00
error_and_abort ( ef , " Unable to write \" edje_file \" entry to \" %s \" \n " ,
file_out ) ;
2003-06-16 06:55:13 -07:00
}
2008-08-20 20:57:20 -07:00
2003-06-16 06:55:13 -07:00
if ( verbose )
{
printf ( " %s: Wrote %9i bytes (%4iKb) for \" edje_file \" header \n " ,
progname , bytes , ( bytes + 512 ) / 1024 ) ;
}
2008-08-20 20:57:20 -07:00
return bytes ;
}
static int
data_write_fonts ( Eet_File * ef , int * font_num , int * input_bytes , int * input_raw_bytes )
{
2008-10-22 04:34:42 -07:00
Eina_List * l ; ;
2008-08-20 20:57:20 -07:00
int bytes = 0 ;
int total_bytes = 0 ;
2008-10-22 04:34:42 -07:00
Font * fn ;
2008-08-20 20:57:20 -07:00
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( fonts , l , fn )
2004-01-22 18:13:42 -08:00
{
void * fdata = NULL ;
int fsize = 0 ;
2008-10-22 04:34:42 -07:00
Eina_List * ll ;
2004-01-22 18:13:42 -08:00
FILE * f ;
2007-08-26 05:54:51 -07:00
2004-01-22 18:13:42 -08:00
f = fopen ( fn - > file , " rb " ) ;
if ( f )
{
long pos ;
2007-08-26 05:54:51 -07:00
2004-01-22 18:13:42 -08:00
fseek ( f , 0 , SEEK_END ) ;
pos = ftell ( f ) ;
rewind ( f ) ;
fdata = malloc ( pos ) ;
if ( fdata )
{
if ( fread ( fdata , pos , 1 , f ) ! = 1 )
2008-08-20 20:58:11 -07:00
error_and_abort ( ef , " Unable to read all of font "
" file \" %s \" \n " , fn - > file ) ;
2004-01-22 18:13:42 -08:00
fsize = pos ;
}
fclose ( f ) ;
}
else
{
2008-10-22 04:34:42 -07:00
char * data ;
EINA_LIST_FOREACH ( fnt_dirs , ll , data )
2004-01-22 18:13:42 -08:00
{
char buf [ 4096 ] ;
2007-08-26 05:54:51 -07:00
2008-10-22 04:34:42 -07:00
snprintf ( buf , sizeof ( buf ) , " %s/%s " , data , fn - > file ) ;
2004-01-22 18:13:42 -08:00
f = fopen ( buf , " rb " ) ;
if ( f )
{
long pos ;
2007-08-26 05:54:51 -07:00
2004-01-22 18:13:42 -08:00
fseek ( f , 0 , SEEK_END ) ;
pos = ftell ( f ) ;
rewind ( f ) ;
fdata = malloc ( pos ) ;
if ( fdata )
{
if ( fread ( fdata , pos , 1 , f ) ! = 1 )
2008-08-20 20:58:11 -07:00
error_and_abort ( ef , " Unable to read all of font "
" file \" %s \" \n " , buf ) ;
2004-01-22 18:13:42 -08:00
fsize = pos ;
}
fclose ( f ) ;
if ( fdata ) break ;
}
}
}
if ( ! fdata )
{
2008-08-20 20:58:11 -07:00
error_and_abort ( ef , " Unable to load font part \" %s \" entry "
" to %s \n " , fn - > file , file_out ) ;
2004-01-22 18:13:42 -08:00
}
else
{
char buf [ 4096 ] ;
2007-08-26 05:54:51 -07:00
2004-01-22 18:13:42 -08:00
snprintf ( buf , sizeof ( buf ) , " fonts/%s " , fn - > name ) ;
bytes = eet_write ( ef , buf , fdata , fsize , 1 ) ;
if ( bytes < = 0 )
2008-08-20 20:58:11 -07:00
error_and_abort ( ef , " Unable to write font part \" %s \" as \" %s \" "
" part entry to %s \n " , fn - > file , buf , file_out ) ;
* font_num + = 1 ;
total_bytes + = bytes ;
* input_bytes + = fsize ;
* input_raw_bytes + = fsize ;
2004-01-22 18:13:42 -08:00
if ( verbose )
{
printf ( " %s: Wrote %9i bytes (%4iKb) for \" %s \" font entry \" %s \" compress: [real: %2.1f%%] \n " ,
progname , bytes , ( bytes + 512 ) / 1024 , buf , fn - > file ,
100 - ( 100 * ( double ) bytes ) / ( ( double ) ( fsize ) )
) ;
}
free ( fdata ) ;
}
}
2008-08-20 20:57:20 -07:00
return total_bytes ;
}
static int
data_write_images ( Eet_File * ef , int * image_num , int * input_bytes , int * input_raw_bytes )
{
2008-10-22 04:34:42 -07:00
Eina_List * l ;
2008-08-20 20:57:20 -07:00
int bytes = 0 ;
int total_bytes = 0 ;
2003-10-18 19:11:06 -07:00
if ( ( edje_file ) & & ( edje_file - > image_dir ) )
2003-06-11 06:20:48 -07:00
{
2005-11-10 22:49:57 -08:00
Ecore_Evas * ee ;
Evas * evas ;
2008-10-22 04:34:42 -07:00
Edje_Image_Directory_Entry * img ;
2007-08-26 05:54:51 -07:00
2005-11-10 22:49:57 -08:00
ecore_init ( ) ;
ecore_evas_init ( ) ;
2008-08-20 20:58:11 -07:00
2005-11-10 22:49:57 -08:00
ee = ecore_evas_buffer_new ( 1 , 1 ) ;
2006-01-23 07:13:44 -08:00
if ( ! ee )
2008-08-20 20:58:11 -07:00
error_and_abort ( ef , " Cannot create buffer engine canvas for image "
" load. \n " ) ;
2005-11-10 22:49:57 -08:00
evas = ecore_evas_get ( ee ) ;
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( edje_file - > image_dir - > entries , l , img )
2003-06-11 06:20:48 -07:00
{
2006-11-17 06:47:30 -08:00
if ( img - > source_type = = EDJE_IMAGE_SOURCE_TYPE_EXTERNAL )
{
}
else
2003-06-11 06:20:48 -07:00
{
2005-11-10 22:49:57 -08:00
Evas_Object * im ;
2008-10-22 04:34:42 -07:00
Eina_List * ll ;
char * data ;
2007-08-26 05:54:51 -07:00
2003-10-18 19:11:06 -07:00
im = NULL ;
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( img_dirs , ll , data )
2003-06-16 06:55:13 -07:00
{
2003-10-18 19:11:06 -07:00
char buf [ 4096 ] ;
2007-08-26 05:54:51 -07:00
snprintf ( buf , sizeof ( buf ) , " %s/%s " ,
2008-10-22 04:34:42 -07:00
data , img - > entry ) ;
2005-11-10 22:49:57 -08:00
im = evas_object_image_add ( evas ) ;
if ( im )
{
evas_object_image_file_set ( im , buf , NULL ) ;
2007-08-26 05:54:51 -07:00
if ( evas_object_image_load_error_get ( im ) = =
2005-11-10 22:49:57 -08:00
EVAS_LOAD_ERROR_NONE )
{
break ;
}
evas_object_del ( im ) ;
im = NULL ;
}
}
if ( ! im )
{
im = evas_object_image_add ( evas ) ;
if ( im )
{
evas_object_image_file_set ( im , img - > entry , NULL ) ;
2007-08-26 05:54:51 -07:00
if ( evas_object_image_load_error_get ( im ) ! =
2005-11-10 22:49:57 -08:00
EVAS_LOAD_ERROR_NONE )
{
evas_object_del ( im ) ;
im = NULL ;
}
}
2003-06-16 06:55:13 -07:00
}
2003-10-18 19:11:06 -07:00
if ( im )
2003-07-10 18:47:42 -07:00
{
2005-11-10 22:49:57 -08:00
void * im_data ;
2003-10-18 19:11:06 -07:00
int im_w , im_h ;
int im_alpha ;
char buf [ 256 ] ;
2007-08-26 05:54:51 -07:00
2005-11-10 22:49:57 -08:00
evas_object_image_size_get ( im , & im_w , & im_h ) ;
im_alpha = evas_object_image_alpha_get ( im ) ;
im_data = evas_object_image_data_get ( im , 0 ) ;
2003-10-18 19:11:06 -07:00
if ( ( im_data ) & & ( im_w > 0 ) & & ( im_h > 0 ) )
{
2004-08-31 22:41:26 -07:00
int mode , qual ;
2007-08-26 05:54:51 -07:00
2003-10-18 19:11:06 -07:00
snprintf ( buf , sizeof ( buf ) , " images/%i " , img - > id ) ;
2004-08-31 22:41:26 -07:00
mode = 2 ;
2004-09-01 19:43:16 -07:00
qual = 80 ;
2004-08-31 22:41:26 -07:00
if ( ( img - > source_type = = EDJE_IMAGE_SOURCE_TYPE_INLINE_PERFECT ) & &
( img - > source_param = = 0 ) )
mode = 0 ; /* RAW */
else if ( ( img - > source_type = = EDJE_IMAGE_SOURCE_TYPE_INLINE_PERFECT ) & &
( img - > source_param = = 1 ) )
mode = 1 ; /* COMPRESS */
else
mode = 2 ; /* LOSSY */
2004-09-01 19:43:16 -07:00
if ( ( mode = = 0 ) & & ( no_raw ) )
{
mode = 1 ; /* promote compression */
img - > source_param = 95 ;
}
2004-08-31 22:41:26 -07:00
if ( ( mode = = 2 ) & & ( no_lossy ) ) mode = 1 ; /* demote compression */
if ( ( mode = = 1 ) & & ( no_comp ) )
{
if ( no_lossy ) mode = 0 ; /* demote compression */
2004-09-01 19:43:16 -07:00
else if ( no_raw )
{
img - > source_param = 90 ;
mode = 2 ; /* no choice. lossy */
}
2004-08-31 22:41:26 -07:00
}
if ( mode = = 2 )
{
qual = img - > source_param ;
if ( qual < min_quality ) qual = min_quality ;
if ( qual > max_quality ) qual = max_quality ;
}
if ( mode = = 0 )
2007-08-26 05:54:51 -07:00
bytes = eet_data_image_write ( ef , buf ,
2003-10-18 19:11:06 -07:00
im_data , im_w , im_h ,
2007-08-26 05:54:51 -07:00
im_alpha ,
2004-08-31 22:41:26 -07:00
0 , 0 , 0 ) ;
else if ( mode = = 1 )
2007-08-26 05:54:51 -07:00
bytes = eet_data_image_write ( ef , buf ,
2004-08-31 22:41:26 -07:00
im_data , im_w , im_h ,
2007-08-26 05:54:51 -07:00
im_alpha ,
2004-08-31 22:41:26 -07:00
1 , 0 , 0 ) ;
else if ( mode = = 2 )
2007-08-26 05:54:51 -07:00
bytes = eet_data_image_write ( ef , buf ,
2003-10-18 19:11:06 -07:00
im_data , im_w , im_h ,
im_alpha ,
2004-08-31 22:41:26 -07:00
0 , qual , 1 ) ;
2003-10-18 19:11:06 -07:00
if ( bytes < = 0 )
2008-08-20 20:58:11 -07:00
error_and_abort ( ef , " Unable to write image part "
" \" %s \" as \" %s \" part entry to "
" %s \n " , img - > entry , buf ,
file_out ) ;
* image_num + = 1 ;
total_bytes + = bytes ;
2003-10-18 19:11:06 -07:00
}
else
{
2008-08-20 20:58:11 -07:00
error_and_abort ( ef , " Unable to load image for "
" image part \" %s \" as \" %s \" part "
" entry to %s \n " , img - > entry , buf ,
file_out ) ;
2003-10-18 19:11:06 -07:00
}
2008-08-20 20:58:11 -07:00
2003-10-18 19:11:06 -07:00
if ( verbose )
{
struct stat st ;
2006-08-05 18:35:56 -07:00
const char * file = NULL ;
2007-08-26 05:54:51 -07:00
2005-11-10 22:49:57 -08:00
evas_object_image_file_get ( im , & file , NULL ) ;
2009-10-07 03:55:48 -07:00
if ( ! file | | ( stat ( file , & st ) ! = 0 ) )
2003-10-18 19:11:06 -07:00
st . st_size = 0 ;
2008-08-20 20:57:20 -07:00
* input_bytes + = st . st_size ;
* input_raw_bytes + = im_w * im_h * 4 ;
2003-10-18 19:11:06 -07:00
printf ( " %s: Wrote %9i bytes (%4iKb) for \" %s \" image entry \" %s \" compress: [raw: %2.1f%%] [real: %2.1f%%] \n " ,
progname , bytes , ( bytes + 512 ) / 1024 , buf , img - > entry ,
100 - ( 100 * ( double ) bytes ) / ( ( double ) ( im_w * im_h * 4 ) ) ,
100 - ( 100 * ( double ) bytes ) / ( ( double ) ( st . st_size ) )
) ;
}
2005-11-10 22:49:57 -08:00
evas_object_del ( im ) ;
2003-07-10 18:47:42 -07:00
}
2003-10-18 19:11:06 -07:00
else
2003-06-16 06:55:13 -07:00
{
2008-08-20 20:58:11 -07:00
error_and_abort ( ef , " Unable to load image for image \" %s \" part entry to %s. Missing PNG or JPEG loader modules for Evas or file does not exist, or is not readable. \n " ,
img - > entry , file_out ) ;
2003-06-16 06:55:13 -07:00
}
2003-06-11 06:20:48 -07:00
}
}
2005-11-10 22:49:57 -08:00
ecore_evas_free ( ee ) ;
ecore_evas_shutdown ( ) ;
ecore_shutdown ( ) ;
2003-06-11 06:20:48 -07:00
}
2004-10-23 10:33:27 -07:00
2008-08-20 20:57:20 -07:00
return total_bytes ;
}
static void
check_groups_names ( Eet_File * ef )
{
2008-10-22 04:34:42 -07:00
Eina_List * l ;
Edje_Part_Collection_Directory_Entry * de ;
2008-08-20 20:57:20 -07:00
if ( ! edje_file - > collection_dir )
return ;
2006-01-28 22:05:16 -08:00
/* check that all groups have names */
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( edje_file - > collection_dir - > entries , l , de )
2008-08-20 20:57:20 -07:00
if ( ! de - > entry )
2008-08-20 20:58:11 -07:00
error_and_abort ( ef , " Collection %i: name missing. \n " , de - > id ) ;
2008-08-20 20:57:20 -07:00
}
static void
check_spectra ( Eet_File * ef )
{
2008-10-22 04:34:42 -07:00
Eina_List * l ;
Edje_Spectrum_Directory_Entry * se ;
2008-08-20 20:57:20 -07:00
if ( ! edje_file - > spectrum_dir )
return ;
2006-08-04 01:55:05 -07:00
/* check that all spectra are valid */
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( edje_file - > spectrum_dir - > entries , l , se )
check_spectrum ( se , ef ) ;
2008-08-20 20:57:20 -07:00
}
static void
check_groups ( Eet_File * ef )
{
2008-10-22 04:34:42 -07:00
Eina_List * l ;
Edje_Part_Collection * pc ;
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
{
2008-10-22 04:34:42 -07:00
Eina_List * ll ;
Edje_Part * part ;
Edje_Program * prog ;
EINA_LIST_FOREACH ( pc - > parts , ll , part )
check_part ( pc , part , ef ) ;
EINA_LIST_FOREACH ( pc - > programs , ll , prog )
check_program ( pc , prog , ef ) ;
2004-01-22 18:13:42 -08:00
}
2008-08-20 20:57:20 -07:00
}
static int
data_write_groups ( Eet_File * ef , int * collection_num )
{
2008-10-22 04:34:42 -07:00
Eina_List * l ;
Edje_Part_Collection * pc ;
2008-08-20 20:57:20 -07:00
int bytes = 0 ;
int total_bytes = 0 ;
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( edje_collections , l , pc )
2004-01-22 18:13:42 -08:00
{
char buf [ 4096 ] ;
2007-08-26 05:54:51 -07:00
2003-06-16 06:55:13 -07:00
snprintf ( buf , sizeof ( buf ) , " collections/%i " , pc - > id ) ;
bytes = eet_data_write ( ef , edd_edje_part_collection , buf , pc , 1 ) ;
if ( bytes < = 0 )
2008-08-20 20:58:11 -07:00
error_and_abort ( ef , " Error. Unable to write \" %s \" part entry "
" to %s \n " , buf , file_out ) ;
* collection_num + = 1 ;
total_bytes + = bytes ;
2003-06-16 06:55:13 -07:00
if ( verbose )
{
printf ( " %s: Wrote %9i bytes (%4iKb) for \" %s \" collection entry \n " ,
progname , bytes , ( bytes + 512 ) / 1024 , buf ) ;
}
}
2008-08-20 20:57:20 -07:00
return total_bytes ;
}
static void
2008-08-20 20:57:56 -07:00
create_script_file ( Eet_File * ef , const char * filename , const Code * cd )
2008-08-20 20:57:20 -07:00
{
2008-08-20 20:57:56 -07:00
FILE * f = fopen ( filename , " wb " ) ;
if ( ! f )
2008-08-20 20:58:11 -07:00
error_and_abort ( ef , " Unable to open temp file \" %s \" for script "
" compilation. \n " , 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 ;
}
}
fprintf ( f , " } " ) ;
ln + = cp - > l2 - cp - > l1 + 1 ;
}
}
fclose ( f ) ;
}
static void
compile_script_file ( Eet_File * ef , const char * source , const char * output ,
int script_num )
{
FILE * f ;
char buf [ 4096 ] ;
int ret ;
snprintf ( buf , sizeof ( buf ) ,
" embryo_cc -i %s/include -o %s %s " ,
e_prefix_data_get ( ) , output , source ) ;
ret = system ( buf ) ;
/* accept warnings in the embryo code */
if ( ret < 0 | | ret > 1 )
2008-08-20 20:58:11 -07:00
error_and_abort ( ef , " Compiling script code not clean. \n " ) ;
2007-08-26 05:54:51 -07:00
2008-08-20 20:57:56 -07:00
f = fopen ( output , " rb " ) ;
if ( ! f )
2008-08-20 20:58:11 -07:00
error_and_abort ( ef , " Unable to open script object \" %s \" for reading. \n " ,
output ) ;
2008-08-20 20:57:56 -07:00
fseek ( f , 0 , SEEK_END ) ;
2008-08-20 20:58:11 -07:00
int size = ftell ( f ) ;
2008-08-20 20:57:56 -07:00
rewind ( f ) ;
if ( size > 0 )
{
int bt ;
2008-08-20 20:58:11 -07:00
void * data = malloc ( size ) ;
2008-08-20 20:57:56 -07:00
if ( data )
2004-03-27 21:26:17 -08:00
{
2008-08-20 20:57:56 -07:00
if ( fread ( data , size , 1 , f ) ! = 1 )
2008-08-20 20:58:11 -07:00
error_and_abort ( ef , " Unable to read all of script object "
" \" %s \" \n " , output ) ;
2008-08-20 20:57:56 -07:00
snprintf ( buf , sizeof ( buf ) , " scripts/%i " , script_num ) ;
bt = eet_write ( ef , buf , data , size , 1 ) ;
free ( data ) ;
}
}
fclose ( f ) ;
}
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
{
2009-10-25 04:40:06 -07:00
char tmpn [ 4096 ] ;
char tmpo [ 4096 ] ;
2008-08-20 20:57:56 -07:00
int fd ;
2008-10-22 04:34:42 -07:00
Code * cd = eina_list_data_get ( l ) ;
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 ;
2007-08-26 05:54:51 -07:00
2009-08-25 10:25:23 -07:00
snprintf ( tmpn , PATH_MAX , " %s/edje_cc.sma-tmp-XXXXXX " , tmp_dir ) ;
2008-08-20 20:57:56 -07:00
fd = mkstemp ( tmpn ) ;
if ( fd < 0 )
2008-08-20 20:58:11 -07:00
error_and_abort ( ef , " Unable to open temp file \" %s \" for script "
" compilation. \n " , tmpn ) ;
2007-08-26 05:54:51 -07:00
2008-08-20 20:57:56 -07:00
create_script_file ( ef , tmpn , cd ) ;
close ( fd ) ;
2007-08-26 05:54:51 -07:00
2009-08-25 10:25:23 -07:00
snprintf ( tmpo , PATH_MAX , " %s/edje_cc.amx-tmp-XXXXXX " , tmp_dir ) ;
2008-08-20 20:57:56 -07:00
fd = mkstemp ( tmpo ) ;
if ( fd < 0 )
{
2008-08-20 20:58:11 -07:00
unlink ( tmpn ) ;
error_and_abort ( ef , " Unable to open temp file \" %s \" for script "
" compilation. \n " , tmpn ) ;
2004-03-27 21:26:17 -08:00
}
2008-08-20 20:58:11 -07:00
2008-08-20 20:57:56 -07:00
compile_script_file ( ef , tmpn , tmpo , i ) ;
close ( fd ) ;
unlink ( tmpn ) ;
unlink ( tmpo ) ;
2004-03-27 21:26:17 -08:00
}
2008-08-20 20:57:20 -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
typedef struct _Edje_Lua_Script_Writer_Struct Edje_Lua_Script_Writer_Struct ;
struct _Edje_Lua_Script_Writer_Struct {
2009-08-17 04:32:56 -07:00
char * 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
int size ;
} ;
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
2009-10-25 04:24:55 -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
{
2009-10-25 04:40:06 -07:00
Edje_Lua_Script_Writer_Struct * data ;
void * old ;
2009-10-25 04:24:55 -07:00
2009-10-25 04:40:06 -07:00
data = ( Edje_Lua_Script_Writer_Struct * ) _data ;
old = data - > 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
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 ) ;
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
2009-08-17 04:32:56 -07:00
_edje_lua_error_and_abort ( lua_State * L , int err_code , Eet_File * 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
{
char * err_type ;
2009-10-25 04:24:55 -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 )
{
case LUA_ERRRUN :
err_type = " runtime " ;
break ;
case LUA_ERRSYNTAX :
err_type = " syntax " ;
break ;
case LUA_ERRMEM :
err_type = " memory allocation " ;
break ;
case LUA_ERRERR :
err_type = " error handler " ;
break ;
default :
err_type = " unknown " ;
break ;
}
error_and_abort ( ef , " Lua %s error: %s \n " , err_type , lua_tostring ( L , - 1 ) ) ;
}
static void
data_write_lua_scripts ( Eet_File * ef )
{
Eina_List * l ;
Eina_List * ll ;
Code_Program * cp ;
int i ;
for ( i = 0 , l = codes ; l ; l = eina_list_next ( l ) , i + + )
{
2009-10-25 04:40:06 -07:00
char buf [ 4096 ] ;
Code * cd ;
lua_State * L ;
int ln = 1 ;
luaL_Buffer b ;
Edje_Lua_Script_Writer_Struct data ;
# ifdef LUA_BINARY
int err_code ;
# endif
cd = ( Code * ) eina_list_data_get ( l ) ;
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 ;
if ( ( ! cd - > shared ) & & ( ! cd - > programs ) )
continue ;
2009-10-25 04:40:06 -07:00
L = luaL_newstate ( ) ;
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 ( ! L )
error_and_abort ( ef , " Lua error: Lua state could not be initialized \n " ) ;
luaL_buffinit ( L , & b ) ;
data . buf = NULL ;
data . size = 0 ;
if ( cd - > shared )
{
while ( ln < ( cd - > l1 - 1 ) )
{
luaL_addchar ( & b , ' \n ' ) ;
ln + + ;
}
luaL_addstring ( & b , cd - > shared ) ;
ln + = cd - > l2 - cd - > l1 ;
}
EINA_LIST_FOREACH ( 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 , ef ) ;
lua_dump ( L , _edje_lua_script_writer , & data ) ;
# else // LUA_PLAIN_TEXT
2009-12-08 21:46:02 -08:00
data . buf = ( char * ) lua_tostring ( L , - 1 ) ;
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 = strlen ( data . buf ) ;
# endif
//printf("lua chunk size: %d\n", data.size);
/*
* TODO load and test Lua chunk
*/
/*
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 ) ) ;
*/
snprintf ( buf , sizeof ( buf ) , " lua_scripts/%i " , i ) ;
eet_write ( ef , buf , data . buf , data . size , 1 ) ;
# ifdef LUA_BINARY
free ( data . buf ) ;
# endif
lua_close ( L ) ;
}
}
2008-08-20 20:57:20 -07:00
void
data_write ( void )
{
Eet_File * ef ;
int input_bytes = 0 ;
int total_bytes = 0 ;
int src_bytes = 0 ;
int fmap_bytes = 0 ;
int input_raw_bytes = 0 ;
int image_num = 0 ;
int font_num = 0 ;
int collection_num = 0 ;
ef = eet_open ( file_out , EET_FILE_MODE_WRITE ) ;
if ( ! ef )
{
2009-12-22 05:46:00 -08:00
ERR ( " %s: Error. Unable to open \" %s \" for writing output " ,
progname , file_out ) ;
2008-08-20 20:57:20 -07:00
exit ( - 1 ) ;
}
total_bytes + = data_write_header ( ef ) ;
total_bytes + = data_write_fonts ( ef , & font_num , & input_bytes ,
& input_raw_bytes ) ;
total_bytes + = data_write_images ( ef , & image_num , & input_bytes ,
& input_raw_bytes ) ;
check_groups_names ( ef ) ;
check_spectra ( ef ) ;
check_groups ( ef ) ;
total_bytes + = data_write_groups ( ef , & collection_num ) ;
data_write_scripts ( 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
data_write_lua_scripts ( ef ) ;
2008-08-20 20:57:20 -07:00
2004-08-29 04:03:19 -07:00
src_bytes = source_append ( ef ) ;
total_bytes + = src_bytes ;
fmap_bytes = source_fontmap_save ( ef , fonts ) ;
total_bytes + = fmap_bytes ;
2008-08-20 20:57:20 -07:00
2003-06-11 06:20:48 -07:00
eet_close ( ef ) ;
2008-08-20 20:57:20 -07:00
2003-07-10 18:47:42 -07:00
if ( verbose )
{
struct stat st ;
2007-08-26 05:54:51 -07:00
2003-07-10 18:47:42 -07:00
if ( stat ( file_in , & st ) ! = 0 )
st . st_size = 0 ;
input_bytes + = st . st_size ;
input_raw_bytes + = st . st_size ;
printf ( " Summary: \n "
" Wrote %i collections \n "
" Wrote %i images \n "
2004-01-22 18:13:42 -08:00
" Wrote %i fonts \n "
2004-08-29 04:03:19 -07:00
" Wrote %i bytes (%iKb) of original source data \n "
" Wrote %i bytes (%iKb) of original source font map \n "
2003-07-10 18:47:42 -07:00
" Conservative compression summary: \n "
" Wrote total %i bytes (%iKb) from %i (%iKb) input data \n "
" Output file is %3.1f%% the size of the input data \n "
" Saved %i bytes (%iKb) \n "
" Raw compression summary: \n "
" Wrote total %i bytes (%iKb) from %i (%iKb) raw input data \n "
" Output file is %3.1f%% the size of the raw input data \n "
" Saved %i bytes (%iKb) \n "
,
collection_num ,
image_num ,
2004-01-22 18:13:42 -08:00
font_num ,
2004-08-29 04:03:19 -07:00
src_bytes , ( src_bytes + 512 ) / 1024 ,
fmap_bytes , ( fmap_bytes + 512 ) / 1024 ,
2003-07-10 18:47:42 -07:00
total_bytes , ( total_bytes + 512 ) / 1024 ,
input_bytes , ( input_bytes + 512 ) / 1024 ,
( 100.0 * ( double ) total_bytes ) / ( double ) input_bytes ,
input_bytes - total_bytes ,
( input_bytes - total_bytes + 512 ) / 1024 ,
total_bytes , ( total_bytes + 512 ) / 1024 ,
input_raw_bytes , ( input_raw_bytes + 512 ) / 1024 ,
( 100.0 * ( double ) total_bytes ) / ( double ) input_raw_bytes ,
input_raw_bytes - total_bytes ,
( input_raw_bytes - total_bytes + 512 ) / 1024 ) ;
}
2003-06-11 06:20:48 -07:00
}
2003-06-13 20:06:36 -07:00
2008-04-11 16:36:35 -07:00
void
data_queue_group_lookup ( char * name )
{
Group_Lookup * gl ;
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 ) ;
}
2003-06-13 20:06:36 -07:00
void
data_queue_part_lookup ( Edje_Part_Collection * pc , char * name , int * dest )
{
Part_Lookup * pl ;
2007-08-26 05:54:51 -07:00
2003-06-13 20:06:36 -07:00
pl = mem_alloc ( SZ ( Part_Lookup ) ) ;
2008-10-22 04:34:42 -07:00
part_lookups = eina_list_append ( part_lookups , pl ) ;
2003-06-13 20:06:36 -07:00
pl - > pc = pc ;
pl - > name = mem_strdup ( name ) ;
pl - > dest = dest ;
}
2003-06-16 06:55:13 -07:00
void
data_queue_program_lookup ( Edje_Part_Collection * pc , char * name , int * dest )
{
Program_Lookup * pl ;
2007-08-26 05:54:51 -07:00
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 ;
pl - > name = mem_strdup ( name ) ;
pl - > dest = dest ;
}
2003-06-13 20:06:36 -07:00
void
data_queue_image_lookup ( char * name , int * dest )
{
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 ;
}
2006-08-02 03:52:44 -07:00
void
data_queue_spectrum_lookup ( char * name , int * dest )
{
Spectrum_Lookup * sl ;
2007-08-26 05:54:51 -07:00
2006-08-02 03:52:44 -07:00
sl = mem_alloc ( SZ ( Spectrum_Lookup ) ) ;
2008-10-22 04:34:42 -07:00
spectrum_lookups = eina_list_append ( spectrum_lookups , sl ) ;
2006-08-02 03:52:44 -07:00
sl - > name = mem_strdup ( name ) ;
sl - > dest = dest ;
}
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 ;
}
2006-08-02 03:52:44 -07:00
void
data_queue_spectrum_slave_lookup ( int * master , int * slave )
{
Slave_Lookup * sl ;
sl = mem_alloc ( SZ ( Slave_Lookup ) ) ;
2008-10-22 04:34:42 -07:00
spectrum_slave_lookups = eina_list_append ( spectrum_slave_lookups , sl ) ;
2006-08-02 03:52:44 -07:00
sl - > master = master ;
sl - > slave = slave ;
}
2004-10-19 09:37:20 -07:00
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 )
{
2008-10-22 04:34:42 -07:00
Eina_List * l ;
2007-08-26 05:54:51 -07:00
2003-06-13 20:06:36 -07:00
while ( part_lookups )
{
Part_Lookup * pl ;
2008-10-22 04:34:42 -07:00
Edje_Part * ep ;
2007-08-26 05:54:51 -07:00
2008-10-22 04:34:42 -07:00
pl = eina_list_data_get ( part_lookups ) ;
2007-08-26 05:54:51 -07:00
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( pl - > pc - > parts , l , ep )
2003-06-13 20:06:36 -07:00
{
if ( ( ep - > name ) & & ( ! strcmp ( ep - > name , pl - > name ) ) )
{
2004-10-19 09:37:20 -07:00
handle_slave_lookup ( part_slave_lookups , pl - > dest , ep - > id ) ;
2003-06-13 20:06:36 -07:00
* ( pl - > dest ) = ep - > id ;
break ;
}
}
if ( ! l )
{
2009-12-22 05:46:00 -08:00
ERR ( " %s: Error. Unable to find part name \" %s \" . " ,
progname , pl - > name ) ;
2003-06-13 20:06:36 -07:00
exit ( - 1 ) ;
}
2008-10-22 04:34:42 -07:00
part_lookups = eina_list_remove ( part_lookups , pl ) ;
2003-06-13 20:06:36 -07:00
free ( pl - > name ) ;
free ( pl ) ;
}
2003-06-16 06:55:13 -07:00
while ( program_lookups )
{
Program_Lookup * pl ;
2008-10-22 04:34:42 -07:00
Edje_Program * ep ;
2007-08-26 05:54:51 -07:00
2008-10-22 04:34:42 -07:00
pl = eina_list_data_get ( program_lookups ) ;
2007-08-26 05:54:51 -07:00
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( pl - > pc - > programs , l , ep )
2003-06-16 06:55:13 -07:00
{
if ( ( ep - > name ) & & ( ! strcmp ( ep - > name , pl - > name ) ) )
{
* ( pl - > dest ) = ep - > id ;
break ;
}
}
if ( ! l )
{
2009-12-22 05:46:00 -08:00
ERR ( " %s: Error. Unable to find program name \" %s \" . " ,
progname , pl - > name ) ;
2003-06-16 06:55:13 -07:00
exit ( - 1 ) ;
}
2008-10-22 04:34:42 -07:00
program_lookups = eina_list_remove ( program_lookups , pl ) ;
2003-06-16 06:55:13 -07:00
free ( pl - > name ) ;
free ( pl ) ;
}
2007-08-26 05:54:51 -07:00
2008-04-11 16:36:35 -07:00
while ( group_lookups )
{
Group_Lookup * gl ;
2008-10-22 04:34:42 -07:00
Edje_Part_Collection_Directory_Entry * de ;
gl = eina_list_data_get ( group_lookups ) ;
2008-04-11 16:36:35 -07:00
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( edje_file - > collection_dir - > entries , l , de )
2008-04-11 16:36:35 -07:00
{
if ( ! strcmp ( de - > entry , gl - > name ) )
{
break ;
}
}
if ( ! l )
{
2009-12-22 05:46:00 -08:00
ERR ( " %s: Error. Unable to find group name \" %s \" . " ,
progname , gl - > name ) ;
2008-04-11 16:36:35 -07:00
exit ( - 1 ) ;
}
2008-10-22 04:34:42 -07:00
group_lookups = eina_list_remove ( group_lookups , gl ) ;
2008-04-11 16:36:35 -07:00
free ( gl - > name ) ;
free ( gl ) ;
}
2003-06-13 20:06:36 -07:00
while ( image_lookups )
{
Image_Lookup * il ;
2008-10-22 04:34:42 -07:00
Edje_Image_Directory_Entry * de ;
2007-08-26 05:54:51 -07:00
2008-10-22 04:34:42 -07:00
il = eina_list_data_get ( image_lookups ) ;
2007-08-26 05:54:51 -07:00
2004-08-29 02:40:02 -07:00
if ( ! edje_file - > image_dir )
2004-10-05 22:25:03 -07:00
l = NULL ;
2004-08-29 02:40:02 -07:00
else
2004-10-05 22:25:03 -07:00
{
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( edje_file - > image_dir - > entries , l , de )
2004-10-05 22:25:03 -07:00
{
if ( ( de - > entry ) & & ( ! strcmp ( de - > entry , il - > name ) ) )
{
2004-10-19 09:37:20 -07:00
handle_slave_lookup ( image_slave_lookups , il - > dest , de - > id ) ;
2006-11-17 06:47:30 -08:00
if ( de - > source_type = = EDJE_IMAGE_SOURCE_TYPE_EXTERNAL )
* ( il - > dest ) = - de - > id - 1 ;
else
* ( il - > dest ) = de - > id ;
2004-10-05 22:25:03 -07:00
break ;
}
}
}
2007-08-26 05:54:51 -07:00
2003-06-13 20:06:36 -07:00
if ( ! l )
{
2009-12-22 05:46:00 -08:00
ERR ( " %s: Error. Unable to find image name \" %s \" . " ,
progname , il - > name ) ;
2003-06-13 20:06:36 -07:00
exit ( - 1 ) ;
}
2008-10-22 04:34:42 -07:00
image_lookups = eina_list_remove ( image_lookups , il ) ;
2003-06-13 20:06:36 -07:00
free ( il - > name ) ;
free ( il ) ;
}
2004-10-19 09:37:20 -07:00
2006-08-02 03:52:44 -07:00
while ( spectrum_lookups )
{
Spectrum_Lookup * il ;
2008-10-22 04:34:42 -07:00
Edje_Spectrum_Directory_Entry * de ;
2007-08-26 05:54:51 -07:00
2008-10-22 04:34:42 -07:00
il = eina_list_data_get ( spectrum_lookups ) ;
2006-08-02 03:52:44 -07:00
if ( ! edje_file - > spectrum_dir )
l = NULL ;
else
{
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( edje_file - > spectrum_dir - > entries , l , de )
2006-08-02 03:52:44 -07:00
{
* ( il - > dest ) = 1 ;
if ( ( de - > entry ) & & ( ! strcmp ( de - > entry , il - > name ) ) )
{
handle_slave_lookup ( spectrum_slave_lookups , il - > dest , de - > id ) ;
* ( il - > dest ) = de - > id ;
break ;
}
}
}
2007-08-26 05:54:51 -07:00
2006-08-02 03:52:44 -07:00
if ( ! l )
{
2009-12-22 05:46:00 -08:00
ERR ( " %s: Error. unable to find spectrum name %s " ,
progname , il - > name ) ;
2006-08-02 03:52:44 -07:00
exit ( - 1 ) ;
}
2008-10-22 04:34:42 -07:00
spectrum_lookups = eina_list_remove ( spectrum_lookups , il ) ;
2006-08-02 03:52:44 -07:00
free ( il - > name ) ;
free ( il ) ;
}
2004-10-19 09:37:20 -07:00
while ( part_slave_lookups )
{
2008-10-22 04:34:42 -07:00
free ( eina_list_data_get ( part_slave_lookups ) ) ;
part_slave_lookups = eina_list_remove_list ( part_slave_lookups , part_slave_lookups ) ;
2004-10-19 09:37:20 -07:00
}
while ( image_slave_lookups )
{
2008-10-22 04:34:42 -07:00
free ( eina_list_data_get ( image_slave_lookups ) ) ;
image_slave_lookups = eina_list_remove_list ( image_slave_lookups , image_slave_lookups ) ;
2004-10-19 09:37:20 -07:00
}
2006-08-02 03:52:44 -07:00
while ( spectrum_slave_lookups )
{
2008-10-22 04:34:42 -07:00
free ( eina_list_data_get ( spectrum_slave_lookups ) ) ;
spectrum_slave_lookups = eina_list_remove_list ( spectrum_slave_lookups , spectrum_slave_lookups ) ;
2006-08-02 03:52:44 -07:00
}
2003-06-13 20:06:36 -07:00
}
2004-04-01 01:30:45 -08:00
static void
2008-04-11 16:36:35 -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 )
{
if ( * p = = ' \\ ' ) inesc = 1 ;
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 )
{
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 = = ' \" ' )
{
/* 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
{
name [ i ] = 0 ;
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
2008-04-11 16:36:35 -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
_data_queue_program_lookup ( Edje_Part_Collection * pc , char * name , char * ptr , int len )
{
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
2009-10-25 04:24:55 -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
{
data_queue_group_lookup ( name ) ;
}
static void
2009-10-25 04:24:55 -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 ;
data_queue_image_lookup ( name , & ( cl - > val ) ) ;
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
{
Code * cd ;
Edje_Part_Collection * pc ;
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 ) ;
2004-04-01 01:30:45 -08:00
if ( ( cd - > shared ) | | ( cd - > programs ) )
{
2008-10-22 04:34:42 -07:00
Eina_List * ll ;
Code_Program * cp ;
2007-08-26 05:54:51 -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 - > shared ) & & ( ! cd - > is_lua ) )
2004-04-01 01:30:45 -08:00
{
2008-04-11 16:36:35 -07:00
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 ) ;
2004-04-01 01:30:45 -08: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
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 )
{
2009-12-22 05:46:00 -08:00
ERR ( " %s: Error. The unexpected happened. A numeric replacement string was larger than the original! " ,
progname ) ;
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 ) ;
}
}