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
*/
2008-10-26 10:18:19 -07:00
# include <string.h>
# include <limits.h>
# include <unistd.h>
# include <sys/stat.h>
# 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
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
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 ;
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 ;
fprintf ( stderr , " %s: Error. " , progname ) ;
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
}
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
}
}
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 ) ;
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
# ifdef HAVE_EVIL
2008-08-20 20:57:56 -07:00
char * tmpdir = evil_tmpdir_get ( ) ;
2007-08-26 05:54:51 -07:00
# else
2008-08-20 20:57:56 -07:00
char * tmpdir = " /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
{
int fd ;
2008-10-22 04:34:42 -07:00
Code * cd = eina_list_data_get ( l ) ;
2007-08-26 05:54:51 -07:00
2008-08-20 20:57:56 -07:00
if ( ( ! cd - > shared ) & & ( ! cd - > programs ) )
continue ;
2007-08-26 05:54:51 -07:00
2008-08-20 20:57:56 -07:00
char tmpn [ 4096 ] ;
snprintf ( tmpn , PATH_MAX , " %s/edje_cc.sma-tmp-XXXXXX " , tmpdir ) ;
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
2008-08-20 20:57:56 -07:00
char tmpo [ 4096 ] ;
snprintf ( tmpo , PATH_MAX , " %s/edje_cc.amx-tmp-XXXXXX " , tmpdir ) ;
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
}
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 )
{
2008-08-20 20:58:11 -07:00
fprintf ( stderr , " %s: Error. Unable to open \" %s \" for writing output \n " ,
2008-08-20 20:57:20 -07:00
progname , file_out ) ;
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 ) ;
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 )
{
2008-08-20 20:58:11 -07:00
fprintf ( stderr , " %s: Error. Unable to find part name \" %s \" . \n " ,
2003-06-13 20:06:36 -07:00
progname , pl - > name ) ;
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 )
{
2008-08-20 20:58:11 -07:00
fprintf ( stderr , " %s: Error. Unable to find program name \" %s \" . \n " ,
2003-06-16 06:55:13 -07:00
progname , pl - > name ) ;
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 )
{
2008-08-20 20:58:11 -07:00
fprintf ( stderr , " %s: Error. Unable to find group name \" %s \" . \n " ,
2008-04-11 16:36:35 -07:00
progname , gl - > name ) ;
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 )
{
2008-08-20 20:58:11 -07:00
fprintf ( stderr , " %s: Error. Unable to find image name \" %s \" . \n " ,
2003-06-13 20:06:36 -07:00
progname , il - > name ) ;
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 )
{
fprintf ( stderr , " %s: Error. unable to find spectrum name %s \n " ,
progname , il - > name ) ;
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 ;
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
_data_queue_group_lookup ( Edje_Part_Collection * pc , char * name , char * ptr , int len )
{
data_queue_group_lookup ( name ) ;
}
static void
_data_queue_image_pc_lookup ( Edje_Part_Collection * pc , char * name , char * ptr , int len )
{
Code_Lookup * cl ;
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
2004-04-01 01:30:45 -08:00
if ( cd - > shared )
{
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
{
char buf [ 256 ] ;
int i , n ;
snprintf ( buf , sizeof ( buf ) , " %i " , cl - > val ) ;
n = strlen ( buf ) ;
if ( n > cl - > len )
{
fprintf ( stderr , " %s: Error. The unexpected happened. A numeric replacement string was larger than the original! \n " ,
progname ) ;
exit ( - 1 ) ;
}
for ( i = 0 ; i < cl - > len ; i + + ) cl - > ptr [ i ] = ' ' ;
strncpy ( cl - > ptr , buf , n ) ;
}
}