2008-03-06 11:48:11 -08:00
/*
* vim : ts = 8 : sw = 3 : sts = 8 : noexpandtab : cino = > 5 n - 3f 0 ^ - 2 { 2
*/
/*
* TODO
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
2009-08-17 07:49:26 -07:00
* Add LUA Support : )
2008-03-06 11:48:11 -08:00
* Remove images / fonts
2009-08-17 07:49:26 -07:00
* Clean the saving routines
2008-03-13 12:01:53 -07:00
*
2008-03-06 11:48:11 -08:00
*/
2008-10-26 10:23:54 -07:00
# ifdef HAVE_CONFIG_H
# include <config.h>
# endif
2008-10-26 10:18:19 -07:00
# include <string.h>
# include <limits.h>
# include <sys/stat.h>
# include <errno.h>
2009-08-17 07:49:26 -07:00
2009-11-03 01:26:15 -08:00
# ifndef _MSC_VER
# include <unistd.h>
# endif
2008-10-26 10:21:11 -07:00
# ifdef HAVE_LOCALE_H
# include <locale.h>
# endif
2008-10-26 10:18:19 -07:00
2009-10-08 14:45:55 -07:00
# ifdef HAVE_EVIL
# include <Evil.h>
# endif
2008-03-06 11:48:11 -08:00
# include "edje_private.h"
2009-08-17 07:49:26 -07:00
2008-03-06 11:48:11 -08:00
/* Get ed(Edje*) from obj(Evas_Object*) */
# define GET_ED_OR_RETURN(RET) \
Edje * ed ; \
ed = _edje_fetch ( obj ) ; \
if ( ! ed ) return RET ;
/* Get rp(Edje_Real_Part*) from obj(Evas_Object*) and part(char*) */
# define GET_RP_OR_RETURN(RET) \
Edje * ed ; \
Edje_Real_Part * rp ; \
ed = _edje_fetch ( obj ) ; \
if ( ! ed ) return RET ; \
rp = _edje_real_part_get ( ed , part ) ; \
if ( ! rp ) return RET ;
/* Get pd(Edje_Part_Description*) from obj(Evas_Object*), part(char*) and state (char*) */
# define GET_PD_OR_RETURN(RET) \
Edje * ed ; \
Edje_Part_Description * pd ; \
ed = _edje_fetch ( obj ) ; \
if ( ! ed ) return RET ; \
pd = _edje_part_description_find_byname ( ed , part , state ) ; \
if ( ! pd ) return RET ;
/* Get epr(Edje_Program*) from obj(Evas_Object*) and prog(char*)*/
# define GET_EPR_OR_RETURN(RET) \
Edje_Program * epr ; \
epr = _edje_program_get_byname ( obj , prog ) ; \
if ( ! epr ) return RET ;
2009-08-17 06:54:17 -07:00
static void *
_alloc ( size_t size )
2008-03-06 11:48:11 -08:00
{
void * mem ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
mem = calloc ( 1 , size ) ;
if ( mem ) return mem ;
fprintf ( stderr , " Edje_Edit: Error. memory allocation of %i bytes failed. %s \n " ,
2009-08-17 06:54:17 -07:00
( int ) size , strerror ( errno ) ) ;
2008-03-06 11:48:11 -08:00
return NULL ;
}
/*************/
/* INTERNALS */
/*************/
2009-09-17 15:38:35 -07:00
2008-03-06 11:48:11 -08:00
static Edje_Part_Description *
_edje_part_description_find_byname ( Edje * ed , const char * part , const char * state ) //state include the value in the string (ex. "default 0.00")
{
Edje_Real_Part * rp ;
Edje_Part_Description * pd ;
char * delim ;
double value ;
char * name ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
if ( ! ed | | ! part | | ! state ) return NULL ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
rp = _edje_real_part_get ( ed , part ) ;
if ( ! rp ) return NULL ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
name = strdup ( state ) ;
delim = strrchr ( name , ( int ) ' ' ) ;
if ( ! delim )
2008-03-13 12:01:53 -07:00
{
free ( name ) ;
return NULL ;
}
2008-03-13 12:08:14 -07:00
if ( sscanf ( delim , " %lf " , & value ) ! = 1 )
2008-03-13 12:01:53 -07:00
{
free ( name ) ;
return NULL ;
}
2008-03-06 11:48:11 -08:00
delim [ 0 ] = ' \0 ' ;
//printf("SEARCH DESC(%s): %s %f\n", state, state, value);
pd = _edje_part_description_find ( ed , rp , name , value ) ;
free ( name ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
if ( ! pd ) return NULL ;
return pd ;
}
static int
_edje_image_id_find ( Evas_Object * obj , const char * image_name )
{
Edje_Image_Directory_Entry * i ;
2008-10-22 04:34:42 -07:00
Eina_List * l ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
GET_ED_OR_RETURN ( - 1 ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
if ( ! ed - > file ) return - 1 ;
if ( ! ed - > file - > image_dir ) return - 1 ;
2008-03-13 12:01:53 -07:00
2008-03-13 12:08:14 -07:00
//printf("SEARCH IMAGE %s\n", image_name);
2008-03-13 12:01:53 -07:00
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ed - > file - > image_dir - > entries , l , i )
2008-03-13 12:01:53 -07:00
{
2008-03-13 12:08:14 -07:00
if ( strcmp ( image_name , i - > entry ) = = 0 )
2008-03-13 12:01:53 -07:00
{
//printf(" Found id: %d \n", i->id);
return i - > id ;
}
}
2008-03-06 11:48:11 -08:00
return - 1 ;
}
2008-03-13 12:08:14 -07:00
static const char *
2008-03-06 11:48:11 -08:00
_edje_image_name_find ( Evas_Object * obj , int image_id )
{
Edje_Image_Directory_Entry * i ;
2008-10-22 04:34:42 -07:00
Eina_List * l ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
GET_ED_OR_RETURN ( NULL ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
if ( ! ed - > file ) return NULL ;
if ( ! ed - > file - > image_dir ) return NULL ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
//printf("SEARCH IMAGE ID %d\n", image_id);
2008-03-13 12:01:53 -07:00
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ed - > file - > image_dir - > entries , l , i )
if ( image_id = = i - > id )
return i - > entry ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
return NULL ;
}
static void
_edje_real_part_free ( Edje_Real_Part * rp )
{
if ( ! rp ) return ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
if ( rp - > object )
2008-03-13 12:01:53 -07:00
{
_edje_callbacks_del ( rp - > object ) ;
evas_object_del ( rp - > object ) ;
}
2008-03-06 11:48:11 -08:00
if ( rp - > swallowed_object )
2008-03-13 12:01:53 -07:00
{
evas_object_smart_member_del ( rp - > swallowed_object ) ;
evas_object_event_callback_del ( rp - > swallowed_object ,
EVAS_CALLBACK_FREE ,
_edje_object_part_swallow_free_cb ) ;
evas_object_clip_unset ( rp - > swallowed_object ) ;
evas_object_data_del ( rp - > swallowed_object , " \377 edje.swallowing_part " ) ;
if ( rp - > part - > mouse_events )
_edje_callbacks_del ( rp - > swallowed_object ) ;
if ( rp - > part - > type = = EDJE_PART_TYPE_GROUP )
evas_object_del ( rp - > swallowed_object ) ;
rp - > swallowed_object = NULL ;
}
2008-10-15 07:11:11 -07:00
if ( rp - > text . text ) eina_stringshare_del ( rp - > text . text ) ;
if ( rp - > text . font ) eina_stringshare_del ( rp - > text . font ) ;
if ( rp - > text . cache . in_str ) eina_stringshare_del ( rp - > text . cache . in_str ) ;
if ( rp - > text . cache . out_str ) eina_stringshare_del ( rp - > text . cache . out_str ) ;
2008-03-13 12:01:53 -07:00
2009-08-14 10:19:42 -07:00
if ( rp - > custom )
_edje_collection_free_part_description_free ( rp - > custom - > description , 0 ) ;
free ( rp - > drag ) ;
eina_mempool_free ( _edje_real_part_state_mp , rp - > param2 ) ;
eina_mempool_free ( _edje_real_part_state_mp , rp - > custom ) ;
2008-03-06 11:48:11 -08:00
_edje_unref ( rp - > edje ) ;
2009-08-14 10:19:42 -07:00
eina_mempool_free ( _edje_real_part_mp , rp ) ;
2008-03-06 11:48:11 -08:00
}
2009-09-15 20:37:28 -07:00
static Eina_Bool
2008-03-06 11:48:11 -08:00
_edje_import_image_file ( Edje * ed , const char * path , int id )
{
2008-05-30 01:00:25 -07:00
char buf [ 256 ] ;
2008-03-06 11:48:11 -08:00
Evas_Object * im ;
Eet_File * eetf ;
2008-05-30 01:00:25 -07:00
void * im_data ;
int im_w , im_h ;
int im_alpha ;
int bytes ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
/* Try to load the file */
im = evas_object_image_add ( ed - > evas ) ;
if ( ! im ) return 0 ;
evas_object_image_file_set ( im , path , NULL ) ;
if ( evas_object_image_load_error_get ( im ) ! = EVAS_LOAD_ERROR_NONE )
2008-03-13 12:01:53 -07:00
{
fprintf ( stderr , " Edje_Edit: Error. unable to load image \" %s \" . "
" Missing PNG or JPEG loader modules for Evas or "
2008-03-24 01:22:01 -07:00
" file does not exist, or is not readable. \n " , path ) ;
2008-03-13 12:01:53 -07:00
evas_object_del ( im ) ;
im = NULL ;
return 0 ;
}
2008-03-06 11:48:11 -08:00
if ( ! im ) return 0 ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
/* Write the loaded image to the edje file */
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 ) ;
if ( ( ! im_data ) | | ! ( im_w > 0 ) | | ! ( im_h > 0 ) )
2008-03-13 12:01:53 -07:00
{
evas_object_del ( im ) ;
return 0 ;
}
2008-03-06 11:48:11 -08:00
/* open the eet file */
eetf = eet_open ( ed - > path , EET_FILE_MODE_READ_WRITE ) ;
if ( ! eetf )
2008-03-13 12:01:53 -07:00
{
fprintf ( stderr ,
" Edje_Edit: Error. unable to open \" %s \" for writing output \n " ,
ed - > path ) ;
evas_object_del ( im ) ;
return 0 ;
}
2008-03-06 11:48:11 -08:00
snprintf ( buf , sizeof ( buf ) , " images/%i " , id ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
/* write the image data */
2009-10-26 14:28:39 -07:00
//printf("*********** Writing images/%i to edj ******************\n", id);
2008-03-06 11:48:11 -08:00
bytes = eet_data_image_write ( eetf , buf ,
2008-03-13 12:01:53 -07:00
im_data , im_w , im_h ,
2008-03-24 01:22:01 -07:00
im_alpha ,
0 , 100 , 1 ) ;
2008-03-06 11:48:11 -08:00
if ( bytes < = 0 )
2008-03-13 12:01:53 -07:00
{
fprintf ( stderr , " Edje_Edit: Error. unable to write image part \" %s \" "
" part entry to %s \n " , buf , ed - > path ) ;
evas_object_del ( im ) ;
return 0 ;
}
2008-03-06 11:48:11 -08:00
/* Rewrite Edje_File to edj */
evas_object_del ( im ) ;
2008-03-13 12:01:53 -07:00
2009-10-26 14:28:39 -07:00
//printf("*********** Writing Edje_File* ed->file ******************\n");
2008-03-06 11:48:11 -08:00
bytes = eet_data_write ( eetf , _edje_edd_edje_file , " edje_file " , ed - > file , 1 ) ;
if ( bytes < = 0 )
2008-03-13 12:01:53 -07:00
{
fprintf ( stderr , " Edje_Edit: Error. unable to write \" edje_file \" "
" entry to \" %s \" \n " , ed - > path ) ;
eet_close ( eetf ) ;
return 0 ;
}
2008-03-06 11:48:11 -08:00
eet_close ( eetf ) ;
return 1 ;
}
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
static int
_edje_part_id_find ( Edje * ed , const char * part )
{
int id ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
for ( id = 0 ; id < ed - > table_parts_size ; id + + )
2008-03-13 12:01:53 -07:00
{
Edje_Real_Part * rp = ed - > table_parts [ id ] ;
2008-05-30 01:00:25 -07:00
2008-03-13 12:01:53 -07:00
if ( ! strcmp ( rp - > part - > name , part ) )
return id ;
}
2008-03-06 11:48:11 -08:00
return - 1 ;
}
static void
_edje_part_id_set ( Edje * ed , Edje_Real_Part * rp , int new_id )
{
/* This function change the id of a given real_part.
* All the depedency will be updated too .
2008-03-13 12:01:53 -07:00
* Also the table_parts is updated , and the current * rp in the table
2008-03-06 11:48:11 -08:00
* is lost .
* If new Id = - 1 then all the depencies will be deleted
*/
int old_id ;
Edje_Part * part ;
2008-10-22 04:34:42 -07:00
Eina_List * l , * ll ;
Edje_Part * p ;
Edje_Program * epr ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
part = rp - > part ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
if ( ! part ) return ;
2009-10-26 14:28:39 -07:00
//printf("CHANGE ID OF PART %s TO %d\n", part->name, new_id);
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
if ( ! ed | | ! part | | new_id < - 1 ) return ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
if ( part - > id = = new_id ) return ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
old_id = part - > id ;
part - > id = new_id ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
/* Fix all the dependecies in all parts... */
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ed - > collection - > parts , l , p )
2008-03-13 12:01:53 -07:00
{
2008-05-30 01:00:25 -07:00
Edje_Part_Description * d ;
2008-03-13 12:01:53 -07:00
//printf(" search id: %d in %s\n", old_id, p->name);
if ( p - > clip_to_id = = old_id ) p - > clip_to_id = new_id ;
if ( p - > dragable . confine_id = = old_id ) p - > dragable . confine_id = new_id ;
/* ...in default description */
d = p - > default_desc ;
//printf(" search in %s (%s)\n", p->name, d->state.name);
if ( d - > rel1 . id_x = = old_id ) d - > rel1 . id_x = new_id ;
if ( d - > rel1 . id_y = = old_id ) d - > rel1 . id_y = new_id ;
if ( d - > rel2 . id_x = = old_id ) d - > rel2 . id_x = new_id ;
if ( d - > rel2 . id_y = = old_id ) d - > rel2 . id_y = new_id ;
if ( d - > text . id_source = = old_id ) d - > text . id_source = new_id ;
if ( d - > text . id_text_source = = old_id ) d - > text . id_text_source = new_id ;
/* ...and in all other descriptions */
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( p - > other_desc , ll , d )
2008-03-13 12:01:53 -07:00
{
//printf(" search in %s (%s)\n", p->name, d->state.name);
if ( d - > rel1 . id_x = = old_id ) d - > rel1 . id_x = new_id ;
if ( d - > rel1 . id_y = = old_id ) d - > rel1 . id_y = new_id ;
if ( d - > rel2 . id_x = = old_id ) d - > rel2 . id_x = new_id ;
if ( d - > rel2 . id_y = = old_id ) d - > rel2 . id_y = new_id ;
if ( d - > text . id_source = = old_id ) d - > text . id_source = new_id ;
if ( d - > text . id_text_source = = old_id ) d - > text . id_text_source = new_id ;
}
}
2008-03-06 11:48:11 -08:00
/*...and also in programs targets */
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ed - > collection - > programs , l , epr )
2008-03-13 12:01:53 -07:00
{
2008-10-22 04:34:42 -07:00
Edje_Program_Target * pt ;
2008-03-13 12:01:53 -07:00
if ( epr - > action ! = EDJE_ACTION_TYPE_STATE_SET )
continue ;
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( epr - > targets , ll , pt )
2008-03-13 12:01:53 -07:00
{
if ( pt - > id = = old_id )
{
if ( new_id = = - 1 )
2008-10-22 04:34:42 -07:00
epr - > targets = eina_list_remove ( epr - > targets , pt ) ;
2008-03-13 12:01:53 -07:00
else
pt - > id = new_id ;
}
}
}
2008-03-06 11:48:11 -08:00
/* Adjust table_parts */
if ( new_id > = 0 )
2008-03-13 12:01:53 -07:00
ed - > table_parts [ new_id ] = rp ;
2008-03-06 11:48:11 -08:00
}
static void
_edje_parts_id_switch ( Edje * ed , Edje_Real_Part * rp1 , Edje_Real_Part * rp2 )
{
/* This function switch the id of two parts.
* All the depedency will be updated too .
* Also the table_parts is updated ,
* The parts list isn ' t touched
*/
int id1 ;
int id2 ;
2008-10-22 04:34:42 -07:00
Eina_List * l , * ll ;
Edje_Part * p ;
Edje_Program * epr ;
2008-03-13 12:01:53 -07:00
2009-10-26 14:28:39 -07:00
//printf("SWITCH ID OF PART %d AND %d\n", rp1->part->id, rp2->part->id);
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
if ( ! ed | | ! rp1 | | ! rp2 ) return ;
if ( rp1 = = rp2 ) return ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
id1 = rp1 - > part - > id ;
id2 = rp2 - > part - > id ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
/* Switch ids */
rp1 - > part - > id = id2 ;
rp2 - > part - > id = id1 ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
/* adjust table_parts */
ed - > table_parts [ id1 ] = rp2 ;
ed - > table_parts [ id2 ] = rp1 ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
// Fix all the dependecies in all parts...
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ed - > collection - > parts , l , p )
2008-03-13 12:01:53 -07:00
{
2008-10-22 04:34:42 -07:00
Eina_List * ll ;
2008-05-30 01:00:25 -07:00
Edje_Part_Description * d ;
2008-03-13 12:01:53 -07:00
//printf(" search id: %d in %s\n", old_id, p->name);
if ( p - > clip_to_id = = id1 ) p - > clip_to_id = id2 ;
else if ( p - > clip_to_id = = id2 ) p - > clip_to_id = id1 ;
if ( p - > dragable . confine_id = = id1 ) p - > dragable . confine_id = id2 ;
else if ( p - > dragable . confine_id = = id2 ) p - > dragable . confine_id = id1 ;
// ...in default description
d = p - > default_desc ;
// printf(" search in %s (%s)\n", p->name, d->state.name);
if ( d - > rel1 . id_x = = id1 ) d - > rel1 . id_x = id2 ;
else if ( d - > rel1 . id_x = = id2 ) d - > rel1 . id_x = id1 ;
if ( d - > rel1 . id_y = = id1 ) d - > rel1 . id_y = id2 ;
else if ( d - > rel1 . id_y = = id2 ) d - > rel1 . id_y = id1 ;
if ( d - > rel2 . id_x = = id1 ) d - > rel2 . id_x = id2 ;
else if ( d - > rel2 . id_x = = id2 ) d - > rel2 . id_x = id1 ;
if ( d - > rel2 . id_y = = id1 ) d - > rel2 . id_y = id2 ;
else if ( d - > rel2 . id_y = = id2 ) d - > rel2 . id_y = id1 ;
if ( d - > text . id_source = = id1 ) d - > text . id_source = id2 ;
else if ( d - > text . id_source = = id2 ) d - > text . id_source = id1 ;
if ( d - > text . id_text_source = = id1 ) d - > text . id_text_source = id2 ;
else if ( d - > text . id_text_source = = id2 ) d - > text . id_text_source = id2 ;
// ...and in all other descriptions
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( p - > other_desc , ll , d )
2008-03-13 12:01:53 -07:00
{
//printf(" search in %s (%s)\n", p->name, d->state.name);
if ( d - > rel1 . id_x = = id1 ) d - > rel1 . id_x = id2 ;
else if ( d - > rel1 . id_x = = id2 ) d - > rel1 . id_x = id1 ;
if ( d - > rel1 . id_y = = id1 ) d - > rel1 . id_y = id2 ;
else if ( d - > rel1 . id_y = = id2 ) d - > rel1 . id_y = id1 ;
if ( d - > rel2 . id_x = = id1 ) d - > rel2 . id_x = id2 ;
else if ( d - > rel2 . id_x = = id2 ) d - > rel2 . id_x = id1 ;
if ( d - > rel2 . id_y = = id1 ) d - > rel2 . id_y = id2 ;
else if ( d - > rel2 . id_y = = id2 ) d - > rel2 . id_y = id1 ;
if ( d - > text . id_source = = id1 ) d - > text . id_source = id2 ;
else if ( d - > text . id_source = = id2 ) d - > text . id_source = id1 ;
if ( d - > text . id_text_source = = id1 ) d - > text . id_text_source = id2 ;
else if ( d - > text . id_text_source = = id2 ) d - > text . id_text_source = id2 ;
}
}
2008-03-06 11:48:11 -08:00
//...and also in programs targets
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ed - > collection - > programs , l , epr )
2008-03-13 12:01:53 -07:00
{
2008-10-22 04:34:42 -07:00
Edje_Program_Target * pt ;
2008-03-13 12:01:53 -07:00
if ( epr - > action ! = EDJE_ACTION_TYPE_STATE_SET )
continue ;
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( epr - > targets , ll , pt )
2008-03-13 12:01:53 -07:00
{
if ( pt - > id = = id1 ) pt - > id = id2 ;
else if ( pt - > id = = id2 ) pt - > id = id1 ;
}
}
2008-03-06 11:48:11 -08:00
//TODO Real part dependencies are ok?
}
static void
_edje_fix_parts_id ( Edje * ed )
{
/* We use this to clear the id hole leaved when a part is removed.
* After the execution of this function all parts will have a right
* ( uniqe & ordered ) id . The table_parts is also updated .
*/
2008-10-22 04:34:42 -07:00
Eina_List * l ;
Edje_Part * p ;
2008-03-06 11:48:11 -08:00
int correct_id ;
int count ;
2008-05-30 01:00:25 -07:00
2009-10-26 14:28:39 -07:00
//printf("FIXING PARTS ID \n");
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
//TODO order the list first to be more robust
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
/* Give a correct id to all the parts */
correct_id = 0 ;
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ed - > collection - > parts , l , p )
2008-03-13 12:01:53 -07:00
{
//printf(" [%d]Checking part: %s id: %d\n", correct_id, p->name, p->id);
if ( p - > id ! = correct_id )
_edje_part_id_set ( ed , ed - > table_parts [ p - > id ] , correct_id ) ;
correct_id + + ;
}
2008-03-06 11:48:11 -08:00
/* If we have removed some parts realloc table_parts */
2008-10-22 04:34:42 -07:00
count = eina_list_count ( ed - > collection - > parts ) ;
2008-03-06 11:48:11 -08:00
if ( count ! = ed - > table_parts_size )
2008-03-13 12:01:53 -07:00
{
2009-08-17 07:13:26 -07:00
ed - > table_parts = realloc ( ed - > table_parts , sizeof ( Edje_Real_Part * ) * count ) ;
2008-03-13 12:01:53 -07:00
ed - > table_parts_size = count ;
}
2008-03-06 11:48:11 -08:00
//printf("\n");
}
2008-03-08 15:11:32 -08:00
static void
_edje_if_string_free ( Edje * ed , const char * str )
{
Eet_Dictionary * dict ;
2008-03-13 12:01:53 -07:00
2008-03-08 15:11:32 -08:00
if ( ! ed | | ! str ) return ;
2008-03-13 12:01:53 -07:00
2008-03-08 15:11:32 -08:00
dict = eet_dictionary_get ( ed - > file - > ef ) ;
2008-03-12 02:48:04 -07:00
if ( eet_dictionary_string_check ( dict , str ) ) return ;
2008-10-15 07:11:11 -07:00
eina_stringshare_del ( str ) ;
2008-03-08 15:11:32 -08:00
str = NULL ;
}
2008-07-13 07:29:18 -07:00
2009-08-17 07:49:26 -07:00
static Edje_Spectrum_Directory_Entry *
2008-07-12 05:48:35 -07:00
_edje_edit_spectrum_entry_get ( Edje * ed , const char * spectra )
{
Edje_Spectrum_Directory_Entry * s ;
2008-10-22 04:34:42 -07:00
Eina_List * l ;
2008-07-13 07:18:17 -07:00
2008-07-12 05:48:35 -07:00
if ( ! ed - > file | | ! spectra | | ! ed - > file - > spectrum_dir )
return NULL ;
2008-07-13 07:18:17 -07:00
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ed - > file - > spectrum_dir - > entries , l , s )
if ( ! strcmp ( s - > entry , spectra ) )
return s ;
2008-07-13 07:18:17 -07:00
return NULL ;
}
2009-08-17 07:49:26 -07:00
static Edje_Spectrum_Directory_Entry *
2008-07-13 07:18:17 -07:00
_edje_edit_spectrum_entry_get_by_id ( Edje * ed , int spectra_id )
{
2008-10-22 04:34:42 -07:00
Edje_Spectrum_Directory_Entry * s ;
Eina_List * l ;
2008-07-13 07:18:17 -07:00
if ( ! ed - > file | | ! ed - > file - > spectrum_dir )
return NULL ;
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ed - > file - > spectrum_dir - > entries , l , s )
if ( s - > id = = spectra_id )
return s ;
2008-07-13 07:18:17 -07:00
2008-07-12 05:48:35 -07:00
return NULL ;
}
2008-07-13 07:18:17 -07:00
2008-11-02 06:10:11 -08:00
static Edje_Style *
_edje_edit_style_get ( Edje * ed , const char * name )
{
Eina_List * l ;
Edje_Style * s ;
if ( ! ed | | ! ed - > file | | ! ed - > file - > styles | | ! name )
return NULL ;
EINA_LIST_FOREACH ( ed - > file - > styles , l , s )
if ( s - > name & & ! strcmp ( s - > name , name ) )
return s ;
return NULL ;
}
static Edje_Style_Tag *
_edje_edit_style_tag_get ( Edje * ed , const char * style , const char * name )
{
Eina_List * l ;
Edje_Style * s ;
Edje_Style_Tag * t ;
if ( ! ed | | ! ed - > file | | ! ed - > file - > styles | | ! name )
return NULL ;
s = _edje_edit_style_get ( ed , style ) ;
EINA_LIST_FOREACH ( s - > tags , l , t )
if ( t - > key & & ! strcmp ( t - > key , name ) )
return t ;
return NULL ;
}
2008-03-06 11:48:11 -08:00
/*****************/
/* GENERAL API */
/*****************/
EAPI void
2008-10-22 04:34:42 -07:00
edje_edit_string_list_free ( Eina_List * lst )
2008-03-06 11:48:11 -08:00
{
//printf("FREE LIST: \n");
while ( lst )
2008-03-13 12:01:53 -07:00
{
2008-10-22 04:34:42 -07:00
if ( eina_list_data_get ( lst ) ) eina_stringshare_del ( eina_list_data_get ( lst ) ) ;
//printf("FREE: %s\n", eina_list_data_get(lst));
lst = eina_list_remove ( lst , eina_list_data_get ( lst ) ) ;
2008-03-13 12:01:53 -07:00
}
2008-03-06 11:48:11 -08:00
}
EAPI void
edje_edit_string_free ( const char * str )
{
2008-10-15 07:11:11 -07:00
if ( str ) eina_stringshare_del ( str ) ;
2008-03-06 11:48:11 -08:00
}
2008-10-08 17:04:18 -07:00
EAPI const char *
edje_edit_compiler_get ( Evas_Object * obj )
{
GET_ED_OR_RETURN ( 0 ) ;
2008-10-15 07:11:11 -07:00
return eina_stringshare_add ( ed - > file - > compiler ) ;
2008-10-08 17:04:18 -07:00
}
2008-03-06 11:48:11 -08:00
/****************/
/* GROUPS API */
/****************/
2009-09-17 15:38:35 -07:00
/**
* @ brief Add an edje ( empty ) group to an edje object ' s group set .
*
* @ param obj The pointer to edje object .
* @ param name The name of the group .
*
* @ return 1 If it could allocate memory to the part group added
* or zero if not .
*
* This function adds , at run time , one more group , which will reside
* in memory , to the group set found in the . edj file which @ a obj was
* loaded with . This group can be manipulated by other API functions ,
* like @ c edje_edit_part_add ( ) , for example . If desired , the new
* group can be actually commited the respective . edj by use of @ c
* edje_edit_save ( ) .
*
*/
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_group_add ( Evas_Object * obj , const char * name )
{
Edje_Part_Collection_Directory_Entry * de ;
2008-10-22 04:34:42 -07:00
Edje_Part_Collection_Directory_Entry * d ;
2008-03-06 11:48:11 -08:00
Edje_Part_Collection * pc ;
2008-10-22 04:34:42 -07:00
Eina_List * l ;
2008-05-30 01:00:25 -07:00
int id ;
int search ;
2008-03-06 11:48:11 -08:00
//Code *cd;
2008-03-13 12:01:53 -07:00
2008-05-30 01:00:25 -07:00
GET_ED_OR_RETURN ( 0 ) ;
2009-10-26 14:28:39 -07:00
//printf("ADD GROUP: %s \n", name);
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
/* check if a group with the same name already exists */
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ed - > file - > collection_dir - > entries , l , d )
if ( ! strcmp ( d - > entry , name ) )
return 0 ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
/* Create structs */
2009-08-17 07:13:26 -07:00
de = _alloc ( sizeof ( Edje_Part_Collection_Directory_Entry ) ) ;
2008-03-06 11:48:11 -08:00
if ( ! de ) return 0 ;
2008-03-13 12:01:53 -07:00
2009-08-17 07:13:26 -07:00
pc = _alloc ( sizeof ( Edje_Part_Collection ) ) ;
2008-03-06 11:48:11 -08:00
if ( ! pc )
2008-03-13 12:01:53 -07:00
{
free ( de ) ;
return 0 ;
}
2008-03-06 11:48:11 -08:00
/* Search first free id */
2008-05-30 01:00:25 -07:00
id = 0 ;
search = 0 ;
2008-03-06 11:48:11 -08:00
while ( ! id )
2008-03-13 12:01:53 -07:00
{
2009-09-15 20:37:28 -07:00
Eina_Bool found = 0 ;
2008-05-30 01:00:25 -07:00
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ed - > file - > collection_dir - > entries , l , d )
2008-03-13 12:01:53 -07:00
{
// printf("search if %d is free [id %d]\n", search, d->id);
if ( search = = d - > id )
{
found = 1 ;
break ;
}
}
if ( ! found )
id = search ;
else
search + + ;
}
2008-03-06 11:48:11 -08:00
/* Init Edje_Part_Collection_Directory_Entry */
2009-10-26 14:28:39 -07:00
//printf(" new id: %d\n", id);
2008-03-06 11:48:11 -08:00
de - > id = id ;
2009-08-17 14:28:40 -07:00
de - > entry = strdup ( name ) ;
2008-10-22 04:34:42 -07:00
ed - > file - > collection_dir - > entries = eina_list_append ( ed - > file - > collection_dir - > entries , de ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
/* Init Edje_Part_Collection */
pc - > id = id ;
2008-03-08 15:11:32 -08:00
pc - > references = 1 ; //TODO i'm not shure about this (maybe set to 0 ?)
2008-03-06 11:48:11 -08:00
pc - > programs = NULL ;
pc - > parts = NULL ;
pc - > data = NULL ;
pc - > script = NULL ;
2008-10-15 07:11:11 -07:00
pc - > part = eina_stringshare_add ( name ) ;
2008-03-13 12:01:53 -07:00
2009-08-17 07:13:26 -07:00
//cd = _alloc(sizeof(Code));
2008-10-22 04:34:42 -07:00
//codes = eina_list_append(codes, cd);
2008-03-13 12:01:53 -07:00
2008-12-17 06:26:47 -08:00
if ( ! ed - > file - > collection_hash )
ed - > file - > collection_hash = eina_hash_string_superfast_new ( NULL ) ;
eina_hash_add ( ed - > file - > collection_hash , name , pc ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
return 1 ;
}
2009-09-17 15:38:35 -07:00
/**
* @ brief Delete an edje object ' s current group .
*
* @ param obj The pointer to the edje object .
*
* @ return @ c 1 on success , @ c 0 on failure .
*
* This function deletes the group which @ a obj is set to . This
* operation can be commited the the . edj file the object was loaded
* with by use of @ c edje_edit_save ( ) .
*
*/
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_group_del ( Evas_Object * obj )
{
2008-05-30 01:00:25 -07:00
char buf [ 32 ] ;
2008-10-22 04:34:42 -07:00
Eina_List * l ;
2008-03-06 11:48:11 -08:00
int i ;
Edje_Part_Collection * g ;
2008-05-30 01:00:25 -07:00
Eet_File * eetf ;
2008-10-22 04:34:42 -07:00
Edje_Part_Collection_Directory_Entry * e ;
2008-05-30 01:00:25 -07:00
GET_ED_OR_RETURN ( 0 ) ;
2008-03-06 11:48:11 -08:00
g = ed - > collection ;
2009-10-26 14:28:39 -07:00
//printf("REMOVE GROUP: %s [id: %d]\n", g->part, g->id);
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
/* Don't remove the last group */
2008-10-22 04:34:42 -07:00
if ( eina_list_count ( ed - > file - > collection_dir - > entries ) < 2 )
2008-03-13 12:01:53 -07:00
return 0 ;
2008-03-06 11:48:11 -08:00
/* Remove collection/id from eet file */
eetf = eet_open ( ed - > file - > path , EET_FILE_MODE_READ_WRITE ) ;
if ( ! eetf )
2008-03-13 12:01:53 -07:00
{
fprintf ( stderr , " Edje_Edit: Error. unable to open \" %s \" "
" for writing output \n " , ed - > file - > path ) ;
return 0 ;
}
2009-08-17 07:13:26 -07:00
snprintf ( buf , sizeof ( buf ) , " collections/%d " , g - > id ) ;
2008-03-06 11:48:11 -08:00
eet_delete ( eetf , buf ) ;
eet_close ( eetf ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
/* Remove all Edje_Real_Parts */
for ( i = 0 ; i < ed - > table_parts_size ; i + + )
2008-03-13 12:01:53 -07:00
_edje_real_part_free ( ed - > table_parts [ i ] ) ;
2008-03-06 11:48:11 -08:00
ed - > table_parts_size = 0 ;
free ( ed - > table_parts ) ;
ed - > table_parts = NULL ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
/* Free Group */
_edje_collection_free ( ed - > file , g ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
/* Update collection_dir */
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ed - > file - > collection_dir - > entries , l , e )
2008-03-13 12:01:53 -07:00
{
2009-10-26 14:28:39 -07:00
//printf(" id: %d entry: %s\n", e->id, e->entry);
2008-03-13 12:01:53 -07:00
if ( e - > id = = g - > id )
{
ed - > file - > collection_dir - > entries =
2008-10-22 04:34:42 -07:00
eina_list_remove_list ( ed - > file - > collection_dir - > entries , l ) ;
2008-03-13 12:01:53 -07:00
// free(e->entry); This should be right but cause a segv
free ( e ) ;
e = NULL ;
break ;
}
}
2008-03-06 11:48:11 -08:00
ed - > collection = NULL ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
if ( ed - > table_programs_size > 0 )
2008-03-13 12:01:53 -07:00
{
free ( ed - > table_programs ) ;
ed - > table_programs = NULL ;
ed - > table_programs_size = 0 ;
}
2008-03-06 11:48:11 -08:00
return 1 ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_group_exist ( Evas_Object * obj , const char * group )
{
2008-10-22 04:34:42 -07:00
Eina_List * l ;
Edje_Part_Collection_Directory_Entry * e ;
2008-05-30 01:00:25 -07:00
2008-03-13 12:01:53 -07:00
GET_ED_OR_RETURN ( 0 ) ;
2008-05-30 01:00:25 -07:00
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ed - > file - > collection_dir - > entries , l , e )
if ( e - > entry & & ! strcmp ( e - > entry , group ) )
return 1 ;
2008-03-06 11:48:11 -08:00
return 0 ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_group_name_set ( Evas_Object * obj , const char * new_name )
{
2008-10-22 04:34:42 -07:00
Eina_List * l ;
2008-05-30 01:00:25 -07:00
Edje_Part_Collection * pc ;
2008-10-22 04:34:42 -07:00
Edje_Part_Collection_Directory_Entry * pce ;
2008-03-13 12:01:53 -07:00
GET_ED_OR_RETURN ( 0 ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
if ( ! new_name ) return 0 ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
pc = ed - > collection ;
2009-09-15 20:37:28 -07:00
if ( ! strcmp ( pc - > part , new_name ) ) return 1 ;
if ( edje_edit_group_exist ( obj , new_name ) ) return 0 ;
2009-10-26 14:28:39 -07:00
//printf("Set name of current group: %s [id: %d][new name: %s]\n",
// pc->part, pc->id, new_name);
2008-03-13 12:01:53 -07:00
2008-10-15 07:11:11 -07:00
//if (pc->part && ed->file->free_strings) eina_stringshare_del(pc->part); TODO FIXME
pc - > part = eina_stringshare_add ( new_name ) ;
2008-03-13 12:01:53 -07:00
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ed - > file - > collection_dir - > entries , l , pce )
2008-03-13 12:01:53 -07:00
{
if ( pc - > id = = pce - > id )
{
2008-12-17 06:26:47 -08:00
eina_hash_del ( ed - > file - > collection_hash ,
pce - > entry , NULL ) ;
if ( ! ed - > file - > collection_hash )
ed - > file - > collection_hash = eina_hash_string_superfast_new ( NULL ) ;
eina_hash_add ( ed - > file - > collection_hash ,
new_name , pc ) ;
2008-03-13 12:01:53 -07:00
//if (pce->entry && //TODO Also this cause segv
// !eet_dictionary_string_check(eet_dictionary_get(ed->file->ef), pce->entry))
2008-10-15 07:11:11 -07:00
// eina_stringshare_del(pce->entry);
pce - > entry = eina_stringshare_add ( new_name ) ;
2008-03-13 12:01:53 -07:00
return 1 ;
}
}
2008-03-13 09:01:35 -07:00
return 0 ;
2008-03-06 11:48:11 -08:00
}
EAPI int
edje_edit_group_min_w_get ( Evas_Object * obj )
{
2009-10-26 14:28:39 -07:00
//printf("Get min_w of group\n");
2008-03-13 12:01:53 -07:00
GET_ED_OR_RETURN ( - 1 ) ;
2008-03-06 11:48:11 -08:00
if ( ! ed - > collection ) return - 1 ;
return ed - > collection - > prop . min . w ;
}
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
EAPI void
edje_edit_group_min_w_set ( Evas_Object * obj , int w )
{
2009-10-26 14:28:39 -07:00
//printf("Set min_w of group [new w: %d]\n", w);
2008-03-13 12:01:53 -07:00
GET_ED_OR_RETURN ( ) ;
2008-03-06 11:48:11 -08:00
ed - > collection - > prop . min . w = w ;
}
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
EAPI int
edje_edit_group_min_h_get ( Evas_Object * obj )
{
2009-10-26 14:28:39 -07:00
//printf("Get min_h of group\n");
2008-03-13 12:01:53 -07:00
GET_ED_OR_RETURN ( - 1 ) ;
2008-03-06 11:48:11 -08:00
if ( ! ed - > collection ) return - 1 ;
return ed - > collection - > prop . min . h ;
}
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
EAPI void
edje_edit_group_min_h_set ( Evas_Object * obj , int h )
{
2009-10-26 14:28:39 -07:00
//printf("Set min_h of group [new h: %d]\n", h);
2008-03-13 12:01:53 -07:00
GET_ED_OR_RETURN ( ) ;
2008-03-06 11:48:11 -08:00
ed - > collection - > prop . min . h = h ;
}
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
EAPI int
edje_edit_group_max_w_get ( Evas_Object * obj )
{
2009-10-26 14:28:39 -07:00
//printf("Get max_w of group\n");
2008-03-13 12:01:53 -07:00
GET_ED_OR_RETURN ( - 1 ) ;
2008-03-06 11:48:11 -08:00
if ( ! ed - > collection ) return - 1 ;
return ed - > collection - > prop . max . w ;
}
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
EAPI void
edje_edit_group_max_w_set ( Evas_Object * obj , int w )
{
2009-10-26 14:28:39 -07:00
//printf("Set max_w of group: [new w: %d]\n", w);
2008-03-13 12:01:53 -07:00
GET_ED_OR_RETURN ( ) ;
2008-03-06 11:48:11 -08:00
ed - > collection - > prop . max . w = w ;
}
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
EAPI int
edje_edit_group_max_h_get ( Evas_Object * obj )
{
2009-10-26 14:28:39 -07:00
//printf("Get max_h of group\n");
2008-03-13 12:01:53 -07:00
GET_ED_OR_RETURN ( - 1 ) ;
2008-03-06 11:48:11 -08:00
if ( ! ed - > collection ) return - 1 ;
return ed - > collection - > prop . max . h ;
}
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
EAPI void
edje_edit_group_max_h_set ( Evas_Object * obj , int h )
{
2009-10-26 14:28:39 -07:00
//printf("Set max_h of group: [new h: %d]\n", h);
2008-03-13 12:01:53 -07:00
GET_ED_OR_RETURN ( ) ;
2008-03-06 11:48:11 -08:00
ed - > collection - > prop . max . h = h ;
}
2008-09-14 15:30:15 -07:00
/***************/
/* DATA API */
/***************/
2008-10-22 04:34:42 -07:00
EAPI Eina_List *
2008-09-14 15:30:15 -07:00
edje_edit_data_list_get ( Evas_Object * obj )
{
2008-10-22 04:34:42 -07:00
Eina_List * datas , * l ;
Edje_Data * d ;
2008-09-14 15:30:15 -07:00
GET_ED_OR_RETURN ( NULL ) ;
if ( ! ed - > file | | ! ed - > file - > data )
return NULL ;
datas = NULL ;
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ed - > file - > data , l , d )
datas = eina_list_append ( datas , eina_stringshare_add ( d - > key ) ) ;
2008-09-14 15:30:15 -07:00
return datas ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-09-14 15:30:15 -07:00
edje_edit_data_add ( Evas_Object * obj , const char * itemname , const char * value )
{
2008-10-22 04:34:42 -07:00
Eina_List * l ;
2008-09-14 15:30:15 -07:00
Edje_Data * d ;
2008-10-22 04:34:42 -07:00
Edje_Data * dd ;
2008-09-14 15:30:15 -07:00
GET_ED_OR_RETURN ( 0 ) ;
if ( ! itemname | | ! ed - > file )
return 0 ;
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ed - > file - > data , l , dd )
if ( strcmp ( dd - > key , itemname ) = = 0 )
return 0 ;
2008-09-14 15:30:15 -07:00
2009-08-17 06:54:17 -07:00
d = _alloc ( sizeof ( Edje_Data ) ) ;
2008-09-14 15:30:15 -07:00
if ( ! d ) return 0 ;
2008-10-15 07:11:11 -07:00
d - > key = ( char * ) eina_stringshare_add ( itemname ) ;
if ( value ) d - > value = ( char * ) eina_stringshare_add ( value ) ;
2008-09-14 15:30:15 -07:00
else d - > value = NULL ;
2008-10-22 04:34:42 -07:00
ed - > file - > data = eina_list_append ( ed - > file - > data , d ) ;
2008-09-14 15:30:15 -07:00
return 1 ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-09-14 15:30:15 -07:00
edje_edit_data_del ( Evas_Object * obj , const char * itemname )
{
2008-10-22 04:34:42 -07:00
Eina_List * l ;
Edje_Data * d ;
2008-09-14 15:30:15 -07:00
GET_ED_OR_RETURN ( 0 ) ;
if ( ! itemname | | ! ed - > file | | ! ed - > file - > data )
return 0 ;
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ed - > file - > data , l , d )
2008-09-14 15:30:15 -07:00
{
if ( strcmp ( d - > key , itemname ) = = 0 )
{
_edje_if_string_free ( ed , d - > key ) ;
_edje_if_string_free ( ed , d - > value ) ;
2008-10-22 04:34:42 -07:00
ed - > file - > data = eina_list_remove ( ed - > file - > data , d ) ;
2008-09-14 15:30:15 -07:00
free ( d ) ;
return 1 ;
}
}
return 0 ;
}
EAPI const char *
edje_edit_data_value_get ( Evas_Object * obj , char * itemname )
{
2008-10-22 04:34:42 -07:00
Eina_List * l ;
Edje_Data * d ;
2008-09-14 15:30:15 -07:00
GET_ED_OR_RETURN ( NULL ) ;
if ( ! itemname | | ! ed - > file | | ! ed - > file - > data )
return NULL ;
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ed - > file - > data , l , d )
if ( strcmp ( d - > key , itemname ) = = 0 )
return eina_stringshare_add ( d - > value ) ;
2008-09-14 15:30:15 -07:00
return NULL ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-09-27 14:29:55 -07:00
edje_edit_data_value_set ( Evas_Object * obj , const char * itemname , const char * value )
2008-09-14 15:30:15 -07:00
{
2008-10-22 04:34:42 -07:00
Eina_List * l ;
Edje_Data * d ;
2008-09-14 15:30:15 -07:00
GET_ED_OR_RETURN ( 0 ) ;
if ( ! itemname | | ! value | | ! ed - > file | | ! ed - > file - > data )
return 0 ;
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ed - > file - > data , l , d )
if ( strcmp ( d - > key , itemname ) = = 0 )
{
_edje_if_string_free ( ed , d - > value ) ;
d - > value = ( char * ) eina_stringshare_add ( value ) ;
return 1 ;
}
2008-09-14 15:30:15 -07:00
return 0 ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-09-27 14:29:55 -07:00
edje_edit_data_name_set ( Evas_Object * obj , const char * itemname , const char * newname )
{
2008-10-22 04:34:42 -07:00
Eina_List * l ;
Edje_Data * d ;
2008-09-27 14:29:55 -07:00
GET_ED_OR_RETURN ( 0 ) ;
if ( ! itemname | | ! newname | | ! ed - > file | | ! ed - > file - > data )
return 0 ;
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ed - > file - > data , l , d )
if ( strcmp ( d - > key , itemname ) = = 0 )
{
_edje_if_string_free ( ed , d - > key ) ;
d - > key = ( char * ) eina_stringshare_add ( newname ) ;
return 1 ;
}
2008-09-27 14:29:55 -07:00
return 0 ;
}
/***********************/
/* COLOR CLASSES API */
/***********************/
2008-10-22 04:34:42 -07:00
EAPI Eina_List *
2008-09-27 14:29:55 -07:00
edje_edit_color_classes_list_get ( Evas_Object * obj )
{
2008-10-22 04:34:42 -07:00
Eina_List * classes = NULL ;
Eina_List * l ;
Edje_Color_Class * cc ;
2008-09-27 14:29:55 -07:00
GET_ED_OR_RETURN ( NULL ) ;
2008-09-28 11:44:19 -07:00
if ( ! ed - > file | | ! ed - > file - > color_classes )
2008-09-27 14:29:55 -07:00
return NULL ;
2009-10-26 14:28:39 -07:00
//printf("GET CLASSES LIST %d %d\n", eina_list_count(ed->color_classes), eina_list_count(ed->file->color_classes));
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ed - > file - > color_classes , l , cc )
classes = eina_list_append ( classes , eina_stringshare_add ( cc - > name ) ) ;
2008-09-27 14:29:55 -07:00
return classes ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-09-28 11:44:19 -07:00
edje_edit_color_class_colors_get ( Evas_Object * obj , const char * class_name , int * r , int * g , int * b , int * a , int * r2 , int * g2 , int * b2 , int * a2 , int * r3 , int * g3 , int * b3 , int * a3 )
{
2008-10-22 04:34:42 -07:00
Eina_List * l ;
Edje_Color_Class * cc ;
2008-09-28 11:44:19 -07:00
GET_ED_OR_RETURN ( 0 ) ;
if ( ! ed - > file | | ! ed - > file - > color_classes )
return 0 ;
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ed - > file - > color_classes , l , cc )
if ( ! strcmp ( cc - > name , class_name ) )
{
if ( r ) * r = cc - > r ;
if ( g ) * g = cc - > g ;
if ( b ) * b = cc - > b ;
if ( a ) * a = cc - > a ;
if ( r2 ) * r2 = cc - > r2 ;
if ( g2 ) * g2 = cc - > g2 ;
if ( b2 ) * b2 = cc - > b2 ;
if ( a2 ) * a2 = cc - > a2 ;
if ( r3 ) * r3 = cc - > r3 ;
if ( g3 ) * g3 = cc - > g3 ;
if ( b3 ) * b3 = cc - > b3 ;
if ( a3 ) * a3 = cc - > a3 ;
return 1 ;
}
2008-09-28 11:44:19 -07:00
return 0 ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-09-28 11:44:19 -07:00
edje_edit_color_class_colors_set ( Evas_Object * obj , const char * class_name , int r , int g , int b , int a , int r2 , int g2 , int b2 , int a2 , int r3 , int g3 , int b3 , int a3 )
{
2008-10-22 04:34:42 -07:00
Eina_List * l ;
Edje_Color_Class * cc ;
2008-09-28 11:44:19 -07:00
GET_ED_OR_RETURN ( 0 ) ;
if ( ! ed - > file | | ! ed - > file - > color_classes )
return 0 ;
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ed - > file - > color_classes , l , cc )
if ( ! strcmp ( cc - > name , class_name ) )
{
if ( r > - 1 ) cc - > r = r ;
if ( g > - 1 ) cc - > g = g ;
if ( b > - 1 ) cc - > b = b ;
if ( a > - 1 ) cc - > a = a ;
if ( r2 > - 1 ) cc - > r2 = r2 ;
if ( g2 > - 1 ) cc - > g2 = g2 ;
if ( b2 > - 1 ) cc - > b2 = b2 ;
if ( a2 > - 1 ) cc - > a2 = a2 ;
if ( r3 > - 1 ) cc - > r3 = r3 ;
if ( g3 > - 1 ) cc - > g3 = g3 ;
if ( b3 > - 1 ) cc - > b3 = b3 ;
if ( a3 > - 1 ) cc - > a3 = a3 ;
return 1 ;
}
2008-09-28 11:44:19 -07:00
return 0 ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-09-28 11:44:19 -07:00
edje_edit_color_class_add ( Evas_Object * obj , const char * name )
{
2008-10-22 04:34:42 -07:00
Eina_List * l ;
2008-09-28 11:44:19 -07:00
Edje_Color_Class * c ;
2008-10-22 04:34:42 -07:00
Edje_Color_Class * cc ;
2008-09-28 11:44:19 -07:00
GET_ED_OR_RETURN ( 0 ) ;
if ( ! name | | ! ed - > file )
return 0 ;
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ed - > file - > color_classes , l , cc )
if ( strcmp ( cc - > name , name ) = = 0 )
return 0 ;
2008-09-28 11:44:19 -07:00
2009-08-17 06:54:17 -07:00
c = _alloc ( sizeof ( Edje_Color_Class ) ) ;
2008-09-28 11:44:19 -07:00
if ( ! c ) return 0 ;
2008-10-15 07:11:11 -07:00
c - > name = ( char * ) eina_stringshare_add ( name ) ;
2008-09-28 11:44:19 -07:00
c - > r = c - > g = c - > b = c - > a = 255 ;
c - > r2 = c - > g2 = c - > b2 = c - > a2 = 255 ;
c - > r3 = c - > g3 = c - > b3 = c - > a3 = 255 ;
2008-10-22 04:34:42 -07:00
ed - > file - > color_classes = eina_list_append ( ed - > file - > color_classes , c ) ;
2008-09-28 11:44:19 -07:00
return 1 ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-09-28 11:44:19 -07:00
edje_edit_color_class_del ( Evas_Object * obj , const char * name )
{
2008-10-22 04:34:42 -07:00
Eina_List * l ;
Edje_Color_Class * cc ;
2008-09-28 11:44:19 -07:00
GET_ED_OR_RETURN ( 0 ) ;
if ( ! name | | ! ed - > file | | ! ed - > file - > color_classes )
return 0 ;
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ed - > file - > color_classes , l , cc )
if ( strcmp ( cc - > name , name ) = = 0 )
{
_edje_if_string_free ( ed , cc - > name ) ;
ed - > file - > color_classes = eina_list_remove ( ed - > file - > color_classes , cc ) ;
free ( cc ) ;
return 1 ;
}
2008-09-28 11:44:19 -07:00
return 0 ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-09-28 11:44:19 -07:00
edje_edit_color_class_name_set ( Evas_Object * obj , const char * name , const char * newname )
{
2008-10-22 04:34:42 -07:00
Eina_List * l ;
Edje_Color_Class * cc ;
2008-09-28 11:44:19 -07:00
GET_ED_OR_RETURN ( 0 ) ;
if ( ! ed - > file | | ! ed - > file - > color_classes )
return 0 ;
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ed - > file - > color_classes , l , cc )
if ( ! strcmp ( cc - > name , name ) )
{
_edje_if_string_free ( ed , cc - > name ) ;
cc - > name = ( char * ) eina_stringshare_add ( newname ) ;
return 1 ;
}
2008-09-28 11:44:19 -07:00
return 0 ;
}
2008-09-14 15:30:15 -07:00
2008-11-02 06:10:11 -08:00
/*********************/
/* TEXT STYLES API */
/*********************/
EAPI Eina_List *
edje_edit_styles_list_get ( Evas_Object * obj )
{
Eina_List * styles = NULL ;
Eina_List * l ;
Edje_Style * s ;
GET_ED_OR_RETURN ( NULL ) ;
if ( ! ed - > file | | ! ed - > file - > styles )
return NULL ;
2009-10-26 14:28:39 -07:00
//printf("GET STYLES LIST %d\n", eina_list_count(ed->file->styles));
2008-11-02 06:10:11 -08:00
EINA_LIST_FOREACH ( ed - > file - > styles , l , s )
styles = eina_list_append ( styles , eina_stringshare_add ( s - > name ) ) ;
return styles ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-11-02 06:10:11 -08:00
edje_edit_style_add ( Evas_Object * obj , const char * style )
{
Edje_Style * s ;
GET_ED_OR_RETURN ( 0 ) ;
2009-10-26 14:28:39 -07:00
//printf("ADD STYLE '%s'\n", style);
2008-11-02 06:10:11 -08:00
s = _edje_edit_style_get ( ed , style ) ;
if ( s ) return 0 ;
2009-08-17 06:54:17 -07:00
s = _alloc ( sizeof ( Edje_Style ) ) ;
2008-11-02 06:10:11 -08:00
if ( ! s ) return 0 ;
s - > name = ( char * ) eina_stringshare_add ( style ) ;
s - > tags = NULL ;
s - > style = NULL ;
ed - > file - > styles = eina_list_append ( ed - > file - > styles , s ) ;
return 1 ;
}
EAPI void
edje_edit_style_del ( Evas_Object * obj , const char * style )
{
Edje_Style * s ;
GET_ED_OR_RETURN ( ) ;
2009-10-26 14:28:39 -07:00
//printf("DEL STYLE '%s'\n", style);
2008-11-02 06:10:11 -08:00
s = _edje_edit_style_get ( ed , style ) ;
if ( ! s ) return ;
ed - > file - > styles = eina_list_remove ( ed - > file - > styles , s ) ;
_edje_if_string_free ( ed , s - > name ) ;
//~ //s->style HOWTO FREE ???
while ( s - > tags )
{
Edje_Style_Tag * t ;
t = s - > tags - > data ;
s - > tags = eina_list_remove ( s - > tags , t ) ;
_edje_if_string_free ( ed , t - > key ) ;
_edje_if_string_free ( ed , t - > value ) ;
_edje_if_string_free ( ed , t - > font ) ;
_edje_if_string_free ( ed , t - > text_class ) ;
free ( t ) ;
t = NULL ;
}
free ( s ) ;
s = NULL ;
s = NULL ;
}
EAPI Eina_List *
edje_edit_style_tags_list_get ( Evas_Object * obj , const char * style )
{
Eina_List * tags = NULL ;
2009-08-24 09:40:42 -07:00
Eina_List * l ;
2008-11-02 06:10:11 -08:00
Edje_Style * s ;
Edje_Style_Tag * t ;
GET_ED_OR_RETURN ( NULL ) ;
if ( ! ed - > file | | ! ed - > file - > styles | | ! style )
return NULL ;
s = _edje_edit_style_get ( ed , style ) ;
2009-10-26 14:28:39 -07:00
//printf("GET STYLE TAG LIST %d\n", eina_list_count(s->tags));
2009-08-24 09:40:42 -07:00
EINA_LIST_FOREACH ( s - > tags , l , t )
2008-11-02 06:10:11 -08:00
tags = eina_list_append ( tags , eina_stringshare_add ( t - > key ) ) ;
return tags ;
}
EAPI void
edje_edit_style_tag_name_set ( Evas_Object * obj , const char * style , const char * tag , const char * new_name )
{
Edje_Style_Tag * t ;
GET_ED_OR_RETURN ( ) ;
2009-10-26 14:28:39 -07:00
//printf("SET TAG NAME for '%s' FOR STYLE '%s'\n", tag, style);
2008-11-02 06:10:11 -08:00
if ( ! ed - > file | | ! ed - > file - > styles | | ! style | | ! tag )
return ;
t = _edje_edit_style_tag_get ( ed , style , tag ) ;
if ( ! t ) return ;
_edje_if_string_free ( ed , t - > key ) ;
t - > key = eina_stringshare_add ( new_name ) ;
}
EAPI const char *
edje_edit_style_tag_value_get ( Evas_Object * obj , const char * style , const char * tag )
{
Edje_Style_Tag * t ;
GET_ED_OR_RETURN ( NULL ) ;
2009-10-26 14:28:39 -07:00
//printf("GET TAG '%s' FOR STYLE '%s'\n", tag, style);
2008-11-02 06:10:11 -08:00
if ( ! ed - > file | | ! ed - > file - > styles | | ! style | | ! tag )
return NULL ;
t = _edje_edit_style_tag_get ( ed , style , tag ) ;
if ( t & & t - > value )
return eina_stringshare_add ( t - > value ) ;
return NULL ;
}
EAPI void
edje_edit_style_tag_value_set ( Evas_Object * obj , const char * style , const char * tag , const char * new_value )
{
Edje_Style_Tag * t ;
GET_ED_OR_RETURN ( ) ;
2009-10-26 14:28:39 -07:00
//printf("SET TAG VALUE for '%s' FOR STYLE '%s'\n", tag, style);
2008-11-02 06:10:11 -08:00
if ( ! ed - > file | | ! ed - > file - > styles | | ! style | | ! tag )
return ;
t = _edje_edit_style_tag_get ( ed , style , tag ) ;
if ( ! t ) return ;
_edje_if_string_free ( ed , t - > value ) ;
t - > value = eina_stringshare_add ( new_value ) ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-11-02 06:10:11 -08:00
edje_edit_style_tag_add ( Evas_Object * obj , const char * style , const char * tag_name )
{
Edje_Style * s ;
Edje_Style_Tag * t ;
GET_ED_OR_RETURN ( 0 ) ;
2009-10-26 14:28:39 -07:00
//printf("ADD TAG '%s' IN STYLE '%s'\n", tag_name, style);
2008-11-02 06:10:11 -08:00
t = _edje_edit_style_tag_get ( ed , style , tag_name ) ;
if ( t ) return 0 ;
s = _edje_edit_style_get ( ed , style ) ;
if ( ! s ) return 0 ;
2009-08-17 06:54:17 -07:00
t = _alloc ( sizeof ( Edje_Style_Tag ) ) ;
2008-11-02 06:10:11 -08:00
if ( ! t ) return 0 ;
t - > key = eina_stringshare_add ( tag_name ) ;
t - > value = NULL ;
t - > font = NULL ;
t - > text_class = NULL ;
s - > tags = eina_list_append ( s - > tags , t ) ;
return 1 ;
}
EAPI void
edje_edit_style_tag_del ( Evas_Object * obj , const char * style , const char * tag )
{
Edje_Style * s ;
Edje_Style_Tag * t ;
GET_ED_OR_RETURN ( ) ;
2009-10-26 14:28:39 -07:00
//printf("DEL TAG '%s' IN STYLE '%s'\n", tag, style);
2008-11-02 06:10:11 -08:00
s = _edje_edit_style_get ( ed , style ) ;
t = _edje_edit_style_tag_get ( ed , style , tag ) ;
s - > tags = eina_list_remove ( s - > tags , t ) ;
_edje_if_string_free ( ed , t - > key ) ;
_edje_if_string_free ( ed , t - > value ) ;
_edje_if_string_free ( ed , t - > font ) ;
_edje_if_string_free ( ed , t - > text_class ) ;
free ( t ) ;
t = NULL ;
}
2008-03-06 11:48:11 -08:00
/***************/
/* PARTS API */
/***************/
2008-10-22 04:34:42 -07:00
EAPI Eina_List *
2008-03-06 11:48:11 -08:00
edje_edit_parts_list_get ( Evas_Object * obj )
{
2008-10-22 04:34:42 -07:00
Eina_List * parts ;
2008-03-06 11:48:11 -08:00
int i ;
2008-03-13 12:01:53 -07:00
GET_ED_OR_RETURN ( NULL ) ;
2008-03-06 11:48:11 -08:00
//printf("EE: Found %d parts\n", ed->table_parts_size);
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
parts = NULL ;
for ( i = 0 ; i < ed - > table_parts_size ; i + + )
2008-03-13 12:01:53 -07:00
{
Edje_Real_Part * rp ;
2008-05-30 01:00:25 -07:00
2008-03-13 12:01:53 -07:00
rp = ed - > table_parts [ i ] ;
2008-10-22 04:34:42 -07:00
parts = eina_list_append ( parts , eina_stringshare_add ( rp - > part - > name ) ) ;
2008-03-13 12:01:53 -07:00
}
2008-03-06 11:48:11 -08:00
return parts ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_part_name_set ( Evas_Object * obj , const char * part , const char * new_name )
{
2008-03-13 12:01:53 -07:00
GET_RP_OR_RETURN ( 0 ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
if ( ! new_name ) return 0 ;
2009-09-15 20:37:28 -07:00
if ( ! strcmp ( part , new_name ) ) return 1 ;
2008-03-06 11:48:11 -08:00
if ( _edje_real_part_get ( ed , new_name ) ) return 0 ;
2008-03-13 12:01:53 -07:00
2009-10-26 14:28:39 -07:00
//printf("Set name of part: %s [new name: %s]\n", part, new_name);
2008-03-13 12:01:53 -07:00
2008-03-08 15:11:32 -08:00
_edje_if_string_free ( ed , rp - > part - > name ) ;
2008-10-15 07:11:11 -07:00
rp - > part - > name = ( char * ) eina_stringshare_add ( new_name ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
return 1 ;
}
2009-11-25 09:00:53 -08:00
Eina_Bool
_edje_edit_real_part_add ( Evas_Object * obj , const char * name , Edje_Part_Type type , const char * source )
2008-03-06 11:48:11 -08:00
{
Edje_Part_Collection * pc ;
Edje_Part * ep ;
Edje_Real_Part * rp ;
2008-03-13 12:01:53 -07:00
GET_ED_OR_RETURN ( 0 ) ;
2009-10-26 14:28:39 -07:00
//printf("ADD PART: %s [type: %d]\n", name, type);
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
/* Check if part already exists */
if ( _edje_real_part_get ( ed , name ) )
2009-09-15 20:37:28 -07:00
return EINA_FALSE ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
/* Alloc Edje_Part or return */
2009-08-17 06:54:17 -07:00
ep = _alloc ( sizeof ( Edje_Part ) ) ;
2009-09-15 20:37:28 -07:00
if ( ! ep ) return EINA_FALSE ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
/* Alloc Edje_Real_Part or return */
2009-08-17 06:54:17 -07:00
rp = _alloc ( sizeof ( Edje_Real_Part ) ) ;
2008-03-06 11:48:11 -08:00
if ( ! rp )
2008-03-13 12:01:53 -07:00
{
free ( ep ) ;
2009-09-15 20:37:28 -07:00
return EINA_FALSE ;
2008-03-13 12:01:53 -07:00
}
2008-03-06 11:48:11 -08:00
/* Init Edje_Part */
pc = ed - > collection ;
2008-10-22 04:34:42 -07:00
pc - > parts = eina_list_append ( pc - > parts , ep ) ;
2008-03-13 12:01:53 -07:00
2008-10-22 04:34:42 -07:00
ep - > id = eina_list_count ( pc - > parts ) - 1 ;
2008-03-06 11:48:11 -08:00
ep - > type = type ;
2008-10-15 07:11:11 -07:00
ep - > name = eina_stringshare_add ( name ) ;
2008-03-06 11:48:11 -08:00
ep - > mouse_events = 1 ;
ep - > repeat_events = 0 ;
2008-04-01 14:33:17 -07:00
ep - > ignore_flags = EVAS_EVENT_FLAG_NONE ;
2008-03-06 11:48:11 -08:00
ep - > pointer_mode = EVAS_OBJECT_POINTER_MODE_AUTOGRAB ;
ep - > precise_is_inside = 0 ;
ep - > use_alternate_font_metrics = 0 ;
ep - > clip_to_id = - 1 ;
ep - > dragable . confine_id = - 1 ;
ep - > dragable . events_id = - 1 ;
2009-11-25 09:00:53 -08:00
if ( source )
ep - > source = eina_stringshare_add ( source ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
ep - > default_desc = NULL ;
ep - > other_desc = NULL ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
/* Init Edje_Real_Part */
rp - > edje = ed ;
_edje_ref ( rp - > edje ) ;
rp - > part = ep ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
if ( ep - > type = = EDJE_PART_TYPE_RECTANGLE )
2008-03-13 12:01:53 -07:00
rp - > object = evas_object_rectangle_add ( ed - > evas ) ;
2008-03-06 11:48:11 -08:00
else if ( ep - > type = = EDJE_PART_TYPE_IMAGE )
2008-03-13 12:01:53 -07:00
rp - > object = evas_object_image_add ( ed - > evas ) ;
2008-03-06 11:48:11 -08:00
else if ( ep - > type = = EDJE_PART_TYPE_TEXT )
2008-03-13 12:01:53 -07:00
{
_edje_text_part_on_add ( ed , rp ) ;
rp - > object = evas_object_text_add ( ed - > evas ) ;
evas_object_text_font_source_set ( rp - > object , ed - > path ) ;
}
2008-03-06 11:48:11 -08:00
else if ( ep - > type = = EDJE_PART_TYPE_SWALLOW | |
2009-11-25 09:00:53 -08:00
ep - > type = = EDJE_PART_TYPE_GROUP | |
ep - > type = = EDJE_PART_TYPE_EXTERNAL )
2008-03-13 12:01:53 -07:00
{
rp - > object = evas_object_rectangle_add ( ed - > evas ) ;
evas_object_color_set ( rp - > object , 0 , 0 , 0 , 0 ) ;
evas_object_pass_events_set ( rp - > object , 1 ) ;
evas_object_pointer_mode_set ( rp - > object , EVAS_OBJECT_POINTER_MODE_NOGRAB ) ;
2009-11-25 09:00:53 -08:00
if ( ep - > type = = EDJE_PART_TYPE_EXTERNAL )
{
Evas_Object * child ;
child = _edje_external_type_add ( source , evas_object_evas_get ( obj ) , obj , NULL ) ;
if ( child )
_edje_real_part_swallow ( rp , child ) ;
}
2008-03-13 12:01:53 -07:00
}
2008-03-06 11:48:11 -08:00
else if ( ep - > type = = EDJE_PART_TYPE_TEXTBLOCK )
2008-03-13 12:01:53 -07:00
rp - > object = evas_object_textblock_add ( ed - > evas ) ;
2008-03-06 11:48:11 -08:00
else if ( ep - > type = = EDJE_PART_TYPE_GRADIENT )
2008-03-13 12:01:53 -07:00
rp - > object = evas_object_gradient_add ( ed - > evas ) ;
2008-03-06 11:48:11 -08:00
else
2008-03-13 12:01:53 -07:00
printf ( " EDJE ERROR: wrong part type %i! \n " , ep - > type ) ;
2008-03-06 11:48:11 -08:00
if ( rp - > object )
2008-03-13 12:01:53 -07:00
{
evas_object_smart_member_add ( rp - > object , ed - > obj ) ;
evas_object_layer_set ( rp - > object , evas_object_layer_get ( ed - > obj ) ) ;
if ( ep - > type ! = EDJE_PART_TYPE_SWALLOW & & ep - > type ! = EDJE_PART_TYPE_GROUP )
{
if ( ep - > mouse_events )
{
_edje_callbacks_add ( rp - > object , ed , rp ) ;
if ( ep - > repeat_events )
evas_object_repeat_events_set ( rp - > object , 1 ) ;
if ( ep - > pointer_mode ! = EVAS_OBJECT_POINTER_MODE_AUTOGRAB )
evas_object_pointer_mode_set ( rp - > object , ep - > pointer_mode ) ;
}
else
{
evas_object_pass_events_set ( rp - > object , 1 ) ;
evas_object_pointer_mode_set ( rp - > object ,
EVAS_OBJECT_POINTER_MODE_NOGRAB ) ;
}
if ( ep - > precise_is_inside )
evas_object_precise_is_inside_set ( rp - > object , 1 ) ;
}
evas_object_clip_set ( rp - > object , ed - > clipper ) ;
}
2008-03-06 11:48:11 -08:00
rp - > gradient_id = - 1 ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
/* Update table_parts */
ed - > table_parts_size + + ;
ed - > table_parts = realloc ( ed - > table_parts ,
2008-03-13 12:01:53 -07:00
sizeof ( Edje_Real_Part * ) * ed - > table_parts_size ) ;
2008-03-06 11:48:11 -08:00
ed - > table_parts [ ep - > id % ed - > table_parts_size ] = rp ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
/* Create default description */
edje_edit_state_add ( obj , name , " default " ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
rp - > param1 . description = ep - > default_desc ;
rp - > chosen_description = rp - > param1 . description ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
edje_object_calc_force ( obj ) ;
2008-03-13 12:01:53 -07:00
2009-09-15 20:37:28 -07:00
return EINA_TRUE ;
2008-03-06 11:48:11 -08:00
}
2009-11-25 09:00:53 -08:00
EAPI Eina_Bool
edje_edit_part_add ( Evas_Object * obj , const char * name , Edje_Part_Type type )
{
if ( type = = EDJE_PART_TYPE_EXTERNAL )
return EINA_FALSE ;
return _edje_edit_real_part_add ( obj , name , type , NULL ) ;
}
EAPI Eina_Bool
edje_edit_part_external_add ( Evas_Object * obj , const char * name , const char * source )
{
if ( ! source )
return EINA_FALSE ;
return _edje_edit_real_part_add ( obj , name , EDJE_PART_TYPE_EXTERNAL , source ) ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_part_del ( Evas_Object * obj , const char * part )
{
Edje_Part * ep ;
2008-05-30 01:00:25 -07:00
Edje_Part_Collection * pc ;
2008-03-06 11:48:11 -08:00
int id ;
2008-03-13 12:01:53 -07:00
GET_RP_OR_RETURN ( 0 ) ;
2008-05-30 01:00:25 -07:00
2009-10-26 14:28:39 -07:00
//printf("REMOVE PART: %s\n", part);
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
ep = rp - > part ;
id = ep - > id ;
2008-03-13 12:01:53 -07:00
2009-09-15 20:37:28 -07:00
if ( ed - > table_parts_size < = 1 ) return EINA_FALSE ; //don't remove the last part
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
/* Unlik Edje_Real_Parts that link to the removed one */
int i ;
for ( i = 0 ; i < ed - > table_parts_size ; i + + )
2008-03-13 12:01:53 -07:00
{
Edje_Real_Part * real ;
2008-05-30 01:00:25 -07:00
if ( i = = id ) continue ; //don't check the deleted id
2008-03-13 12:01:53 -07:00
real = ed - > table_parts [ i % ed - > table_parts_size ] ;
if ( real - > text . source = = rp ) real - > text . source = NULL ;
if ( real - > text . text_source = = rp ) real - > text . text_source = NULL ;
if ( real - > param1 . rel1_to_x = = rp ) real - > param1 . rel1_to_x = NULL ;
if ( real - > param1 . rel1_to_y = = rp ) real - > param1 . rel1_to_y = NULL ;
if ( real - > param1 . rel2_to_x = = rp ) real - > param1 . rel2_to_x = NULL ;
if ( real - > param1 . rel2_to_y = = rp ) real - > param1 . rel2_to_y = NULL ;
2009-08-14 10:19:42 -07:00
if ( real - > param2 )
{
if ( real - > param2 - > rel1_to_x = = rp ) real - > param2 - > rel1_to_x = NULL ;
if ( real - > param2 - > rel1_to_y = = rp ) real - > param2 - > rel1_to_y = NULL ;
if ( real - > param2 - > rel2_to_x = = rp ) real - > param2 - > rel2_to_x = NULL ;
if ( real - > param2 - > rel2_to_y = = rp ) real - > param2 - > rel2_to_y = NULL ;
}
2008-03-13 12:01:53 -07:00
2009-08-14 10:19:42 -07:00
if ( real - > custom )
{
if ( real - > custom - > rel1_to_x = = rp ) real - > custom - > rel1_to_x = NULL ;
if ( real - > custom - > rel1_to_y = = rp ) real - > custom - > rel1_to_y = NULL ;
if ( real - > custom - > rel2_to_x = = rp ) real - > custom - > rel2_to_x = NULL ;
if ( real - > custom - > rel2_to_y = = rp ) real - > custom - > rel2_to_y = NULL ;
}
2008-03-13 12:01:53 -07:00
if ( real - > clip_to = = rp )
{
evas_object_clip_set ( real - > object , ed - > clipper ) ;
real - > clip_to = NULL ;
}
2009-08-14 10:19:42 -07:00
if ( real - > drag & & real - > drag - > confine_to = = rp )
real - > drag - > confine_to = NULL ;
2008-03-13 12:01:53 -07:00
}
2008-03-06 11:48:11 -08:00
/* Unlink all the parts and descriptions that refer to id */
_edje_part_id_set ( ed , rp , - 1 ) ;
/* Remove part from parts list */
pc = ed - > collection ;
2008-10-22 04:34:42 -07:00
pc - > parts = eina_list_remove ( pc - > parts , ep ) ;
2008-03-06 11:48:11 -08:00
_edje_fix_parts_id ( ed ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
/* Free Edje_Part and all descriptions */
2008-03-08 15:11:32 -08:00
_edje_if_string_free ( ed , ep - > name ) ;
2008-03-06 11:48:11 -08:00
if ( ep - > default_desc )
2008-03-13 12:01:53 -07:00
{
_edje_collection_free_part_description_free ( ep - > default_desc , 0 ) ;
ep - > default_desc = NULL ;
}
2008-03-06 11:48:11 -08:00
while ( ep - > other_desc )
2008-03-13 12:01:53 -07:00
{
Edje_Part_Description * desc ;
2008-10-22 04:34:42 -07:00
desc = eina_list_data_get ( ep - > other_desc ) ;
ep - > other_desc = eina_list_remove ( ep - > other_desc , desc ) ;
2008-03-13 12:01:53 -07:00
_edje_collection_free_part_description_free ( desc , 0 ) ;
}
2008-03-06 11:48:11 -08:00
free ( ep ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
/* Free Edje_Real_Part */
_edje_real_part_free ( rp ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
edje_object_calc_force ( obj ) ;
2009-09-15 20:37:28 -07:00
return EINA_TRUE ;
2008-03-06 11:48:11 -08:00
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_part_exist ( Evas_Object * obj , const char * part )
{
2008-03-13 12:01:53 -07:00
GET_RP_OR_RETURN ( 0 ) ;
2008-03-06 11:48:11 -08:00
return 1 ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_part_restack_below ( Evas_Object * obj , const char * part )
{
2008-05-30 01:00:25 -07:00
Edje_Part_Collection * group ;
Edje_Real_Part * prev ;
2008-03-13 12:01:53 -07:00
GET_RP_OR_RETURN ( 0 ) ;
2009-10-26 14:28:39 -07:00
//printf("RESTACK PART: %s BELOW\n", part);
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
if ( rp - > part - > id < 1 ) return 0 ;
group = ed - > collection ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
/* update parts list */
prev = ed - > table_parts [ ( rp - > part - > id - 1 ) % ed - > table_parts_size ] ;
2008-10-22 04:34:42 -07:00
group - > parts = eina_list_remove ( group - > parts , rp - > part ) ;
group - > parts = eina_list_prepend_relative ( group - > parts , rp - > part , prev - > part ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
_edje_parts_id_switch ( ed , rp , prev ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
evas_object_stack_below ( rp - > object , prev - > object ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
return 1 ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_part_restack_above ( Evas_Object * obj , const char * part )
{
2008-05-30 01:00:25 -07:00
Edje_Part_Collection * group ;
Edje_Real_Part * next ;
2008-03-13 12:01:53 -07:00
GET_RP_OR_RETURN ( 0 ) ;
2009-10-26 14:28:39 -07:00
//printf("RESTACK PART: %s ABOVE\n", part);
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
if ( rp - > part - > id > = ed - > table_parts_size - 1 ) return 0 ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
group = ed - > collection ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
/* update parts list */
next = ed - > table_parts [ ( rp - > part - > id + 1 ) % ed - > table_parts_size ] ;
2008-10-22 04:34:42 -07:00
group - > parts = eina_list_remove ( group - > parts , rp - > part ) ;
group - > parts = eina_list_append_relative ( group - > parts , rp - > part , next - > part ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
/* update ids */
_edje_parts_id_switch ( ed , rp , next ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
evas_object_stack_above ( rp - > object , next - > object ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
return 1 ;
}
2009-09-15 20:37:28 -07:00
EAPI Edje_Part_Type
2008-03-06 11:48:11 -08:00
edje_edit_part_type_get ( Evas_Object * obj , const char * part )
{
2008-03-13 12:01:53 -07:00
GET_RP_OR_RETURN ( 0 ) ;
2008-03-06 11:48:11 -08:00
return rp - > part - > type ;
}
EAPI const char *
edje_edit_part_selected_state_get ( Evas_Object * obj , const char * part )
{
2008-06-06 11:31:49 -07:00
char name [ PATH_MAX ] ;
2008-03-13 12:01:53 -07:00
GET_RP_OR_RETURN ( NULL ) ;
2008-03-06 11:48:11 -08:00
if ( ! rp - > chosen_description )
2009-11-12 07:41:45 -08:00
return eina_stringshare_add ( " default 0.00 " ) ;
2008-03-13 12:01:53 -07:00
2008-06-06 11:31:49 -07:00
snprintf ( name , PATH_MAX , " %s %.2f " ,
2008-03-06 11:48:11 -08:00
rp - > chosen_description - > state . name ,
rp - > chosen_description - > state . value ) ;
2008-03-13 12:01:53 -07:00
2008-10-15 07:11:11 -07:00
return eina_stringshare_add ( name ) ;
2008-03-06 11:48:11 -08:00
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_part_selected_state_set ( Evas_Object * obj , const char * part , const char * state )
{
Edje_Part_Description * pd ;
2008-03-13 12:01:53 -07:00
GET_RP_OR_RETURN ( 0 ) ;
2008-03-06 11:48:11 -08:00
pd = _edje_part_description_find_byname ( ed , part , state ) ;
if ( ! pd ) return 0 ;
2009-10-26 14:28:39 -07:00
//printf("EDJE: Set state: %s\n", pd->state.name);
2008-03-13 12:08:14 -07:00
_edje_part_description_apply ( ed , rp , pd - > state . name , pd - > state . value , NULL , 0 ) ; //WHAT IS NULL , 0
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
edje_object_calc_force ( obj ) ;
return 1 ;
}
EAPI const char *
edje_edit_part_clip_to_get ( Evas_Object * obj , const char * part )
{
Edje_Real_Part * clip = NULL ;
2008-03-13 12:01:53 -07:00
2008-05-30 01:00:25 -07:00
GET_RP_OR_RETURN ( NULL ) ;
2009-10-26 14:28:39 -07:00
//printf("Get clip_to for part: %s [to_id: %d]\n", part, rp->part->clip_to_id);
2008-03-06 11:48:11 -08:00
if ( rp - > part - > clip_to_id < 0 ) return NULL ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
clip = ed - > table_parts [ rp - > part - > clip_to_id % ed - > table_parts_size ] ;
if ( ! clip | | ! clip - > part | | ! clip - > part - > name ) return NULL ;
2008-03-13 12:01:53 -07:00
2008-10-15 07:11:11 -07:00
return eina_stringshare_add ( clip - > part - > name ) ;
2008-03-06 11:48:11 -08:00
}
2008-03-13 12:01:53 -07:00
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_part_clip_to_set ( Evas_Object * obj , const char * part , const char * clip_to )
{
Edje_Real_Part * clip ;
2008-03-13 12:01:53 -07:00
2008-05-30 01:00:25 -07:00
GET_RP_OR_RETURN ( 0 ) ;
2008-03-06 11:48:11 -08:00
/* unset clipping */
if ( ! clip_to )
2008-03-13 12:01:53 -07:00
{
2009-10-26 14:28:39 -07:00
//printf("UnSet clip_to for part: %s\n", part);
2008-03-06 11:48:11 -08:00
2008-03-13 12:01:53 -07:00
if ( rp - > clip_to - > object )
{
evas_object_pointer_mode_set ( rp - > clip_to - > object ,
EVAS_OBJECT_POINTER_MODE_AUTOGRAB ) ;
evas_object_clip_unset ( rp - > object ) ;
}
2008-03-06 11:48:11 -08:00
2008-03-13 12:01:53 -07:00
evas_object_clip_set ( rp - > object , ed - > clipper ) ;
rp - > part - > clip_to_id = - 1 ;
rp - > clip_to = NULL ;
edje_object_calc_force ( obj ) ;
return 1 ;
}
2008-03-06 11:48:11 -08:00
/* set clipping */
2009-10-26 14:28:39 -07:00
//printf("Set clip_to for part: %s [to: %s]\n", part, clip_to);
2008-03-06 11:48:11 -08:00
clip = _edje_real_part_get ( ed , clip_to ) ;
if ( ! clip | | ! clip - > part ) return 0 ;
rp - > part - > clip_to_id = clip - > part - > id ;
rp - > clip_to = clip ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
evas_object_pass_events_set ( rp - > clip_to - > object , 1 ) ;
evas_object_pointer_mode_set ( rp - > clip_to - > object , EVAS_OBJECT_POINTER_MODE_NOGRAB ) ;
evas_object_clip_set ( rp - > object , rp - > clip_to - > object ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
edje_object_calc_force ( obj ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
return 1 ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_part_mouse_events_get ( Evas_Object * obj , const char * part )
{
2008-03-13 12:01:53 -07:00
GET_RP_OR_RETURN ( 0 ) ;
2008-03-13 12:08:14 -07:00
//printf("Get mouse_events for part: %s [%d]\n", part, rp->part->mouse_events);
2008-03-06 11:48:11 -08:00
return rp - > part - > mouse_events ;
}
EAPI void
2009-09-15 20:37:28 -07:00
edje_edit_part_mouse_events_set ( Evas_Object * obj , const char * part , Eina_Bool mouse_events )
2008-03-06 11:48:11 -08:00
{
2008-03-13 12:01:53 -07:00
GET_RP_OR_RETURN ( ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
if ( ! rp - > object ) return ;
2008-05-30 01:00:25 -07:00
2009-10-26 14:28:39 -07:00
//printf("Set mouse_events for part: %s [%d]\n", part, mouse_events);
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
rp - > part - > mouse_events = mouse_events ? 1 : 0 ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
if ( mouse_events )
2008-03-13 12:01:53 -07:00
{
evas_object_pass_events_set ( rp - > object , 0 ) ;
_edje_callbacks_add ( rp - > object , ed , rp ) ;
}
2008-03-06 11:48:11 -08:00
else
2008-03-13 12:01:53 -07:00
{
evas_object_pass_events_set ( rp - > object , 1 ) ;
_edje_callbacks_del ( rp - > object ) ;
}
2008-03-06 11:48:11 -08:00
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_part_repeat_events_get ( Evas_Object * obj , const char * part )
{
2008-03-13 12:01:53 -07:00
GET_RP_OR_RETURN ( 0 ) ;
2008-05-30 01:00:25 -07:00
2008-03-13 12:08:14 -07:00
//printf("Get repeat_events for part: %s [%d]\n", part, rp->part->repeat_events);
2008-03-06 11:48:11 -08:00
return rp - > part - > repeat_events ;
}
EAPI void
2009-09-15 20:37:28 -07:00
edje_edit_part_repeat_events_set ( Evas_Object * obj , const char * part , Eina_Bool repeat_events )
2008-03-06 11:48:11 -08:00
{
2008-03-13 12:01:53 -07:00
GET_RP_OR_RETURN ( ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
if ( ! rp - > object ) return ;
2008-05-30 01:00:25 -07:00
2009-10-26 14:28:39 -07:00
//printf("Set repeat_events for part: %s [%d]\n", part, repeat_events);
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
rp - > part - > repeat_events = repeat_events ? 1 : 0 ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
if ( repeat_events )
2008-03-13 12:01:53 -07:00
evas_object_repeat_events_set ( rp - > object , 1 ) ;
2008-03-06 11:48:11 -08:00
else
2008-03-13 12:01:53 -07:00
evas_object_repeat_events_set ( rp - > object , 0 ) ;
2008-03-06 11:48:11 -08:00
}
2008-04-01 14:33:17 -07:00
EAPI Evas_Event_Flags
edje_edit_part_ignore_flags_get ( Evas_Object * obj , const char * part )
{
GET_RP_OR_RETURN ( 0 ) ;
2008-05-30 01:00:25 -07:00
2008-04-01 14:33:17 -07:00
return rp - > part - > ignore_flags ;
}
EAPI void
edje_edit_part_ignore_flags_set ( Evas_Object * obj , const char * part , Evas_Event_Flags ignore_flags )
{
GET_RP_OR_RETURN ( ) ;
2008-05-30 01:00:25 -07:00
2008-04-01 14:33:17 -07:00
if ( ! rp - > object ) return ;
2009-10-26 14:28:39 -07:00
//printf("Set ignore_flags for part: %s [%#x]\n", part, ignore_flags);
2008-04-01 14:33:17 -07:00
rp - > part - > ignore_flags = ignore_flags ;
}
2008-03-06 11:48:11 -08:00
EAPI const char *
edje_edit_part_source_get ( Evas_Object * obj , const char * part )
{
//Edje_Real_Part *clip = NULL;
2008-03-13 12:01:53 -07:00
2008-05-30 01:00:25 -07:00
GET_RP_OR_RETURN ( NULL ) ;
2009-10-26 14:28:39 -07:00
//printf("Get source for part: %s\n", part);
2008-03-06 11:48:11 -08:00
if ( ! rp - > part - > source ) return NULL ;
2008-03-13 12:01:53 -07:00
2008-10-15 07:11:11 -07:00
return eina_stringshare_add ( rp - > part - > source ) ;
2008-03-06 11:48:11 -08:00
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_part_source_set ( Evas_Object * obj , const char * part , const char * source )
{
2008-03-13 12:01:53 -07:00
GET_RP_OR_RETURN ( 0 ) ;
2009-10-26 14:28:39 -07:00
//printf("Set source for part: %s [source: %s]\n", part, source);
2008-03-13 12:01:53 -07:00
2009-11-25 09:00:53 -08:00
if ( rp - > part - > type = = EDJE_PART_TYPE_EXTERNAL )
return 0 ;
2008-03-08 15:11:32 -08:00
_edje_if_string_free ( ed , rp - > part - > source ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
if ( source )
2008-10-15 07:11:11 -07:00
rp - > part - > source = eina_stringshare_add ( source ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
return 1 ;
}
2008-10-09 07:38:22 -07:00
EAPI int
edje_edit_part_drag_x_get ( Evas_Object * obj , const char * part )
{
GET_RP_OR_RETURN ( 0 ) ;
//printf("Get dragX for part: %s\n", part);
return rp - > part - > dragable . x ;
}
EAPI void
edje_edit_part_drag_x_set ( Evas_Object * obj , const char * part , int drag )
{
GET_RP_OR_RETURN ( ) ;
2009-10-26 14:28:39 -07:00
//printf("Set dragX for part: %s\n", part);
2008-10-09 07:38:22 -07:00
rp - > part - > dragable . x = drag ;
2009-08-11 05:47:00 -07:00
if ( ! drag & & ! rp - > part - > dragable . y )
{
free ( rp - > drag ) ;
rp - > drag = NULL ;
return ;
}
if ( rp - > drag ) return ;
2009-08-17 06:54:17 -07:00
rp - > drag = _alloc ( sizeof ( Edje_Real_Part_Drag ) ) ;
2009-08-11 05:47:00 -07:00
if ( ! rp - > drag ) return ;
rp - > drag - > step . x = rp - > part - > dragable . step_x ;
rp - > drag - > step . y = rp - > part - > dragable . step_y ;
2008-10-09 07:38:22 -07:00
}
EAPI int
edje_edit_part_drag_y_get ( Evas_Object * obj , const char * part )
{
GET_RP_OR_RETURN ( 0 ) ;
//printf("Get dragY for part: %s\n", part);
return rp - > part - > dragable . y ;
}
EAPI void
edje_edit_part_drag_y_set ( Evas_Object * obj , const char * part , int drag )
{
GET_RP_OR_RETURN ( ) ;
2009-10-26 14:28:39 -07:00
//printf("Set dragY for part: %s\n", part);
2008-10-09 07:38:22 -07:00
rp - > part - > dragable . y = drag ;
2009-08-11 05:47:00 -07:00
if ( ! drag & & ! rp - > part - > dragable . x )
{
free ( rp - > drag ) ;
rp - > drag = NULL ;
return ;
}
if ( rp - > drag ) return ;
2009-08-17 06:54:17 -07:00
rp - > drag = _alloc ( sizeof ( Edje_Real_Part_Drag ) ) ;
2009-08-11 05:47:00 -07:00
if ( ! rp - > drag ) return ;
rp - > drag - > step . x = rp - > part - > dragable . step_x ;
rp - > drag - > step . y = rp - > part - > dragable . step_y ;
2008-10-09 07:38:22 -07:00
}
EAPI int
edje_edit_part_drag_step_x_get ( Evas_Object * obj , const char * part )
{
GET_RP_OR_RETURN ( 0 ) ;
//printf("Get dragX_STEP for part: %s\n", part);
return rp - > part - > dragable . step_x ;
}
EAPI void
edje_edit_part_drag_step_x_set ( Evas_Object * obj , const char * part , int step )
{
GET_RP_OR_RETURN ( ) ;
2009-10-26 14:28:39 -07:00
//printf("Set dragX_STEP for part: %s\n", part);
2008-10-09 07:38:22 -07:00
rp - > part - > dragable . step_x = step ;
}
EAPI int
edje_edit_part_drag_step_y_get ( Evas_Object * obj , const char * part )
{
GET_RP_OR_RETURN ( 0 ) ;
//printf("Get dragY_STEP for part: %s\n", part);
return rp - > part - > dragable . step_y ;
}
EAPI void
edje_edit_part_drag_step_y_set ( Evas_Object * obj , const char * part , int step )
{
GET_RP_OR_RETURN ( ) ;
2009-10-26 14:28:39 -07:00
//printf("Set dragY_STEP for part: %s\n", part);
2008-10-09 07:38:22 -07:00
rp - > part - > dragable . step_y = step ;
}
EAPI int
edje_edit_part_drag_count_x_get ( Evas_Object * obj , const char * part )
{
GET_RP_OR_RETURN ( 0 ) ;
//printf("Get dragX_COUNT for part: %s\n", part);
return rp - > part - > dragable . count_x ;
}
EAPI void
edje_edit_part_drag_count_x_set ( Evas_Object * obj , const char * part , int count )
{
GET_RP_OR_RETURN ( ) ;
2009-10-26 14:28:39 -07:00
//printf("Set dragX_COUNT for part: %s\n", part);
2008-10-09 07:38:22 -07:00
rp - > part - > dragable . count_x = count ;
}
EAPI int
edje_edit_part_drag_count_y_get ( Evas_Object * obj , const char * part )
{
GET_RP_OR_RETURN ( 0 ) ;
//printf("Get dragY_COUNT for part: %s\n", part);
return rp - > part - > dragable . count_y ;
}
EAPI void
edje_edit_part_drag_count_y_set ( Evas_Object * obj , const char * part , int count )
{
GET_RP_OR_RETURN ( ) ;
2009-10-26 14:28:39 -07:00
//printf("Set dragY_COUNT for part: %s\n", part);
2008-10-09 07:38:22 -07:00
rp - > part - > dragable . count_y = count ;
}
EAPI const char *
edje_edit_part_drag_confine_get ( Evas_Object * obj , const char * part )
{
Edje_Real_Part * confine ;
//printf("******Get drag confine\n");
GET_RP_OR_RETURN ( NULL ) ;
if ( rp - > part - > dragable . confine_id < 0 )
return NULL ;
confine = ed - > table_parts [ rp - > part - > dragable . confine_id ] ;
2008-10-15 07:11:11 -07:00
return eina_stringshare_add ( confine - > part - > name ) ;
2008-10-09 07:38:22 -07:00
}
EAPI void
edje_edit_part_drag_confine_set ( Evas_Object * obj , const char * part , const char * confine )
{
Edje_Real_Part * confine_part ;
2009-10-26 14:28:39 -07:00
//printf("******Set drag confine to: %s\n", confine);
2008-10-09 07:38:22 -07:00
GET_RP_OR_RETURN ( ) ;
if ( ! confine )
{
rp - > part - > dragable . confine_id = - 1 ;
return ;
}
confine_part = _edje_real_part_get ( ed , confine ) ;
rp - > part - > dragable . confine_id = confine_part - > part - > id ;
}
EAPI const char *
edje_edit_part_drag_event_get ( Evas_Object * obj , const char * part )
{
Edje_Real_Part * events ;
//printf("******Get drag event part\n");
GET_RP_OR_RETURN ( NULL ) ;
if ( rp - > part - > dragable . events_id < 0 )
return NULL ;
events = ed - > table_parts [ rp - > part - > dragable . events_id ] ;
2008-10-15 07:11:11 -07:00
return eina_stringshare_add ( events - > part - > name ) ;
2008-10-09 07:38:22 -07:00
}
EAPI void
edje_edit_part_drag_event_set ( Evas_Object * obj , const char * part , const char * event )
{
Edje_Real_Part * event_part ;
2009-10-26 14:28:39 -07:00
//printf("******Set drag event to: %s\n", event);
2008-10-09 07:38:22 -07:00
GET_RP_OR_RETURN ( ) ;
if ( ! event )
{
rp - > part - > dragable . events_id = - 1 ;
return ;
}
event_part = _edje_real_part_get ( ed , event ) ;
rp - > part - > dragable . events_id = event_part - > part - > id ;
}
2008-03-06 11:48:11 -08:00
/*********************/
/* PART STATES API */
/*********************/
2008-10-22 04:34:42 -07:00
EAPI Eina_List *
2008-03-06 11:48:11 -08:00
edje_edit_part_states_list_get ( Evas_Object * obj , const char * part )
{
2008-06-06 11:31:49 -07:00
char state_name [ PATH_MAX ] ;
2008-10-22 04:34:42 -07:00
Eina_List * states ;
Eina_List * l ;
2008-03-06 11:48:11 -08:00
Edje_Part_Description * state ;
2008-03-13 12:01:53 -07:00
GET_RP_OR_RETURN ( NULL ) ;
2008-03-06 11:48:11 -08:00
//Is there a better place to put this? maybe edje_edit_init() ?
2008-10-26 04:55:57 -07:00
# ifdef HAVE_LOCALE_H
2008-03-06 11:48:11 -08:00
setlocale ( LC_NUMERIC , " C " ) ;
2008-10-26 04:55:57 -07:00
# endif
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
states = NULL ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
//append default state
state = rp - > part - > default_desc ;
2008-06-06 11:31:49 -07:00
snprintf ( state_name , PATH_MAX ,
2008-03-13 12:08:14 -07:00
" %s %.2f " , state - > state . name , state - > state . value ) ;
2008-10-22 04:34:42 -07:00
states = eina_list_append ( states , eina_stringshare_add ( state_name ) ) ;
2008-03-13 12:01:53 -07:00
//printf("NEW STATE def: %s\n", state->state.name);
2008-03-06 11:48:11 -08:00
//append other states
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( rp - > part - > other_desc , l , state )
2008-03-13 12:01:53 -07:00
{
snprintf ( state_name , sizeof ( state_name ) ,
2008-03-13 12:08:14 -07:00
" %s %.2f " , state - > state . name , state - > state . value ) ;
2008-10-22 04:34:42 -07:00
states = eina_list_append ( states , eina_stringshare_add ( state_name ) ) ;
2008-03-13 12:01:53 -07:00
//printf("NEW STATE: %s\n", state_name);
}
2008-03-06 11:48:11 -08:00
return states ;
}
EAPI int
edje_edit_state_name_set ( Evas_Object * obj , const char * part , const char * state , const char * new_name ) //state and new_name include the value in the string (ex. "default 0.00")
{
char * delim ;
double value ;
2008-05-30 01:00:25 -07:00
int part_id ;
int i ;
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( 0 ) ;
2009-10-26 14:28:39 -07:00
//printf("Set name of state: %s in part: %s [new name: %s]\n",
// part, state, new_name);
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
if ( ! new_name ) return 0 ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
/* split name from value */
delim = strrchr ( new_name , ( int ) ' ' ) ;
if ( ! delim ) return 0 ;
2008-03-13 12:08:14 -07:00
if ( sscanf ( delim , " %lf " , & value ) ! = 1 ) return 0 ;
2008-03-06 11:48:11 -08:00
delim [ 0 ] = ' \0 ' ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
/* update programs */
/* update the 'state' field in all programs. update only if program has
a single target */
2008-05-30 01:00:25 -07:00
part_id = _edje_part_id_find ( ed , part ) ;
2008-03-06 11:48:11 -08:00
for ( i = 0 ; i < ed - > table_programs_size ; i + + )
2008-03-13 12:01:53 -07:00
{
Edje_Program * epr = ed - > table_programs [ i ] ;
2008-05-30 01:00:25 -07:00
2008-10-22 04:34:42 -07:00
if ( eina_list_count ( epr - > targets ) = = 1 )
2008-03-13 12:01:53 -07:00
{
2008-10-22 04:34:42 -07:00
Edje_Program_Target * t = eina_list_data_get ( epr - > targets ) ;
2008-05-30 01:00:25 -07:00
2008-03-13 12:01:53 -07:00
if ( t - > id = = part_id & &
! strcmp ( epr - > state , pd - > state . name ) & &
pd - > state . value = = epr - > value )
{
_edje_if_string_free ( ed , epr - > state ) ;
2008-10-15 07:11:11 -07:00
epr - > state = eina_stringshare_add ( new_name ) ;
2008-03-13 12:01:53 -07:00
epr - > value = value ;
}
}
}
2008-03-06 11:48:11 -08:00
/* set name */
2008-03-08 15:11:32 -08:00
_edje_if_string_free ( ed , pd - > state . name ) ;
2008-10-15 07:11:11 -07:00
pd - > state . name = ( char * ) eina_stringshare_add ( new_name ) ;
2008-03-06 11:48:11 -08:00
/* set value */
pd - > state . value = value ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
delim [ 0 ] = ' ' ;
2009-10-26 14:28:39 -07:00
//printf("## SET OK %s %.2f\n", pd->state.name, pd->state.value);
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
return 1 ;
}
EAPI void
edje_edit_state_del ( Evas_Object * obj , const char * part , const char * state )
{
2008-05-30 01:00:25 -07:00
Edje_Part_Description * pd ;
2008-03-13 12:01:53 -07:00
GET_RP_OR_RETURN ( ) ;
2009-10-26 14:28:39 -07:00
//printf("REMOVE STATE: %s IN PART: %s\n", state, part);
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
pd = _edje_part_description_find_byname ( ed , part , state ) ;
if ( ! pd ) return ;
2008-03-13 12:01:53 -07:00
2008-10-22 04:34:42 -07:00
rp - > part - > other_desc = eina_list_remove ( rp - > part - > other_desc , pd ) ;
2008-03-13 12:01:53 -07:00
2008-03-13 09:01:35 -07:00
_edje_collection_free_part_description_free ( pd , 0 ) ;
2008-03-06 11:48:11 -08:00
}
EAPI void
edje_edit_state_add ( Evas_Object * obj , const char * part , const char * name )
{
2008-05-30 01:00:25 -07:00
Edje_Part_Description * pd ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
GET_RP_OR_RETURN ( ) ;
2008-03-13 12:01:53 -07:00
2009-10-26 14:28:39 -07:00
//printf("ADD STATE: %s TO PART: %s\n", name , part);
2008-05-30 01:00:25 -07:00
2009-08-17 06:54:17 -07:00
pd = _alloc ( sizeof ( Edje_Part_Description ) ) ;
if ( ! pd ) return ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
if ( ! rp - > part - > default_desc )
2008-03-13 12:01:53 -07:00
rp - > part - > default_desc = pd ;
2008-03-06 11:48:11 -08:00
else
2008-10-22 04:34:42 -07:00
rp - > part - > other_desc = eina_list_append ( rp - > part - > other_desc , pd ) ;
2008-03-13 12:01:53 -07:00
2008-10-15 07:11:11 -07:00
pd - > state . name = eina_stringshare_add ( name ) ;
2008-03-06 11:48:11 -08:00
pd - > state . value = 0.0 ;
pd - > visible = 1 ;
pd - > align . x = 0.5 ;
pd - > align . y = 0.5 ;
pd - > min . w = 0 ;
pd - > min . h = 0 ;
pd - > fixed . w = 0 ;
pd - > fixed . h = 0 ;
pd - > max . w = - 1 ;
pd - > max . h = - 1 ;
pd - > rel1 . relative_x = 0.0 ;
pd - > rel1 . relative_y = 0.0 ;
pd - > rel1 . offset_x = 0 ;
pd - > rel1 . offset_y = 0 ;
pd - > rel1 . id_x = - 1 ;
pd - > rel1 . id_y = - 1 ;
pd - > rel2 . relative_x = 1.0 ;
pd - > rel2 . relative_y = 1.0 ;
pd - > rel2 . offset_x = - 1 ;
pd - > rel2 . offset_y = - 1 ;
pd - > rel2 . id_x = - 1 ;
pd - > rel2 . id_y = - 1 ;
pd - > image . id = - 1 ;
pd - > fill . smooth = 1 ;
pd - > fill . pos_rel_x = 0.0 ;
pd - > fill . pos_abs_x = 0 ;
pd - > fill . rel_x = 1.0 ;
pd - > fill . abs_x = 0 ;
pd - > fill . pos_rel_y = 0.0 ;
pd - > fill . pos_abs_y = 0 ;
pd - > fill . rel_y = 1.0 ;
pd - > fill . abs_y = 0 ;
pd - > fill . angle = 0 ;
pd - > fill . spread = 0 ;
pd - > fill . type = EDJE_FILL_TYPE_SCALE ;
pd - > color_class = NULL ;
pd - > color . r = 255 ;
pd - > color . g = 255 ;
pd - > color . b = 255 ;
pd - > color . a = 255 ;
pd - > color2 . r = 0 ;
pd - > color2 . g = 0 ;
pd - > color2 . b = 0 ;
pd - > color2 . a = 255 ;
pd - > color3 . r = 0 ;
pd - > color3 . g = 0 ;
pd - > color3 . b = 0 ;
pd - > color3 . a = 128 ;
pd - > text . align . x = 0.5 ;
pd - > text . align . y = 0.5 ;
pd - > text . id_source = - 1 ;
pd - > text . id_text_source = - 1 ;
pd - > gradient . rel1 . relative_x = 0 ;
pd - > gradient . rel1 . relative_y = 0 ;
pd - > gradient . rel1 . offset_x = 0 ;
pd - > gradient . rel1 . offset_y = 0 ;
pd - > gradient . rel2 . relative_x = 1 ;
pd - > gradient . rel2 . relative_y = 1 ;
pd - > gradient . rel2 . offset_x = - 1 ;
pd - > gradient . rel2 . offset_y = - 1 ;
2008-07-14 18:03:24 -07:00
pd - > gradient . use_rel = 1 ;
2009-11-25 09:00:53 -08:00
if ( rp - > part - > type = = EDJE_PART_TYPE_EXTERNAL & & rp - > part - > source )
{
Edje_External_Param_Info * pi ;
pi = edje_external_param_info_get ( rp - > part - > source ) ;
while ( pi & & pi - > name )
{
Edje_External_Param * p ;
p = _alloc ( sizeof ( Edje_External_Param ) ) ;
/* error checking.. meh */
p - > name = eina_stringshare_add ( pi - > name ) ;
p - > type = pi - > type ;
switch ( p - > type )
{
case EDJE_EXTERNAL_PARAM_TYPE_INT :
p - > i = pi - > info . i . def ;
break ;
case EDJE_EXTERNAL_PARAM_TYPE_DOUBLE :
p - > d = pi - > info . d . def ;
break ;
case EDJE_EXTERNAL_PARAM_TYPE_STRING :
if ( pi - > info . s . def )
p - > s = eina_stringshare_add ( pi - > info . s . def ) ;
break ;
}
pd - > external_params = eina_list_append ( pd - > external_params , p ) ;
pi + + ;
}
if ( pd - > external_params )
rp - > param1 . external_params = _edje_external_params_parse ( rp - > swallowed_object , pd - > external_params ) ;
}
2008-03-06 11:48:11 -08:00
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_state_exist ( Evas_Object * obj , const char * part , const char * state )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( 0 ) ;
2008-03-06 11:48:11 -08:00
return 1 ;
}
2008-03-13 12:01:53 -07:00
2009-10-20 23:19:02 -07:00
EAPI Eina_Bool
edje_edit_state_copy ( Evas_Object * obj , const char * part , const char * from , const char * to )
{
Edje_Part_Description * pdfrom , * pdto ;
Edje_Part_Image_Id * i ;
2009-11-17 16:27:49 -08:00
Edje_External_Param * p ;
2009-10-20 23:19:02 -07:00
Eina_List * l ;
GET_RP_OR_RETURN ( 0 ) ;
pdfrom = _edje_part_description_find_byname ( ed , part , from ) ;
if ( ! pdfrom )
return 0 ;
pdto = _edje_part_description_find_byname ( ed , part , to ) ;
if ( ! pdto )
{
pdto = _alloc ( sizeof ( Edje_Part_Description ) ) ;
if ( ! pdto )
return 0 ;
/* No need to check for default desc, at this point it must exist */
rp - > part - > other_desc = eina_list_append ( rp - > part - > other_desc , pdto ) ;
pdto - > state . name = eina_stringshare_add ( to ) ;
pdto - > state . value = 0.0 ;
}
# define PD_COPY(_x) pdto->_x = pdfrom->_x
2009-11-17 16:27:49 -08:00
# define PD_STRING_COPY(_x) _edje_if_string_free(ed, pdto->_x); \
pdto - > _x = eina_stringshare_add ( pdfrom - > _x )
2009-10-20 23:19:02 -07:00
PD_COPY ( align . x ) ;
PD_COPY ( align . y ) ;
PD_COPY ( fixed . w ) ;
PD_COPY ( fixed . h ) ;
PD_COPY ( min . w ) ;
PD_COPY ( min . h ) ;
PD_COPY ( max . w ) ;
PD_COPY ( max . h ) ;
PD_COPY ( aspect . min ) ;
PD_COPY ( aspect . max ) ;
PD_COPY ( aspect . prefer ) ;
PD_COPY ( rel1 . relative_x ) ;
PD_COPY ( rel1 . relative_y ) ;
PD_COPY ( rel1 . offset_x ) ;
PD_COPY ( rel1 . offset_y ) ;
PD_COPY ( rel1 . id_x ) ;
PD_COPY ( rel1 . id_y ) ;
PD_COPY ( rel2 . relative_x ) ;
PD_COPY ( rel2 . relative_y ) ;
PD_COPY ( rel2 . offset_x ) ;
PD_COPY ( rel2 . offset_y ) ;
PD_COPY ( rel2 . id_x ) ;
PD_COPY ( rel2 . id_y ) ;
EINA_LIST_FREE ( pdto - > image . tween_list , i )
free ( i ) ;
EINA_LIST_FOREACH ( pdfrom - > image . tween_list , l , i )
{
Edje_Part_Image_Id * new_i ;
new_i = _alloc ( sizeof ( Edje_Part_Image_Id ) ) ;
/* error checking? What to do if failed? Rollback, abort? */
new_i - > id = i - > id ;
pdto - > image . tween_list = eina_list_append ( pdto - > image . tween_list , new_i ) ;
}
2009-11-17 16:27:49 -08:00
PD_STRING_COPY ( gradient . type ) ;
PD_STRING_COPY ( gradient . params ) ;
2009-10-20 23:19:02 -07:00
PD_COPY ( gradient . id ) ;
PD_COPY ( gradient . use_rel ) ;
PD_COPY ( gradient . rel1 . relative_x ) ;
PD_COPY ( gradient . rel1 . relative_y ) ;
PD_COPY ( gradient . rel1 . offset_x ) ;
PD_COPY ( gradient . rel1 . offset_y ) ;
PD_COPY ( gradient . rel2 . relative_x ) ;
PD_COPY ( gradient . rel2 . relative_y ) ;
PD_COPY ( gradient . rel2 . offset_x ) ;
PD_COPY ( gradient . rel2 . offset_y ) ;
PD_COPY ( border . l ) ;
PD_COPY ( border . r ) ;
PD_COPY ( border . t ) ;
PD_COPY ( border . b ) ;
PD_COPY ( border . no_fill ) ;
PD_COPY ( fill . pos_rel_x ) ;
PD_COPY ( fill . rel_x ) ;
PD_COPY ( fill . pos_rel_y ) ;
PD_COPY ( fill . rel_y ) ;
PD_COPY ( fill . pos_abs_x ) ;
PD_COPY ( fill . abs_x ) ;
PD_COPY ( fill . pos_abs_y ) ;
PD_COPY ( fill . abs_y ) ;
PD_COPY ( fill . angle ) ;
PD_COPY ( fill . spread ) ;
PD_COPY ( fill . smooth ) ;
PD_COPY ( fill . type ) ;
2009-11-17 16:27:49 -08:00
PD_STRING_COPY ( color_class ) ;
PD_STRING_COPY ( text . text ) ;
PD_STRING_COPY ( text . text_class ) ;
PD_STRING_COPY ( text . style ) ;
PD_STRING_COPY ( text . font ) ;
PD_STRING_COPY ( text . repch ) ;
2009-10-20 23:19:02 -07:00
PD_COPY ( text . align . x ) ;
PD_COPY ( text . align . y ) ;
PD_COPY ( text . elipsis ) ;
PD_COPY ( text . size ) ;
PD_COPY ( text . id_source ) ;
PD_COPY ( text . id_text_source ) ;
PD_COPY ( text . fit_x ) ;
PD_COPY ( text . fit_y ) ;
PD_COPY ( text . min_x ) ;
PD_COPY ( text . min_y ) ;
PD_COPY ( text . max_x ) ;
PD_COPY ( text . max_y ) ;
2009-11-17 16:27:49 -08:00
PD_STRING_COPY ( box . layout ) ;
PD_STRING_COPY ( box . alt_layout ) ;
2009-10-20 23:19:02 -07:00
PD_COPY ( box . align . x ) ;
PD_COPY ( box . align . y ) ;
PD_COPY ( box . padding . x ) ;
PD_COPY ( box . padding . y ) ;
PD_COPY ( box . min . h ) ;
PD_COPY ( box . min . v ) ;
PD_COPY ( table . homogeneous ) ;
PD_COPY ( table . align . x ) ;
PD_COPY ( table . align . y ) ;
PD_COPY ( table . padding . x ) ;
PD_COPY ( table . padding . y ) ;
PD_COPY ( color . r ) ;
PD_COPY ( color . g ) ;
PD_COPY ( color . b ) ;
PD_COPY ( color . a ) ;
PD_COPY ( color2 . r ) ;
PD_COPY ( color2 . g ) ;
PD_COPY ( color2 . b ) ;
PD_COPY ( color2 . a ) ;
PD_COPY ( color3 . r ) ;
PD_COPY ( color3 . g ) ;
PD_COPY ( color3 . b ) ;
PD_COPY ( color3 . a ) ;
2009-11-17 16:27:49 -08:00
/* XXX: optimize this, most likely we don't need to remove and add */
EINA_LIST_FREE ( pdto - > external_params , p )
{
_edje_if_string_free ( ed , p - > name ) ;
if ( p - > s )
_edje_if_string_free ( ed , p - > s ) ;
free ( p ) ;
}
EINA_LIST_FOREACH ( pdfrom - > external_params , l , p )
{
Edje_External_Param * new_p ;
new_p = _alloc ( sizeof ( Edje_External_Param ) ) ;
new_p - > name = eina_stringshare_add ( p - > name ) ;
new_p - > type = p - > type ;
switch ( p - > type )
{
case EDJE_EXTERNAL_PARAM_TYPE_INT :
new_p - > i = p - > i ;
break ;
case EDJE_EXTERNAL_PARAM_TYPE_DOUBLE :
new_p - > d = p - > d ;
break ;
case EDJE_EXTERNAL_PARAM_TYPE_STRING :
new_p - > s = eina_stringshare_add ( p - > s ) ;
break ;
default :
break ;
}
}
2009-10-20 23:19:02 -07:00
PD_COPY ( visible ) ;
2009-11-17 16:27:49 -08:00
# undef PD_STRING_COPY
2009-10-20 23:19:02 -07:00
# undef PD_COPY
return 1 ;
}
2008-03-06 11:48:11 -08:00
//relative
EAPI double
edje_edit_state_rel1_relative_x_get ( Evas_Object * obj , const char * part , const char * state )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( 0 ) ;
2008-03-13 12:08:14 -07:00
//printf("Get rel1 rel of part: %s state: %s [%f]\n", part, state, pd->rel1.relative_x);
2008-03-06 11:48:11 -08:00
return pd - > rel1 . relative_x ;
}
EAPI double
edje_edit_state_rel1_relative_y_get ( Evas_Object * obj , const char * part , const char * state )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( 0 ) ;
2008-03-13 12:08:14 -07:00
//printf("Get rel1 rel of part: %s state: %s\n", part, state);
2008-03-06 11:48:11 -08:00
return pd - > rel1 . relative_y ;
}
EAPI double
edje_edit_state_rel2_relative_x_get ( Evas_Object * obj , const char * part , const char * state )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( 0 ) ;
2008-03-13 12:08:14 -07:00
//printf("Get rel2 rel of part: %s state: %s\n", part, state);
2008-03-06 11:48:11 -08:00
return pd - > rel2 . relative_x ;
}
EAPI double
edje_edit_state_rel2_relative_y_get ( Evas_Object * obj , const char * part , const char * state )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( 0 ) ;
2008-03-13 12:08:14 -07:00
//printf("Get rel2 rel of part: %s state: %s\n", part, state);
2008-03-06 11:48:11 -08:00
return pd - > rel2 . relative_y ;
}
EAPI void
edje_edit_state_rel1_relative_x_set ( Evas_Object * obj , const char * part , const char * state , double x )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( ) ;
2008-03-06 11:48:11 -08:00
//printf("Set rel1x of part: %s state: %s to: %f\n", part, state, x);
//TODO check boudaries
pd - > rel1 . relative_x = x ;
edje_object_calc_force ( obj ) ;
}
EAPI void
edje_edit_state_rel1_relative_y_set ( Evas_Object * obj , const char * part , const char * state , double y )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( ) ;
2008-03-06 11:48:11 -08:00
//printf("Set rel1y of part: %s state: %s to: %f\n", part, state, y);
//TODO check boudaries
pd - > rel1 . relative_y = y ;
edje_object_calc_force ( obj ) ;
}
EAPI void
edje_edit_state_rel2_relative_x_set ( Evas_Object * obj , const char * part , const char * state , double x )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( ) ;
2008-03-06 11:48:11 -08:00
//printf("Set rel2x of part: %s state: %s to: %f\n", part, state, x);
//TODO check boudaries
pd - > rel2 . relative_x = x ;
edje_object_calc_force ( obj ) ;
}
EAPI void
edje_edit_state_rel2_relative_y_set ( Evas_Object * obj , const char * part , const char * state , double y )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( ) ;
2008-03-06 11:48:11 -08:00
//printf("Set rel2y of part: %s state: %s to: %f\n", part, state, y);
pd = _edje_part_description_find_byname ( ed , part , state ) ;
//TODO check boudaries
pd - > rel2 . relative_y = y ;
edje_object_calc_force ( obj ) ;
}
//offset
EAPI int
edje_edit_state_rel1_offset_x_get ( Evas_Object * obj , const char * part , const char * state )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( 0 ) ;
2008-03-13 12:08:14 -07:00
//printf("Get rel1 offset of part: %s state: %s\n", part, state);
2008-03-06 11:48:11 -08:00
return pd - > rel1 . offset_x ;
}
EAPI int
edje_edit_state_rel1_offset_y_get ( Evas_Object * obj , const char * part , const char * state )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( 0 ) ;
2008-03-13 12:08:14 -07:00
//printf("Get rel1 offset of part: %s state: %s\n", part, state);
2008-03-06 11:48:11 -08:00
return pd - > rel1 . offset_y ;
}
EAPI int
edje_edit_state_rel2_offset_x_get ( Evas_Object * obj , const char * part , const char * state )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( 0 ) ;
2008-03-13 12:08:14 -07:00
//printf("Get rel2 offset of part: %s state: %s\n", part, state);
2008-03-06 11:48:11 -08:00
return pd - > rel2 . offset_x ;
}
EAPI int
edje_edit_state_rel2_offset_y_get ( Evas_Object * obj , const char * part , const char * state )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( 0 ) ;
2008-03-13 12:08:14 -07:00
//printf("Get rel2 offset of part: %s state: %s\n", part, state);
2008-03-06 11:48:11 -08:00
return pd - > rel2 . offset_y ;
}
EAPI void
edje_edit_state_rel1_offset_x_set ( Evas_Object * obj , const char * part , const char * state , double x )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( ) ;
2009-10-26 14:28:39 -07:00
//printf("Set rel1x offset of part: %s state: %s to: %f\n", part, state, x);
2008-03-06 11:48:11 -08:00
//TODO check boudaries
pd - > rel1 . offset_x = x ;
edje_object_calc_force ( obj ) ;
}
EAPI void
edje_edit_state_rel1_offset_y_set ( Evas_Object * obj , const char * part , const char * state , double y )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( ) ;
2009-10-26 14:28:39 -07:00
//printf("Set rel1y offset of part: %s state: %s to: %f\n", part, state, y);
2008-03-06 11:48:11 -08:00
//TODO check boudaries
pd - > rel1 . offset_y = y ;
edje_object_calc_force ( obj ) ;
}
EAPI void
edje_edit_state_rel2_offset_x_set ( Evas_Object * obj , const char * part , const char * state , double x )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( ) ;
2009-10-26 14:28:39 -07:00
//printf("Set rel2x offset of part: %s state: %s to: %f\n", part, state, x);
2008-03-06 11:48:11 -08:00
//TODO check boudaries
pd - > rel2 . offset_x = x ;
edje_object_calc_force ( obj ) ;
}
EAPI void
edje_edit_state_rel2_offset_y_set ( Evas_Object * obj , const char * part , const char * state , double y )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( ) ;
2009-10-26 14:28:39 -07:00
//printf("Set rel2y offset of part: %s state: %s to: %f\n", part, state, y);
2008-03-06 11:48:11 -08:00
//TODO check boudaries
pd - > rel2 . offset_y = y ;
edje_object_calc_force ( obj ) ;
}
//relative to
EAPI const char *
edje_edit_state_rel1_to_x_get ( Evas_Object * obj , const char * part , const char * state )
{
Edje_Real_Part * rel ;
2008-05-30 01:00:25 -07:00
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( NULL ) ;
2008-05-30 01:00:25 -07:00
2008-03-13 12:08:14 -07:00
//printf("Get rel1x TO of part: %s state: %s\n", part, state);
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
if ( pd - > rel1 . id_x = = - 1 ) return NULL ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
rel = ed - > table_parts [ pd - > rel1 . id_x % ed - > table_parts_size ] ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
if ( rel - > part - > name )
2008-10-15 07:11:11 -07:00
return eina_stringshare_add ( rel - > part - > name ) ;
2008-03-06 11:48:11 -08:00
else
2008-03-13 12:01:53 -07:00
return NULL ;
2008-03-06 11:48:11 -08:00
}
EAPI const char *
edje_edit_state_rel1_to_y_get ( Evas_Object * obj , const char * part , const char * state )
{
Edje_Real_Part * rel ;
2008-05-30 01:00:25 -07:00
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( NULL ) ;
2008-05-30 01:00:25 -07:00
2008-03-13 12:08:14 -07:00
//printf("Get rel1y TO of part: %s state: %s\n", part, state);
2008-03-06 11:48:11 -08:00
if ( pd - > rel1 . id_y = = - 1 ) return NULL ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
rel = ed - > table_parts [ pd - > rel1 . id_y % ed - > table_parts_size ] ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
if ( rel - > part - > name )
2008-10-15 07:11:11 -07:00
return eina_stringshare_add ( rel - > part - > name ) ;
2008-03-06 11:48:11 -08:00
else
2008-03-13 12:01:53 -07:00
return NULL ;
2008-03-06 11:48:11 -08:00
}
EAPI const char *
edje_edit_state_rel2_to_x_get ( Evas_Object * obj , const char * part , const char * state )
{
Edje_Real_Part * rel ;
2008-05-30 01:00:25 -07:00
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( NULL ) ;
2008-05-30 01:00:25 -07:00
2008-03-13 12:08:14 -07:00
//printf("Get rel2x TO of part: %s state: %s\n", part, state);
2008-03-06 11:48:11 -08:00
if ( pd - > rel2 . id_x = = - 1 ) return NULL ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
rel = ed - > table_parts [ pd - > rel2 . id_x % ed - > table_parts_size ] ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
if ( rel - > part - > name )
2008-10-15 07:11:11 -07:00
return eina_stringshare_add ( rel - > part - > name ) ;
2008-03-06 11:48:11 -08:00
else
2008-03-13 12:01:53 -07:00
return NULL ;
2008-03-06 11:48:11 -08:00
}
EAPI const char *
edje_edit_state_rel2_to_y_get ( Evas_Object * obj , const char * part , const char * state )
{
Edje_Real_Part * rel ;
2008-05-30 01:00:25 -07:00
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( NULL ) ;
2008-05-30 01:00:25 -07:00
2008-03-13 12:08:14 -07:00
//printf("Get rel2y TO of part: %s state: %s\n", part, state);
2008-03-06 11:48:11 -08:00
if ( pd - > rel2 . id_y = = - 1 ) return NULL ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
rel = ed - > table_parts [ pd - > rel2 . id_y % ed - > table_parts_size ] ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
if ( rel - > part - > name )
2008-10-15 07:11:11 -07:00
return eina_stringshare_add ( rel - > part - > name ) ;
2008-03-06 11:48:11 -08:00
else
2008-03-13 12:01:53 -07:00
return NULL ;
2008-03-06 11:48:11 -08:00
}
EAPI void
//note after this call edje_edit_part_selected_state_set() to update !! need to fix this
edje_edit_state_rel1_to_x_set ( Evas_Object * obj , const char * part , const char * state , const char * rel_to )
{
Edje_Real_Part * relp ;
2008-05-30 01:00:25 -07:00
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( ) ;
2008-05-30 01:00:25 -07:00
2009-10-26 14:28:39 -07:00
//printf("Set rel1 to x on state: %s (to part: )\n", state);
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
if ( rel_to )
2008-03-13 12:01:53 -07:00
{
relp = _edje_real_part_get ( ed , rel_to ) ;
if ( ! relp ) return ;
pd - > rel1 . id_x = relp - > part - > id ;
}
2008-03-06 11:48:11 -08:00
else
2008-03-13 12:01:53 -07:00
pd - > rel1 . id_x = - 1 ;
2008-03-06 11:48:11 -08:00
//_edje_part_description_apply(ed, rp, pd->state.name, pd->state.value, "state", 0.1); //Why segfault??
// edje_object_calc_force(obj);//don't work for redraw
}
EAPI void
//note after this call edje_edit_part_selected_state_set() to update !! need to fix this
edje_edit_state_rel1_to_y_set ( Evas_Object * obj , const char * part , const char * state , const char * rel_to )
{
Edje_Real_Part * relp ;
2008-05-30 01:00:25 -07:00
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( ) ;
2008-03-13 12:08:14 -07:00
//printf("Set rel1 to y on state: %s (to part: %s)\n", state, rel_to);
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
if ( rel_to )
2008-03-13 12:01:53 -07:00
{
relp = _edje_real_part_get ( ed , rel_to ) ;
if ( ! relp ) return ;
pd - > rel1 . id_y = relp - > part - > id ;
}
2008-03-06 11:48:11 -08:00
else
2008-03-13 12:01:53 -07:00
pd - > rel1 . id_y = - 1 ;
2008-03-06 11:48:11 -08:00
//_edje_part_description_apply(ed, rp, pd->state.name, pd->state.value, "state", 0.1); //Why segfault??
// edje_object_calc_force(obj);//don't work for redraw
}
EAPI void
//note after this call edje_edit_part_selected_state_set() to update !! need to fix this
edje_edit_state_rel2_to_x_set ( Evas_Object * obj , const char * part , const char * state , const char * rel_to )
{
Edje_Real_Part * relp ;
2008-05-30 01:00:25 -07:00
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( ) ;
2008-05-30 01:00:25 -07:00
2009-10-26 14:28:39 -07:00
//printf("Set rel2 to x on state: %s (to part: )\n", state);
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
if ( rel_to )
2008-03-13 12:01:53 -07:00
{
relp = _edje_real_part_get ( ed , rel_to ) ;
if ( ! relp ) return ;
pd - > rel2 . id_x = relp - > part - > id ;
}
2008-03-06 11:48:11 -08:00
else
2008-03-13 12:01:53 -07:00
pd - > rel2 . id_x = - 1 ;
2008-03-06 11:48:11 -08:00
//_edje_part_description_apply(ed, rp, pd->state.name, pd->state.value, "state", 0.1); //Why segfault??
// edje_object_calc_force(obj);//don't work for redraw
}
EAPI void
//note after this call edje_edit_part_selected_state_set() to update !! need to fix this
edje_edit_state_rel2_to_y_set ( Evas_Object * obj , const char * part , const char * state , const char * rel_to )
{
Edje_Real_Part * relp ;
2008-05-30 01:00:25 -07:00
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( ) ;
2008-05-30 01:00:25 -07:00
2008-03-13 12:08:14 -07:00
//printf("Set rel2 to y on state: %s (to part: %s)\n", state, rel_to);
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
if ( rel_to )
2008-03-13 12:01:53 -07:00
{
relp = _edje_real_part_get ( ed , rel_to ) ;
if ( ! relp ) return ;
pd - > rel2 . id_y = relp - > part - > id ;
}
2008-03-06 11:48:11 -08:00
else
pd - > rel2 . id_y = - 1 ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
//_edje_part_description_apply(ed, rp, pd->state.name, pd->state.value, "state", 0.1); //Why segfault??
// edje_object_calc_force(obj);//don't work for redraw
}
//colors
EAPI void
edje_edit_state_color_get ( Evas_Object * obj , const char * part , const char * state , int * r , int * g , int * b , int * a )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
//printf("GET COLOR of state '%s'\n", state);
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
if ( r ) * r = pd - > color . r ;
if ( g ) * g = pd - > color . g ;
if ( b ) * b = pd - > color . b ;
if ( a ) * a = pd - > color . a ;
}
EAPI void
edje_edit_state_color2_get ( Evas_Object * obj , const char * part , const char * state , int * r , int * g , int * b , int * a )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
//printf("GET COLOR2 of state '%s'\n", state);
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
if ( r ) * r = pd - > color2 . r ;
if ( g ) * g = pd - > color2 . g ;
if ( b ) * b = pd - > color2 . b ;
if ( a ) * a = pd - > color2 . a ;
}
EAPI void
edje_edit_state_color3_get ( Evas_Object * obj , const char * part , const char * state , int * r , int * g , int * b , int * a )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
//printf("GET COLOR3 of state '%s'\n", state);
if ( r ) * r = pd - > color3 . r ;
if ( g ) * g = pd - > color3 . g ;
if ( b ) * b = pd - > color3 . b ;
if ( a ) * a = pd - > color3 . a ;
}
EAPI void
edje_edit_state_color_set ( Evas_Object * obj , const char * part , const char * state , int r , int g , int b , int a )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
//printf("SET COLOR of state '%s'\n", state);
if ( r > - 1 & & r < 256 ) pd - > color . r = r ;
if ( g > - 1 & & g < 256 ) pd - > color . g = g ;
if ( b > - 1 & & b < 256 ) pd - > color . b = b ;
if ( a > - 1 & & a < 256 ) pd - > color . a = a ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
edje_object_calc_force ( obj ) ;
}
EAPI void
edje_edit_state_color2_set ( Evas_Object * obj , const char * part , const char * state , int r , int g , int b , int a )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
//printf("SET COLOR2 of state '%s'\n", state);
if ( r > - 1 & & r < 256 ) pd - > color2 . r = r ;
if ( g > - 1 & & g < 256 ) pd - > color2 . g = g ;
if ( b > - 1 & & b < 256 ) pd - > color2 . b = b ;
if ( a > - 1 & & a < 256 ) pd - > color2 . a = a ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
edje_object_calc_force ( obj ) ;
}
EAPI void
edje_edit_state_color3_set ( Evas_Object * obj , const char * part , const char * state , int r , int g , int b , int a )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
//printf("SET COLOR3 of state '%s'\n", state);
if ( r > - 1 & & r < 256 ) pd - > color3 . r = r ;
if ( g > - 1 & & g < 256 ) pd - > color3 . g = g ;
if ( b > - 1 & & b < 256 ) pd - > color3 . b = b ;
if ( a > - 1 & & a < 256 ) pd - > color3 . a = a ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
edje_object_calc_force ( obj ) ;
}
//align
EAPI double
edje_edit_state_align_x_get ( Evas_Object * obj , const char * part , const char * state )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( 0 ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
//printf("GET ALIGN_X of state '%s' [%f]\n", state, pd->align.x);
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
return pd - > align . x ;
}
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
EAPI double
edje_edit_state_align_y_get ( Evas_Object * obj , const char * part , const char * state )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( 0 ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
//printf("GET ALIGN_Y of state '%s' [%f]\n", state, pd->align.y);
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
return pd - > align . y ;
}
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
EAPI void
edje_edit_state_align_x_set ( Evas_Object * obj , const char * part , const char * state , double align )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( ) ;
2009-10-26 14:28:39 -07:00
//printf("SET ALIGN_X of state '%s' [to: %f]\n", state, align);
2008-03-06 11:48:11 -08:00
pd - > align . x = align ;
}
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
EAPI void
edje_edit_state_align_y_set ( Evas_Object * obj , const char * part , const char * state , double align )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( ) ;
2008-05-30 01:00:25 -07:00
2009-10-26 14:28:39 -07:00
//printf("SET ALIGN_Y of state '%s' [to: %f]\n", state, align);
2008-03-06 11:48:11 -08:00
pd - > align . y = align ;
}
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
//min & max
EAPI int
edje_edit_state_min_w_get ( Evas_Object * obj , const char * part , const char * state )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( 0 ) ;
2008-05-30 01:00:25 -07:00
2009-10-26 14:28:39 -07:00
//printf("GET MIN_W of state '%s' [%d]\n", state, pd->min.w);
2008-03-06 11:48:11 -08:00
return pd - > min . w ;
}
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
EAPI void
edje_edit_state_min_w_set ( Evas_Object * obj , const char * part , const char * state , int min_w )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( ) ;
2008-05-30 01:00:25 -07:00
2009-10-26 14:28:39 -07:00
//printf("SET MIN_W of state '%s' [to: %d]\n", state, min_w);
2008-03-06 11:48:11 -08:00
pd - > min . w = min_w ;
}
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
EAPI int
edje_edit_state_min_h_get ( Evas_Object * obj , const char * part , const char * state )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( 0 ) ;
2008-05-30 01:00:25 -07:00
2009-10-26 14:28:39 -07:00
//printf("GET MIN_H of state '%s' [%d]\n", state, pd->min.h);
2008-03-06 11:48:11 -08:00
return pd - > min . h ;
}
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
EAPI void
edje_edit_state_min_h_set ( Evas_Object * obj , const char * part , const char * state , int min_h )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( ) ;
2008-05-30 01:00:25 -07:00
2009-10-26 14:28:39 -07:00
//printf("SET MIN_H of state '%s' [to: %d]\n", state, min_h);
2008-03-06 11:48:11 -08:00
pd - > min . h = min_h ;
}
EAPI int
edje_edit_state_max_w_get ( Evas_Object * obj , const char * part , const char * state )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( 0 ) ;
2008-05-30 01:00:25 -07:00
2009-10-26 14:28:39 -07:00
//printf("GET MAX_W of state '%s' [%d]\n", state, pd->max.w);
2008-03-06 11:48:11 -08:00
return pd - > max . w ;
}
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
EAPI void
edje_edit_state_max_w_set ( Evas_Object * obj , const char * part , const char * state , int max_w )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( ) ;
2008-05-30 01:00:25 -07:00
2009-10-26 14:28:39 -07:00
//printf("SET MAX_W of state '%s' [to: %d]\n", state, max_w);
2008-03-06 11:48:11 -08:00
pd - > max . w = max_w ;
}
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
EAPI int
edje_edit_state_max_h_get ( Evas_Object * obj , const char * part , const char * state )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( 0 ) ;
2008-05-30 01:00:25 -07:00
2009-10-26 14:28:39 -07:00
//printf("GET MAX_H of state '%s' [%d]\n", state, pd->max.h);
2008-03-06 11:48:11 -08:00
return pd - > max . h ;
}
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
EAPI void
edje_edit_state_max_h_set ( Evas_Object * obj , const char * part , const char * state , int max_h )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( ) ;
2008-05-30 01:00:25 -07:00
2009-10-26 14:28:39 -07:00
//printf("SET MAX_H of state '%s' [to: %d]\n", state, max_h);
2008-03-06 11:48:11 -08:00
pd - > max . h = max_h ;
}
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
//aspect
EAPI double
edje_edit_state_aspect_min_get ( Evas_Object * obj , const char * part , const char * state )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( 0 ) ;
2008-05-30 01:00:25 -07:00
2009-10-26 14:28:39 -07:00
//printf("GET ASPECT_MIN of state '%s' [%f]\n", state, pd->aspect.min);
2008-03-06 11:48:11 -08:00
return pd - > aspect . min ;
}
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
EAPI double
edje_edit_state_aspect_max_get ( Evas_Object * obj , const char * part , const char * state )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( 0 ) ;
2008-05-30 01:00:25 -07:00
2009-10-26 14:28:39 -07:00
//printf("GET ASPECT_MAX of state '%s' [%f]\n", state, pd->aspect.max);
2008-03-06 11:48:11 -08:00
return pd - > aspect . max ;
}
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
EAPI void
edje_edit_state_aspect_min_set ( Evas_Object * obj , const char * part , const char * state , double aspect )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( ) ;
2008-05-30 01:00:25 -07:00
2009-10-26 14:28:39 -07:00
//printf("SET ASPECT_MIN of state '%s' [to: %f]\n", state, aspect);
2008-03-06 11:48:11 -08:00
pd - > aspect . min = aspect ;
}
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
EAPI void
edje_edit_state_aspect_max_set ( Evas_Object * obj , const char * part , const char * state , double aspect )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( ) ;
2008-05-30 01:00:25 -07:00
2009-10-26 14:28:39 -07:00
//printf("SET ASPECT_MAX of state '%s' [to: %f]\n", state, aspect);
2008-03-06 11:48:11 -08:00
pd - > aspect . max = aspect ;
}
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
EAPI unsigned char
edje_edit_state_aspect_pref_get ( Evas_Object * obj , const char * part , const char * state )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( 0 ) ;
2008-05-30 01:00:25 -07:00
2009-10-26 14:28:39 -07:00
//printf("GET ASPECT_PREF of state '%s' [%d]\n", state, pd->aspect.prefer);
2008-03-06 11:48:11 -08:00
return pd - > aspect . prefer ;
}
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
EAPI void
edje_edit_state_aspect_pref_set ( Evas_Object * obj , const char * part , const char * state , unsigned char pref )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( ) ;
2008-05-30 01:00:25 -07:00
2009-10-26 14:28:39 -07:00
//printf("SET ASPECT_PREF of state '%s' [to: %d]\n", state, pref);
2008-03-06 11:48:11 -08:00
pd - > aspect . prefer = pref ;
}
2008-07-12 05:48:35 -07:00
//fill
EAPI double
edje_edit_state_fill_origin_relative_x_get ( Evas_Object * obj , const char * part , const char * state )
{
GET_PD_OR_RETURN ( 0 ) ;
//printf("Get state fill origin of part: %s state: %s\n", part, state);
return pd - > fill . pos_rel_x ;
}
EAPI double
edje_edit_state_fill_origin_relative_y_get ( Evas_Object * obj , const char * part , const char * state )
{
GET_PD_OR_RETURN ( 0 ) ;
//printf("Get state fill origin of part: %s state: %s\n", part, state);
return pd - > fill . pos_rel_y ;
}
EAPI int
edje_edit_state_fill_origin_offset_x_get ( Evas_Object * obj , const char * part , const char * state )
{
GET_PD_OR_RETURN ( 0 ) ;
//printf("Get state fill origin offset of part: %s state: %s\n", part, state);
return pd - > fill . pos_abs_x ;
}
EAPI int
edje_edit_state_fill_origin_offset_y_get ( Evas_Object * obj , const char * part , const char * state )
{
GET_PD_OR_RETURN ( 0 ) ;
//printf("Get state fill origin offset of part: %s state: %s\n", part, state);
return pd - > fill . pos_abs_y ;
}
EAPI void
edje_edit_state_fill_origin_relative_x_set ( Evas_Object * obj , const char * part , const char * state , double x )
{
GET_PD_OR_RETURN ( ) ;
2009-10-26 14:28:39 -07:00
//printf("Set state fill origin of part: %s state: %s to: %f\n", part, state, x);
2008-07-12 05:48:35 -07:00
pd - > fill . pos_rel_x = x ;
edje_object_calc_force ( obj ) ;
}
EAPI void
edje_edit_state_fill_origin_relative_y_set ( Evas_Object * obj , const char * part , const char * state , double y )
{
GET_PD_OR_RETURN ( ) ;
2009-10-26 14:28:39 -07:00
//printf("Set state fill origin of part: %s state: %s to: %f\n", part, state, y);
2008-07-12 05:48:35 -07:00
pd - > fill . pos_rel_y = y ;
edje_object_calc_force ( obj ) ;
}
EAPI void
edje_edit_state_fill_origin_offset_x_set ( Evas_Object * obj , const char * part , const char * state , double x )
{
GET_PD_OR_RETURN ( ) ;
2009-10-26 14:28:39 -07:00
//printf("Set state fill origin offset x of part: %s state: %s to: %f\n", part, state, x);
2008-07-12 05:48:35 -07:00
pd - > fill . pos_abs_x = x ;
edje_object_calc_force ( obj ) ;
}
EAPI void
edje_edit_state_fill_origin_offset_y_set ( Evas_Object * obj , const char * part , const char * state , double y )
{
GET_PD_OR_RETURN ( ) ;
2009-10-26 14:28:39 -07:00
//printf("Set state fill origin offset y of part: %s state: %s to: %f\n", part, state, y);
2008-07-12 05:48:35 -07:00
pd - > fill . pos_abs_y = y ;
edje_object_calc_force ( obj ) ;
}
EAPI double
edje_edit_state_fill_size_relative_x_get ( Evas_Object * obj , const char * part , const char * state )
{
GET_PD_OR_RETURN ( 0.0 ) ;
//printf("Get state fill size of part: %s state: %s\n", part, state);
return pd - > fill . rel_x ;
}
EAPI double
edje_edit_state_fill_size_relative_y_get ( Evas_Object * obj , const char * part , const char * state )
{
GET_PD_OR_RETURN ( 0.0 ) ;
//printf("Get state fill size of part: %s state: %s\n", part, state);
return pd - > fill . rel_y ;
}
EAPI int
edje_edit_state_fill_size_offset_x_get ( Evas_Object * obj , const char * part , const char * state )
{
GET_PD_OR_RETURN ( 0 ) ;
//printf("Get state fill size offset of part: %s state: %s\n", part, state);
return pd - > fill . abs_x ;
}
EAPI int
edje_edit_state_fill_size_offset_y_get ( Evas_Object * obj , const char * part , const char * state )
{
GET_PD_OR_RETURN ( 0 ) ;
//printf("Get state fill size offset of part: %s state: %s\n", part, state);
return pd - > fill . abs_y ;
}
EAPI void
edje_edit_state_fill_size_relative_x_set ( Evas_Object * obj , const char * part , const char * state , double x )
{
GET_PD_OR_RETURN ( ) ;
2009-10-26 14:28:39 -07:00
//printf("Set state fill size of part: %s state: %s to: %f\n", part, state, x);
2008-07-12 05:48:35 -07:00
pd - > fill . rel_x = x ;
edje_object_calc_force ( obj ) ;
}
EAPI void
edje_edit_state_fill_size_relative_y_set ( Evas_Object * obj , const char * part , const char * state , double y )
{
GET_PD_OR_RETURN ( ) ;
2009-10-26 14:28:39 -07:00
//printf("Set state fill size of part: %s state: %s to: %f\n", part, state, y);
2008-07-12 05:48:35 -07:00
pd - > fill . rel_y = y ;
edje_object_calc_force ( obj ) ;
}
EAPI void
edje_edit_state_fill_size_offset_x_set ( Evas_Object * obj , const char * part , const char * state , double x )
{
GET_PD_OR_RETURN ( ) ;
2009-10-26 14:28:39 -07:00
//printf("Set state fill size offset x of part: %s state: %s to: %f\n", part, state, x);
2008-07-12 05:48:35 -07:00
pd - > fill . abs_x = x ;
edje_object_calc_force ( obj ) ;
}
EAPI void
edje_edit_state_fill_size_offset_y_set ( Evas_Object * obj , const char * part , const char * state , double y )
{
GET_PD_OR_RETURN ( ) ;
2009-10-26 14:28:39 -07:00
//printf("Set state fill size offset y of part: %s state: %s to: %f\n", part, state, y);
2008-07-12 05:48:35 -07:00
pd - > fill . abs_y = y ;
edje_object_calc_force ( obj ) ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-09-16 12:01:37 -07:00
edje_edit_state_visible_get ( Evas_Object * obj , const char * part , const char * state )
{
GET_PD_OR_RETURN ( 0 ) ;
//printf("Get state visible flag of part: %s state: %s\n", part, state);
return pd - > visible ;
}
EAPI void
2009-09-15 20:37:28 -07:00
edje_edit_state_visible_set ( Evas_Object * obj , const char * part , const char * state , Eina_Bool visible )
2008-09-16 12:01:37 -07:00
{
GET_PD_OR_RETURN ( ) ;
2009-10-26 14:28:39 -07:00
//printf("Set state visible flag of part: %s state: %s to: %d\n", part, state, visible);
2008-09-16 12:01:37 -07:00
if ( visible ) pd - > visible = 1 ;
else pd - > visible = 0 ;
edje_object_calc_force ( obj ) ;
}
2008-07-12 05:48:35 -07:00
2008-09-28 15:23:43 -07:00
EAPI const char *
edje_edit_state_color_class_get ( Evas_Object * obj , const char * part , const char * state )
{
GET_PD_OR_RETURN ( NULL ) ;
2009-10-26 14:28:39 -07:00
//printf("Get ColorClass of part: %s state: %s\n", part, state);
2008-10-15 07:11:11 -07:00
return eina_stringshare_add ( pd - > color_class ) ;
2008-09-28 15:23:43 -07:00
}
EAPI void
edje_edit_state_color_class_set ( Evas_Object * obj , const char * part , const char * state , const char * color_class )
{
GET_PD_OR_RETURN ( ) ;
2009-10-26 14:28:39 -07:00
//printf("Set ColorClass of part: %s state: %s [to: %s]\n", part, state, color_class);
2008-09-28 15:23:43 -07:00
_edje_if_string_free ( ed , pd - > color_class ) ;
2008-10-15 07:11:11 -07:00
pd - > color_class = ( char * ) eina_stringshare_add ( color_class ) ;
2008-09-28 15:23:43 -07:00
}
2009-11-17 16:27:49 -08:00
EAPI const Eina_List *
edje_edit_state_external_params_list_get ( Evas_Object * obj , const char * part , const char * state )
{
GET_PD_OR_RETURN ( NULL ) ;
return pd - > external_params ;
}
EAPI Eina_Bool
edje_edit_state_external_param_get ( Evas_Object * obj , const char * part , const char * state , const char * param , Edje_External_Param_Type * type , void * * value )
{
Eina_List * l ;
Edje_External_Param * p ;
GET_PD_OR_RETURN ( EINA_FALSE ) ;
EINA_LIST_FOREACH ( pd - > external_params , l , p )
if ( ! strcmp ( p - > name , param ) )
{
if ( type ) * type = p - > type ;
if ( value )
switch ( p - > type )
{
case EDJE_EXTERNAL_PARAM_TYPE_INT :
* value = & p - > i ;
break ;
case EDJE_EXTERNAL_PARAM_TYPE_DOUBLE :
* value = & p - > d ;
break ;
case EDJE_EXTERNAL_PARAM_TYPE_STRING :
* value = p - > s ;
break ;
}
return EINA_TRUE ;
}
return EINA_FALSE ;
}
EAPI Eina_Bool
edje_edit_state_external_param_int_get ( Evas_Object * obj , const char * part , const char * state , const char * param , int * value )
{
Eina_List * l ;
Edje_External_Param * p ;
GET_PD_OR_RETURN ( EINA_FALSE ) ;
EINA_LIST_FOREACH ( pd - > external_params , l , p )
if ( ! strcmp ( p - > name , param ) )
{
if ( p - > type ! = EDJE_EXTERNAL_PARAM_TYPE_INT )
return EINA_FALSE ;
if ( value )
* value = p - > i ;
return EINA_TRUE ;
}
return EINA_FALSE ;
}
EAPI Eina_Bool
edje_edit_state_external_param_double_get ( Evas_Object * obj , const char * part , const char * state , const char * param , double * value )
{
Eina_List * l ;
Edje_External_Param * p ;
GET_PD_OR_RETURN ( EINA_FALSE ) ;
EINA_LIST_FOREACH ( pd - > external_params , l , p )
if ( ! strcmp ( p - > name , param ) )
{
if ( p - > type ! = EDJE_EXTERNAL_PARAM_TYPE_DOUBLE )
return EINA_FALSE ;
if ( value )
* value = p - > d ;
return EINA_TRUE ;
}
return EINA_FALSE ;
}
EAPI Eina_Bool
edje_edit_state_external_param_string_get ( Evas_Object * obj , const char * part , const char * state , const char * param , const char * * value )
{
Eina_List * l ;
Edje_External_Param * p ;
GET_PD_OR_RETURN ( EINA_FALSE ) ;
EINA_LIST_FOREACH ( pd - > external_params , l , p )
if ( ! strcmp ( p - > name , param ) )
{
if ( p - > type ! = EDJE_EXTERNAL_PARAM_TYPE_STRING )
return EINA_FALSE ;
if ( value )
* value = p - > s ;
return EINA_TRUE ;
}
return EINA_FALSE ;
}
EAPI Eina_Bool
edje_edit_state_external_param_set ( Evas_Object * obj , const char * part , const char * state , const char * param , Edje_External_Param_Type type , . . . )
{
va_list ap ;
Eina_List * l ;
Edje_External_Param * p ;
int found = 0 ;
GET_PD_OR_RETURN ( EINA_FALSE ) ;
va_start ( ap , type ) ;
EINA_LIST_FOREACH ( pd - > external_params , l , p )
if ( ! strcmp ( p - > name , param ) )
{
found = 1 ;
break ;
}
if ( ! found )
{
p = _alloc ( sizeof ( Edje_External_Param ) ) ;
if ( ! p )
{
va_end ( ap ) ;
return EINA_FALSE ;
}
p - > name = eina_stringshare_add ( param ) ;
}
p - > type = type ;
p - > i = 0 ;
p - > d = 0 ;
_edje_if_string_free ( ed , p - > s ) ;
p - > s = NULL ;
switch ( type )
{
case EDJE_EXTERNAL_PARAM_TYPE_INT :
p - > i = ( int ) va_arg ( ap , int ) ;
break ;
case EDJE_EXTERNAL_PARAM_TYPE_DOUBLE :
p - > d = ( double ) va_arg ( ap , double ) ;
break ;
case EDJE_EXTERNAL_PARAM_TYPE_STRING :
p - > s = eina_stringshare_add ( ( const char * ) va_arg ( ap , char * ) ) ;
break ;
}
va_end ( ap ) ;
if ( ! found )
pd - > external_params = eina_list_append ( pd - > external_params , p ) ;
return EINA_TRUE ;
}
EAPI Eina_Bool
edje_edit_state_external_param_int_set ( Evas_Object * obj , const char * part , const char * state , const char * param , int value )
{
return edje_edit_state_external_param_set ( obj , part , state , param , EDJE_EXTERNAL_PARAM_TYPE_INT , value ) ;
}
EAPI Eina_Bool
edje_edit_state_external_param_double_set ( Evas_Object * obj , const char * part , const char * state , const char * param , double value )
{
return edje_edit_state_external_param_set ( obj , part , state , param , EDJE_EXTERNAL_PARAM_TYPE_DOUBLE , value ) ;
}
EAPI Eina_Bool
edje_edit_state_external_param_string_set ( Evas_Object * obj , const char * part , const char * state , const char * param , const char * value )
{
return edje_edit_state_external_param_set ( obj , part , state , param , EDJE_EXTERNAL_PARAM_TYPE_STRING , value ) ;
}
2008-03-06 11:48:11 -08:00
/**************/
/* TEXT API */
/**************/
2008-03-13 09:01:35 -07:00
EAPI const char *
2008-03-06 11:48:11 -08:00
edje_edit_state_text_get ( Evas_Object * obj , const char * part , const char * state )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( NULL ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
//printf("GET TEXT of state: %s\n", state);
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
if ( pd - > text . text )
2008-10-15 07:11:11 -07:00
return eina_stringshare_add ( pd - > text . text ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
return NULL ;
}
EAPI void
edje_edit_state_text_set ( Evas_Object * obj , const char * part , const char * state , const char * text )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
//printf("SET TEXT of state: %s\n", state);
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
if ( ! text ) return ;
2008-03-13 12:01:53 -07:00
2008-03-08 15:11:32 -08:00
_edje_if_string_free ( ed , pd - > text . text ) ;
2008-10-15 07:11:11 -07:00
pd - > text . text = ( char * ) eina_stringshare_add ( text ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
edje_object_calc_force ( obj ) ;
}
EAPI int
edje_edit_state_text_size_get ( Evas_Object * obj , const char * part , const char * state )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( - 1 ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
//printf("GET TEXT_SIZE of state: %s [%d]\n", state, pd->text.size);
return pd - > text . size ;
}
EAPI void
edje_edit_state_text_size_set ( Evas_Object * obj , const char * part , const char * state , int size )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
//printf("SET TEXT_SIZE of state: %s [%d]\n", state, size);
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
if ( size < 0 ) return ;
pd - > text . size = size ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
edje_object_calc_force ( obj ) ;
}
EAPI double
edje_edit_state_text_align_x_get ( Evas_Object * obj , const char * part , const char * state )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( 0 ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
//printf("GET TEXT_ALIGN_X of state: %s [%f]\n", state, pd->text.align.x);
return pd - > text . align . x ;
}
EAPI void
edje_edit_state_text_align_x_set ( Evas_Object * obj , const char * part , const char * state , double align )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
//printf("SET TEXT_ALIGN_X of state: %s [%f]\n", state, align);
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
pd - > text . align . x = align ;
edje_object_calc_force ( obj ) ;
}
EAPI double
edje_edit_state_text_align_y_get ( Evas_Object * obj , const char * part , const char * state )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( 0.0 ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
//printf("GET TEXT_ALIGN_Y of state: %s [%f]\n", state, pd->text.align.x);
return pd - > text . align . y ;
}
EAPI void
edje_edit_state_text_align_y_set ( Evas_Object * obj , const char * part , const char * state , double align )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
//printf("SET TEXT_ALIGN_Y of state: %s [%f]\n", state, align);
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
pd - > text . align . y = align ;
edje_object_calc_force ( obj ) ;
}
2008-10-07 09:01:56 -07:00
EAPI double
edje_edit_state_text_elipsis_get ( Evas_Object * obj , const char * part , const char * state )
{
GET_PD_OR_RETURN ( 0.0 ) ;
//printf("GET TEXT_ELIPSIS of state: %s [%f]\n", state, pd->text.elipsis);
return pd - > text . elipsis ;
}
EAPI void
edje_edit_state_text_elipsis_set ( Evas_Object * obj , const char * part , const char * state , double balance )
{
GET_PD_OR_RETURN ( ) ;
//printf("SET TEXT_ELIPSIS of state: %s [%f]\n", state, balance);
pd - > text . elipsis = balance ;
edje_object_calc_force ( obj ) ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-10-07 09:01:56 -07:00
edje_edit_state_text_fit_x_get ( Evas_Object * obj , const char * part , const char * state )
{
2008-10-26 21:10:31 -07:00
GET_PD_OR_RETURN ( 0 ) ;
2008-10-07 09:01:56 -07:00
//printf("GET TEXT_FIT_VERT of state: %s \n", state);
return pd - > text . fit_x ;
}
EAPI void
2009-09-15 20:37:28 -07:00
edje_edit_state_text_fit_x_set ( Evas_Object * obj , const char * part , const char * state , Eina_Bool fit )
2008-10-07 09:01:56 -07:00
{
GET_PD_OR_RETURN ( ) ;
//printf("SET TEXT_FIT_VERT of state: %s\n", state);
pd - > text . fit_x = fit ? 1 : 0 ;
edje_object_calc_force ( obj ) ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-10-07 09:01:56 -07:00
edje_edit_state_text_fit_y_get ( Evas_Object * obj , const char * part , const char * state )
{
2008-10-26 21:10:31 -07:00
GET_PD_OR_RETURN ( 0 ) ;
2008-10-07 09:01:56 -07:00
//printf("GET TEXT_FIT_VERT of state: %s \n", state);
return pd - > text . fit_y ;
}
EAPI void
2009-09-15 20:37:28 -07:00
edje_edit_state_text_fit_y_set ( Evas_Object * obj , const char * part , const char * state , Eina_Bool fit )
2008-10-07 09:01:56 -07:00
{
GET_PD_OR_RETURN ( ) ;
//printf("SET TEXT_FIT_VERT of state: %s\n", state);
pd - > text . fit_y = fit ? 1 : 0 ;
edje_object_calc_force ( obj ) ;
}
2008-10-22 04:34:42 -07:00
EAPI Eina_List *
2008-03-06 11:48:11 -08:00
edje_edit_fonts_list_get ( Evas_Object * obj )
{
Edje_Font_Directory_Entry * f ;
2008-10-22 04:34:42 -07:00
Eina_List * fonts = NULL ;
Eina_List * l ;
2008-03-13 12:01:53 -07:00
GET_ED_OR_RETURN ( NULL ) ;
2008-03-06 11:48:11 -08:00
if ( ! ed - > file ) return NULL ;
if ( ! ed - > file - > font_dir ) return NULL ;
2008-03-13 12:01:53 -07:00
2009-10-26 14:28:39 -07:00
//printf("GET FONT LIST for %s\n", ed->file->path);
2008-03-13 12:01:53 -07:00
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ed - > file - > font_dir - > entries , l , f )
2008-03-13 12:01:53 -07:00
{
2008-10-22 04:34:42 -07:00
fonts = eina_list_append ( fonts , eina_stringshare_add ( f - > entry ) ) ;
2009-10-26 14:28:39 -07:00
//printf(" Font: %s (%s) \n", f->entry, f->path);
2008-03-13 12:01:53 -07:00
}
2008-03-06 11:48:11 -08:00
return fonts ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_font_add ( Evas_Object * obj , const char * path )
{
2008-06-06 11:31:49 -07:00
char buf [ PATH_MAX ] ;
2008-03-06 11:48:11 -08:00
Edje_Font_Directory_Entry * fnt ;
Eet_File * eetf ;
struct stat st ;
char * name ;
2008-03-13 12:01:53 -07:00
FILE * f ;
void * fdata = NULL ;
int fsize = 0 ;
GET_ED_OR_RETURN ( 0 ) ;
2008-05-30 01:00:25 -07:00
2009-10-26 14:28:39 -07:00
//printf("ADD FONT: %s\n", path);
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
if ( ! path ) return 0 ;
if ( stat ( path , & st ) | | ! S_ISREG ( st . st_mode ) ) return 0 ;
if ( ! ed - > file ) return 0 ;
if ( ! ed - > path ) return 0 ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
/* Create Font_Directory if not exist */
if ( ! ed - > file - > font_dir )
2009-08-17 06:54:17 -07:00
{
ed - > file - > font_dir = _alloc ( sizeof ( Edje_Font_Directory ) ) ;
if ( ! ed - > file - > font_dir ) return 0 ;
}
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
if ( ( name = strrchr ( path , ' / ' ) ) ) name + + ;
else name = ( char * ) path ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
/* Read font data from file */
f = fopen ( path , " rb " ) ;
if ( f )
2008-03-13 12:01:53 -07:00
{
long pos ;
fseek ( f , 0 , SEEK_END ) ;
pos = ftell ( f ) ;
rewind ( f ) ;
fdata = malloc ( pos ) ;
if ( fdata )
{
if ( fread ( fdata , pos , 1 , f ) ! = 1 )
{
fprintf ( stderr , " Edje_Edit: Error. unable to read all of font file \" %s \" \n " ,
path ) ;
return 0 ;
}
fsize = pos ;
}
fclose ( f ) ;
}
2008-03-06 11:48:11 -08:00
/* Write font to edje file */
2009-08-17 07:26:31 -07:00
snprintf ( buf , sizeof ( buf ) , " fonts/%s " , name ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
if ( fdata )
2008-03-13 12:01:53 -07:00
{
/* open the eet file */
eetf = eet_open ( ed - > path , EET_FILE_MODE_READ_WRITE ) ;
if ( ! eetf )
{
fprintf ( stderr ,
" Edje_Edit: Error. unable to open \" %s \" for writing output \n " ,
ed - > path ) ;
return 0 ;
}
if ( eet_write ( eetf , buf , fdata , fsize , 1 ) < = 0 )
{
fprintf ( stderr , " Edje_Edit: Error. unable to write font part \" %s \" as \" %s \" part entry \n " ,
path , buf ) ;
eet_close ( eetf ) ;
free ( fdata ) ;
return 0 ;
}
eet_close ( eetf ) ;
free ( fdata ) ;
}
2008-03-06 11:48:11 -08:00
/* Create Edje_Font_Directory_Entry */
if ( ed - > file - > font_dir )
2008-03-13 12:01:53 -07:00
{
2009-08-17 06:54:17 -07:00
fnt = _alloc ( sizeof ( Edje_Font_Directory_Entry ) ) ;
if ( ! fnt ) return 0 ;
2009-08-17 14:28:40 -07:00
fnt - > entry = strdup ( name ) ;
fnt - > path = strdup ( buf ) ;
2008-03-13 12:01:53 -07:00
2008-10-22 04:34:42 -07:00
ed - > file - > font_dir - > entries = eina_list_append ( ed - > file - > font_dir - > entries , fnt ) ;
2008-12-17 06:26:47 -08:00
if ( ! ed - > file - > font_hash )
ed - > file - > font_hash = eina_hash_string_superfast_new ( NULL ) ;
eina_hash_direct_add ( ed - > file - > font_hash , fnt - > entry , fnt ) ;
2008-03-13 12:01:53 -07:00
}
2008-03-06 11:48:11 -08:00
return 1 ;
}
2008-03-13 12:08:14 -07:00
EAPI const char *
2008-03-06 11:48:11 -08:00
edje_edit_state_font_get ( Evas_Object * obj , const char * part , const char * state )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( NULL ) ;
2008-05-30 01:00:25 -07:00
2009-10-26 14:28:39 -07:00
//printf("GET FONT of state: %s [%s]\n", state, pd->text.font);
2008-03-06 11:48:11 -08:00
if ( ! pd - > text . font ) return NULL ;
2008-10-15 07:11:11 -07:00
return eina_stringshare_add ( pd - > text . font ) ;
2008-03-06 11:48:11 -08:00
}
EAPI void
edje_edit_state_font_set ( Evas_Object * obj , const char * part , const char * state , const char * font )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( ) ;
2008-05-30 01:00:25 -07:00
2009-10-26 14:28:39 -07:00
//printf("SET FONT of state: %s [%s]\n", state, font);
2008-03-13 12:01:53 -07:00
2008-03-08 15:11:32 -08:00
_edje_if_string_free ( ed , pd - > text . font ) ;
2008-10-15 07:11:11 -07:00
pd - > text . font = ( char * ) eina_stringshare_add ( font ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
edje_object_calc_force ( obj ) ;
}
2009-09-15 20:37:28 -07:00
EAPI Edje_Text_Effect
2008-03-06 11:48:11 -08:00
edje_edit_part_effect_get ( Evas_Object * obj , const char * part )
{
2008-03-13 12:01:53 -07:00
GET_RP_OR_RETURN ( 0 ) ;
2008-05-30 01:00:25 -07:00
2009-10-26 14:28:39 -07:00
//printf("GET EFFECT of part: %s\n", part);
2008-03-06 11:48:11 -08:00
return rp - > part - > effect ;
}
EAPI void
2009-09-15 20:37:28 -07:00
edje_edit_part_effect_set ( Evas_Object * obj , const char * part , Edje_Text_Effect effect )
2008-03-06 11:48:11 -08:00
{
2008-03-13 12:01:53 -07:00
GET_RP_OR_RETURN ( ) ;
2008-05-30 01:00:25 -07:00
2009-10-26 14:28:39 -07:00
//printf("SET EFFECT of part: %s [%d]\n", part, effect);
2008-03-06 11:48:11 -08:00
rp - > part - > effect = effect ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
edje_object_calc_force ( obj ) ;
}
/****************/
/* IMAGES API */
/****************/
2008-10-22 04:34:42 -07:00
EAPI Eina_List *
2008-03-06 11:48:11 -08:00
edje_edit_images_list_get ( Evas_Object * obj )
{
Edje_Image_Directory_Entry * i ;
2008-10-22 04:34:42 -07:00
Eina_List * images = NULL ;
Eina_List * l ;
2008-03-13 12:01:53 -07:00
GET_ED_OR_RETURN ( NULL ) ;
2008-03-06 11:48:11 -08:00
if ( ! ed - > file ) return NULL ;
if ( ! ed - > file - > image_dir ) return NULL ;
2008-03-13 12:01:53 -07:00
2009-10-26 14:28:39 -07:00
//printf("GET IMAGES LIST for %s\n", ed->file->path);
2008-03-13 12:01:53 -07:00
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ed - > file - > image_dir - > entries , l , i )
2008-03-13 12:01:53 -07:00
{
2008-10-22 04:34:42 -07:00
images = eina_list_append ( images , eina_stringshare_add ( i - > entry ) ) ;
2008-07-12 05:48:35 -07:00
//printf(" Image: %s (type: %d param: %d id: %d) \n",
// i->entry, i->source_type, i->source_param, i->id);
2008-03-13 12:01:53 -07:00
}
2008-03-06 11:48:11 -08:00
return images ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_image_add ( Evas_Object * obj , const char * path )
{
2008-10-22 04:34:42 -07:00
Eina_List * l ;
2008-03-06 11:48:11 -08:00
Edje_Image_Directory_Entry * de ;
2008-10-22 04:34:42 -07:00
Edje_Image_Directory_Entry * i ;
2008-03-13 12:01:53 -07:00
int free_id = 0 ;
2008-03-06 11:48:11 -08:00
char * name ;
2008-03-13 12:01:53 -07:00
GET_ED_OR_RETURN ( 0 ) ;
2008-03-06 11:48:11 -08:00
if ( ! path ) return 0 ;
if ( ! ed - > file ) return 0 ;
if ( ! ed - > path ) return 0 ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
/* Create Image_Directory if not exist */
if ( ! ed - > file - > image_dir )
2009-08-17 06:54:17 -07:00
{
ed - > file - > image_dir = _alloc ( sizeof ( Edje_Image_Directory ) ) ;
if ( ! ed - > file - > image_dir ) return 0 ;
}
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
/* Loop trough image directory to find if image exist */
2009-10-26 14:28:39 -07:00
//printf("Add Image '%s' (total %d)\n", path,
// eina_list_count(ed->file->image_dir->entries));
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ed - > file - > image_dir - > entries , l , i )
2008-03-13 12:01:53 -07:00
{
if ( ! i ) return 0 ;
if ( i - > id > = free_id ) free_id = i - > id + 1 ; /*TODO search for free (hole) id*/
2009-10-26 14:28:39 -07:00
//printf("IMG: %s [%d]\n", i->entry, i->id);
2008-03-13 12:01:53 -07:00
}
2009-10-26 14:28:39 -07:00
//printf("FREE ID: %d\n", free_id);
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
/* Import image */
if ( ! _edje_import_image_file ( ed , path , free_id ) )
return 0 ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
/* Create Image Entry */
2009-08-17 06:54:17 -07:00
de = _alloc ( sizeof ( Edje_Image_Directory_Entry ) ) ;
if ( ! de ) return 0 ;
2008-03-13 09:01:35 -07:00
if ( ( name = strrchr ( path , ' / ' ) ) ) name + + ;
2008-03-06 11:48:11 -08:00
else name = ( char * ) path ;
2009-08-17 14:28:40 -07:00
de - > entry = strdup ( name ) ;
2008-03-06 11:48:11 -08:00
de - > id = free_id ;
de - > source_type = 1 ;
de - > source_param = 1 ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
/* Add image to Image Directory */
ed - > file - > image_dir - > entries =
2008-10-22 04:34:42 -07:00
eina_list_append ( ed - > file - > image_dir - > entries , de ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
return 1 ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2009-07-13 12:17:35 -07:00
edje_edit_image_data_add ( Evas_Object * obj , const char * name , int id )
{
Eina_List * l ;
Edje_Image_Directory_Entry * de ;
Edje_Image_Directory_Entry * i , * t ;
GET_ED_OR_RETURN ( 0 ) ;
if ( ! name ) return 0 ;
if ( ! ed - > file ) return 0 ;
if ( ! ed - > path ) return 0 ;
/* Create Image_Directory if not exist */
if ( ! ed - > file - > image_dir )
2009-08-17 06:54:17 -07:00
{
ed - > file - > image_dir = _alloc ( sizeof ( Edje_Image_Directory ) ) ;
if ( ! ed - > file - > image_dir ) return 0 ;
}
2009-07-13 12:17:35 -07:00
/* Loop trough image directory to find if image exist */
t = NULL ;
EINA_LIST_FOREACH ( ed - > file - > image_dir - > entries , l , i )
{
if ( ! i ) return 0 ;
if ( i - > id = = id ) t = i ;
}
/* Create Image Entry */
if ( ! t )
2009-08-17 06:54:17 -07:00
{
de = _alloc ( sizeof ( Edje_Image_Directory_Entry ) ) ;
if ( ! de ) return 0 ;
}
2009-07-13 12:17:35 -07:00
else
{
de = t ;
free ( de - > entry ) ;
}
2009-08-17 14:28:40 -07:00
de - > entry = strdup ( name ) ;
2009-07-13 12:17:35 -07:00
de - > id = id ;
de - > source_type = 1 ;
de - > source_param = 1 ;
/* Add image to Image Directory */
if ( ! t )
ed - > file - > image_dir - > entries =
eina_list_append ( ed - > file - > image_dir - > entries , de ) ;
return 1 ;
}
2008-03-06 11:48:11 -08:00
EAPI int
edje_edit_image_id_get ( Evas_Object * obj , const char * image_name )
{
return _edje_image_id_find ( obj , image_name ) ;
}
2009-09-15 20:37:28 -07:00
EAPI Edje_Edit_Image_Comp
2008-07-30 15:41:04 -07:00
edje_edit_image_compression_type_get ( Evas_Object * obj , const char * image )
{
Edje_Image_Directory_Entry * i = NULL ;
2008-10-22 04:34:42 -07:00
Eina_List * l ;
2008-07-30 15:41:04 -07:00
GET_ED_OR_RETURN ( - 1 ) ;
if ( ! ed - > file ) return - 1 ;
if ( ! ed - > file - > image_dir ) return - 1 ;
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ed - > file - > image_dir - > entries , l , i )
2008-07-30 15:41:04 -07:00
{
if ( strcmp ( i - > entry , image ) = = 0 )
break ;
i = NULL ;
}
if ( ! i ) return - 1 ;
switch ( i - > source_type )
{
case EDJE_IMAGE_SOURCE_TYPE_INLINE_PERFECT :
if ( i - > source_param = = 0 ) // RAW
return EDJE_EDIT_IMAGE_COMP_RAW ;
else // COMP
return EDJE_EDIT_IMAGE_COMP_COMP ;
break ;
case EDJE_IMAGE_SOURCE_TYPE_INLINE_LOSSY : // LOSSY
return EDJE_EDIT_IMAGE_COMP_LOSSY ;
break ;
case EDJE_IMAGE_SOURCE_TYPE_EXTERNAL : // USER
return EDJE_EDIT_IMAGE_COMP_USER ;
break ;
}
return - 1 ;
}
EAPI int
edje_edit_image_compression_rate_get ( Evas_Object * obj , const char * image )
{
2008-10-22 04:34:42 -07:00
Eina_List * l ;
2008-07-30 15:41:04 -07:00
Edje_Image_Directory_Entry * i ;
GET_ED_OR_RETURN ( - 1 ) ;
// Gets the Image Entry
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ed - > file - > image_dir - > entries , l , i )
2008-07-30 15:41:04 -07:00
{
if ( strcmp ( i - > entry , image ) = = 0 ) break ;
i = NULL ;
}
if ( ! i ) return - 1 ;
if ( i - > source_type ! = EDJE_IMAGE_SOURCE_TYPE_INLINE_LOSSY ) return - 2 ;
return i - > source_param ;
}
2008-03-13 12:08:14 -07:00
EAPI const char *
2008-03-06 11:48:11 -08:00
edje_edit_state_image_get ( Evas_Object * obj , const char * part , const char * state )
{
char * image ;
2008-05-30 01:00:25 -07:00
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( NULL ) ;
2008-03-06 11:48:11 -08:00
image = ( char * ) _edje_image_name_find ( obj , pd - > image . id ) ;
if ( ! image ) return NULL ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
//printf("GET IMAGE for %s [%s]\n", state, image);
2008-10-15 07:11:11 -07:00
return eina_stringshare_add ( image ) ;
2008-03-06 11:48:11 -08:00
}
EAPI void
edje_edit_state_image_set ( Evas_Object * obj , const char * part , const char * state , const char * image )
{
int id ;
2008-05-30 01:00:25 -07:00
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( ) ;
2008-03-06 11:48:11 -08:00
if ( ! image ) return ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
id = _edje_image_id_find ( obj , image ) ;
2009-10-26 14:28:39 -07:00
//printf("SET IMAGE for %s [%s]\n", state, image);
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
if ( id > - 1 ) pd - > image . id = id ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
edje_object_calc_force ( obj ) ;
}
2008-10-22 04:34:42 -07:00
EAPI Eina_List *
2008-03-06 11:48:11 -08:00
edje_edit_state_tweens_list_get ( Evas_Object * obj , const char * part , const char * state )
{
Edje_Part_Image_Id * i ;
2008-10-22 04:34:42 -07:00
Eina_List * tweens = NULL , * l ;
2008-03-06 11:48:11 -08:00
const char * name ;
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( NULL ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
//printf("GET TWEEN LIST for %s\n", state);
2008-03-13 12:01:53 -07:00
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( pd - > image . tween_list , l , i )
2008-03-13 12:01:53 -07:00
{
name = _edje_image_name_find ( obj , i - > id ) ;
//printf(" t: %s\n", name);
2008-10-22 04:34:42 -07:00
tweens = eina_list_append ( tweens , eina_stringshare_add ( name ) ) ;
2008-03-13 12:01:53 -07:00
}
2008-03-06 11:48:11 -08:00
return tweens ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_state_tween_add ( Evas_Object * obj , const char * part , const char * state , const char * tween )
{
Edje_Part_Image_Id * i ;
int id ;
2008-05-30 01:00:25 -07:00
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( 0 ) ;
2008-03-06 11:48:11 -08:00
id = _edje_image_id_find ( obj , tween ) ;
if ( id < 0 ) return 0 ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
/* alloc Edje_Part_Image_Id */
2009-08-17 07:13:26 -07:00
i = _alloc ( sizeof ( Edje_Part_Image_Id ) ) ;
2008-03-06 11:48:11 -08:00
if ( ! i ) return 0 ;
i - > id = id ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
/* add to tween list */
2008-10-22 04:34:42 -07:00
pd - > image . tween_list = eina_list_append ( pd - > image . tween_list , i ) ;
2008-03-06 11:48:11 -08:00
return 1 ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_state_tween_del ( Evas_Object * obj , const char * part , const char * state , const char * tween )
{
2008-10-22 04:34:42 -07:00
Eina_List * l ;
Edje_Part_Image_Id * i ;
2008-03-06 11:48:11 -08:00
int id ;
2008-05-30 01:00:25 -07:00
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( 0 ) ;
2008-03-06 11:48:11 -08:00
if ( ! pd - > image . tween_list ) return 0 ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
id = _edje_image_id_find ( obj , tween ) ;
if ( id < 0 ) return 0 ;
2008-03-13 12:01:53 -07:00
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( pd - > image . tween_list , l , i )
2008-03-13 12:01:53 -07:00
{
if ( i - > id = = id )
{
2008-10-22 04:34:42 -07:00
pd - > image . tween_list = eina_list_remove_list ( pd - > image . tween_list , l ) ;
2008-03-13 12:01:53 -07:00
return 1 ;
}
}
2008-03-06 11:48:11 -08:00
return 0 ;
}
EAPI void
edje_edit_state_image_border_get ( Evas_Object * obj , const char * part , const char * state , int * l , int * r , int * t , int * b )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
//printf("GET IMAGE_BORDER of state '%s'\n", state);
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
if ( l ) * l = pd - > border . l ;
if ( r ) * r = pd - > border . r ;
if ( t ) * t = pd - > border . t ;
if ( b ) * b = pd - > border . b ;
}
EAPI void
edje_edit_state_image_border_set ( Evas_Object * obj , const char * part , const char * state , int l , int r , int t , int b )
{
2008-03-13 12:01:53 -07:00
GET_PD_OR_RETURN ( ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
//printf("SET IMAGE_BORDER of state '%s'\n", state);
if ( l > - 1 ) pd - > border . l = l ;
if ( r > - 1 ) pd - > border . r = r ;
if ( t > - 1 ) pd - > border . t = t ;
if ( b > - 1 ) pd - > border . b = b ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
edje_object_calc_force ( obj ) ;
}
2008-10-07 14:13:27 -07:00
EAPI unsigned char
edje_edit_state_image_border_fill_get ( Evas_Object * obj , const char * part , const char * state )
{
2008-10-26 21:10:31 -07:00
GET_PD_OR_RETURN ( 0 ) ;
2009-02-12 05:39:15 -08:00
if ( pd - > border . no_fill = = 0 ) return 1 ;
else if ( pd - > border . no_fill = = 1 ) return 0 ;
else if ( pd - > border . no_fill = = 2 ) return 2 ;
return 0 ;
2008-10-07 14:13:27 -07:00
}
EAPI void
edje_edit_state_image_border_fill_set ( Evas_Object * obj , const char * part , const char * state , unsigned char fill )
{
GET_PD_OR_RETURN ( ) ;
2009-02-12 05:39:15 -08:00
if ( fill = = 0 ) pd - > border . no_fill = 1 ;
else if ( fill = = 1 ) pd - > border . no_fill = 0 ;
else if ( fill = = 2 ) pd - > border . no_fill = 2 ;
2008-10-07 14:13:27 -07:00
edje_object_calc_force ( obj ) ;
}
2008-07-12 05:48:35 -07:00
/******************/
/* SPECTRUM API */
/******************/
2008-10-22 04:34:42 -07:00
EAPI Eina_List *
2008-07-12 05:48:35 -07:00
edje_edit_spectrum_list_get ( Evas_Object * obj )
{
Edje_Spectrum_Directory_Entry * s ;
2008-10-22 04:34:42 -07:00
Eina_List * spectrum = NULL ;
Eina_List * l ;
2008-07-12 05:48:35 -07:00
GET_ED_OR_RETURN ( NULL ) ;
if ( ! ed - > file ) return NULL ;
if ( ! ed - > file - > spectrum_dir ) return NULL ;
2008-07-14 18:03:24 -07:00
//printf("GET SPECTRUM LIST for %s\n", ed->file->path);
2008-07-12 05:48:35 -07:00
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ed - > file - > spectrum_dir - > entries , l , s )
2008-07-12 05:48:35 -07:00
{
2008-07-14 18:03:24 -07:00
//printf("SPECTRUM: %s [id: %d]\n", s->entry, s->id);
2008-10-22 04:34:42 -07:00
spectrum = eina_list_append ( spectrum , eina_stringshare_add ( s - > entry ) ) ;
2008-07-12 05:48:35 -07:00
}
2008-07-13 07:29:18 -07:00
return spectrum ;
2008-07-12 05:48:35 -07:00
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-07-12 05:48:35 -07:00
edje_edit_spectra_add ( Evas_Object * obj , const char * name )
{
GET_ED_OR_RETURN ( 0 ) ;
2008-07-13 07:29:18 -07:00
2009-10-26 14:28:39 -07:00
//printf("SPECTRA ADD [new name:%s]\n", name);
2008-07-13 07:29:18 -07:00
2008-07-12 05:48:35 -07:00
Edje_Spectrum_Directory_Entry * s ;
2008-07-13 07:29:18 -07:00
2008-07-12 05:48:35 -07:00
if ( ! ed - > file ) return 0 ;
2008-07-13 07:29:18 -07:00
2008-07-12 05:48:35 -07:00
if ( _edje_edit_spectrum_entry_get ( ed , name ) ) return 0 ;
2008-07-13 07:29:18 -07:00
2008-07-12 05:48:35 -07:00
if ( ! ed - > file - > spectrum_dir )
2009-08-17 06:54:17 -07:00
{
2009-08-17 07:13:26 -07:00
ed - > file - > spectrum_dir = _alloc ( sizeof ( Edje_Spectrum_Directory ) ) ;
2009-08-17 06:54:17 -07:00
if ( ! ed - > file - > spectrum_dir ) return 0 ;
}
2008-07-13 07:29:18 -07:00
2009-08-17 07:13:26 -07:00
s = _alloc ( sizeof ( Edje_Spectrum_Directory_Entry ) ) ;
2009-08-17 06:54:17 -07:00
if ( ! s ) return 0 ;
2008-10-22 04:34:42 -07:00
ed - > file - > spectrum_dir - > entries = eina_list_append ( ed - > file - > spectrum_dir - > entries , s ) ;
s - > id = eina_list_count ( ed - > file - > spectrum_dir - > entries ) - 1 ; //TODO Search for id holes
2008-10-15 07:11:11 -07:00
s - > entry = ( char * ) eina_stringshare_add ( name ) ;
2008-07-12 05:48:35 -07:00
s - > filename = NULL ;
s - > color_list = NULL ;
2008-07-13 07:29:18 -07:00
2008-07-12 05:48:35 -07:00
return 1 ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-07-12 05:48:35 -07:00
edje_edit_spectra_del ( Evas_Object * obj , const char * spectra )
{
Edje_Spectrum_Directory_Entry * s ;
2008-07-13 07:29:18 -07:00
2008-07-12 05:48:35 -07:00
GET_ED_OR_RETURN ( 0 ) ;
2008-07-13 07:29:18 -07:00
2008-07-12 05:48:35 -07:00
s = _edje_edit_spectrum_entry_get ( ed , spectra ) ;
if ( ! s ) return 0 ;
2008-07-13 07:29:18 -07:00
2009-10-26 14:28:39 -07:00
//printf("SPECTRA DEL %s\n", spectra);
2008-07-13 07:29:18 -07:00
2008-10-22 04:34:42 -07:00
ed - > file - > spectrum_dir - > entries = eina_list_remove ( ed - > file - > spectrum_dir - > entries , s ) ;
2008-07-12 05:48:35 -07:00
_edje_if_string_free ( ed , s - > entry ) ;
_edje_if_string_free ( ed , s - > filename ) ;
while ( s - > color_list )
{
Edje_Spectrum_Color * color ;
2008-10-22 04:34:42 -07:00
color = eina_list_data_get ( s - > color_list ) ;
2008-07-12 05:48:35 -07:00
free ( color ) ;
2008-10-22 04:34:42 -07:00
s - > color_list = eina_list_remove_list ( s - > color_list , s - > color_list ) ;
2008-07-12 05:48:35 -07:00
}
free ( s ) ;
2008-07-13 07:29:18 -07:00
2008-07-12 05:48:35 -07:00
return 1 ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-07-12 05:48:35 -07:00
edje_edit_spectra_name_set ( Evas_Object * obj , const char * spectra , const char * name )
{
Edje_Spectrum_Directory_Entry * s ;
2008-07-13 07:29:18 -07:00
2008-07-12 05:48:35 -07:00
GET_ED_OR_RETURN ( 0 ) ;
2009-10-26 14:28:39 -07:00
//printf("SET SPECTRA NAME for spectra: %s [new name:%s]\n", spectra, name);
2008-07-13 07:29:18 -07:00
2008-07-12 05:48:35 -07:00
s = _edje_edit_spectrum_entry_get ( ed , spectra ) ;
if ( ! s ) return 0 ;
2008-07-13 07:29:18 -07:00
2008-07-12 05:48:35 -07:00
_edje_if_string_free ( ed , s - > entry ) ;
2008-10-15 07:11:11 -07:00
s - > entry = ( char * ) eina_stringshare_add ( name ) ;
2008-07-13 07:29:18 -07:00
2008-07-12 05:48:35 -07:00
return 1 ;
}
EAPI int
edje_edit_spectra_stop_num_get ( Evas_Object * obj , const char * spectra )
{
Edje_Spectrum_Directory_Entry * s ;
2008-07-13 07:29:18 -07:00
2008-07-14 18:03:24 -07:00
GET_ED_OR_RETURN ( 0 ) ;
2008-07-13 07:29:18 -07:00
2008-07-14 18:03:24 -07:00
//printf("GET SPECTRA STOP NUM for spectra: %s\n", spectra);
2008-07-13 07:29:18 -07:00
2008-07-12 05:48:35 -07:00
s = _edje_edit_spectrum_entry_get ( ed , spectra ) ;
2008-07-14 18:03:24 -07:00
if ( ! s ) return 0 ;
2008-07-13 07:29:18 -07:00
2008-10-22 04:34:42 -07:00
return eina_list_count ( s - > color_list ) ;
2008-07-12 05:48:35 -07:00
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-07-12 05:48:35 -07:00
edje_edit_spectra_stop_num_set ( Evas_Object * obj , const char * spectra , int num )
{
Edje_Spectrum_Directory_Entry * s ;
Edje_Spectrum_Color * color ;
GET_ED_OR_RETURN ( 0 ) ;
2008-07-13 07:29:18 -07:00
2009-10-26 14:28:39 -07:00
//printf("SET SPECTRA STOP NUM for spectra: %s\n", spectra);
2008-07-13 07:29:18 -07:00
2008-07-12 05:48:35 -07:00
s = _edje_edit_spectrum_entry_get ( ed , spectra ) ;
if ( ! s ) return 0 ;
2008-07-13 07:29:18 -07:00
2008-10-22 04:34:42 -07:00
if ( num = = eina_list_count ( s - > color_list ) ) return 1 ;
2008-07-13 07:29:18 -07:00
2008-07-12 05:48:35 -07:00
//destroy all colors
while ( s - > color_list )
{
2008-10-22 04:34:42 -07:00
color = eina_list_data_get ( s - > color_list ) ;
2008-07-12 05:48:35 -07:00
free ( color ) ;
2008-10-22 04:34:42 -07:00
s - > color_list = eina_list_remove_list ( s - > color_list , s - > color_list ) ;
2008-07-12 05:48:35 -07:00
}
2008-07-13 07:29:18 -07:00
//... and recreate (TODO we should optimize this function)
2008-07-12 05:48:35 -07:00
while ( num )
{
2009-08-17 07:13:26 -07:00
color = _alloc ( sizeof ( Edje_Spectrum_Color ) ) ;
2009-08-17 06:54:17 -07:00
if ( ! color ) return 0 ;
2008-10-22 04:34:42 -07:00
s - > color_list = eina_list_append ( s - > color_list , color ) ;
2008-07-12 05:48:35 -07:00
color - > r = 255 ;
color - > g = 255 ;
color - > b = 255 ;
color - > a = 255 ;
color - > d = 10 ;
num - - ;
}
2008-07-13 07:29:18 -07:00
2008-07-12 05:48:35 -07:00
return 1 ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-07-12 05:48:35 -07:00
edje_edit_spectra_stop_color_get ( Evas_Object * obj , const char * spectra , int stop_number , int * r , int * g , int * b , int * a , int * d )
{
Edje_Spectrum_Directory_Entry * s ;
Edje_Spectrum_Color * color ;
GET_ED_OR_RETURN ( 0 ) ;
2008-07-13 07:29:18 -07:00
2008-07-12 05:48:35 -07:00
s = _edje_edit_spectrum_entry_get ( ed , spectra ) ;
if ( ! s ) return 0 ;
2008-07-14 18:03:24 -07:00
//printf("GET SPECTRA STOP COLOR for spectra: %s stopn: %d\n", spectra, stop_number);
2008-07-13 07:29:18 -07:00
2008-10-22 04:34:42 -07:00
color = eina_list_nth ( s - > color_list , stop_number ) ;
2008-07-12 05:48:35 -07:00
if ( ! color ) return 0 ;
if ( r ) * r = color - > r ;
if ( g ) * g = color - > g ;
if ( b ) * b = color - > b ;
if ( a ) * a = color - > a ;
if ( d ) * d = color - > d ;
2008-07-13 07:29:18 -07:00
2008-07-12 05:48:35 -07:00
return 1 ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-07-12 05:48:35 -07:00
edje_edit_spectra_stop_color_set ( Evas_Object * obj , const char * spectra , int stop_number , int r , int g , int b , int a , int d )
{
Edje_Spectrum_Directory_Entry * s ;
Edje_Spectrum_Color * color ;
GET_ED_OR_RETURN ( 0 ) ;
2008-07-13 07:29:18 -07:00
2008-07-12 05:48:35 -07:00
s = _edje_edit_spectrum_entry_get ( ed , spectra ) ;
if ( ! s ) return 0 ;
2009-10-26 14:28:39 -07:00
//printf("SET SPECTRA STOP COLOR for spectra: %s stopn: %d\n", spectra, stop_number);
2008-07-13 07:29:18 -07:00
2008-10-22 04:34:42 -07:00
color = eina_list_nth ( s - > color_list , stop_number ) ;
2008-07-12 05:48:35 -07:00
if ( ! color ) return 0 ;
color - > r = r ;
color - > g = g ;
color - > b = b ;
color - > a = a ;
color - > d = d ;
2008-07-13 07:29:18 -07:00
2008-07-12 05:48:35 -07:00
edje_object_calc_force ( obj ) ;
2008-07-13 07:29:18 -07:00
2008-07-12 05:48:35 -07:00
return 1 ;
}
/******************/
/* GRADIENT API */
/******************/
EAPI const char *
edje_edit_state_gradient_type_get ( Evas_Object * obj , const char * part , const char * state )
{
GET_PD_OR_RETURN ( NULL ) ;
if ( ! pd - > gradient . type )
return NULL ;
// printf("GET GRADIENT TYPE for part: %s state: %s [%s]\n", part, state, pd->gradient.type);
2008-10-15 07:11:11 -07:00
return eina_stringshare_add ( pd - > gradient . type ) ;
2008-07-12 05:48:35 -07:00
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-07-12 05:48:35 -07:00
edje_edit_state_gradient_type_set ( Evas_Object * obj , const char * part , const char * state , const char * type )
{
GET_PD_OR_RETURN ( 0 ) ;
if ( ! type ) return 0 ;
// printf("SET GRADIENT TYPE for part: %s state: %s TO: %s\n", part, state, type);
_edje_if_string_free ( ed , pd - > gradient . type ) ;
2008-10-15 07:11:11 -07:00
pd - > gradient . type = ( char * ) eina_stringshare_add ( type ) ;
2008-07-12 05:48:35 -07:00
edje_object_calc_force ( obj ) ;
return 1 ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-07-12 05:48:35 -07:00
edje_edit_state_gradient_use_fill_get ( Evas_Object * obj , const char * part , const char * state )
{
GET_PD_OR_RETURN ( - 1 ) ;
if ( ! pd - > gradient . type )
return - 1 ;
2008-07-13 07:29:18 -07:00
2008-10-07 07:11:11 -07:00
//~ if (!strcmp(pd->gradient.type, "linear"))
//~ return 0;
2008-07-12 05:48:35 -07:00
return 1 ;
}
2008-07-13 07:18:17 -07:00
EAPI const char *
edje_edit_state_gradient_spectra_get ( Evas_Object * obj , const char * part , const char * state )
2008-07-12 05:48:35 -07:00
{
2008-07-13 07:18:17 -07:00
Edje_Spectrum_Directory_Entry * s ;
2008-07-13 07:29:18 -07:00
2008-07-13 07:18:17 -07:00
GET_PD_OR_RETURN ( 0 ) ;
//printf("GET GRADIENT SPECTRA for part: %s state: %s\n", part, state);
s = _edje_edit_spectrum_entry_get_by_id ( ed , pd - > gradient . id ) ;
if ( ! s ) return 0 ;
2008-07-13 07:29:18 -07:00
2008-10-15 07:11:11 -07:00
return eina_stringshare_add ( s - > entry ) ;
2008-07-13 07:18:17 -07:00
}
2008-07-12 05:48:35 -07:00
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-07-12 05:48:35 -07:00
edje_edit_state_gradient_spectra_set ( Evas_Object * obj , const char * part , const char * state , const char * spectra )
{
Edje_Spectrum_Directory_Entry * s ;
2008-07-13 07:29:18 -07:00
2008-07-12 05:48:35 -07:00
GET_PD_OR_RETURN ( 0 ) ;
2009-10-26 14:28:39 -07:00
//printf("SET GRADIENT SPECTRA for part: %s state: %s [%s]\n", part, state, spectra);
2008-07-13 07:29:18 -07:00
2008-07-12 05:48:35 -07:00
s = _edje_edit_spectrum_entry_get ( ed , spectra ) ;
if ( ! s ) return 0 ;
2008-07-13 07:18:17 -07:00
2008-07-12 05:48:35 -07:00
pd - > gradient . id = s - > id ;
edje_object_calc_force ( obj ) ;
2008-07-13 07:29:18 -07:00
2008-07-12 05:48:35 -07:00
return 1 ;
}
2008-10-07 07:11:11 -07:00
EAPI int
edje_edit_state_gradient_angle_get ( Evas_Object * obj , const char * part , const char * state )
{
GET_PD_OR_RETURN ( 0 ) ;
return pd - > fill . angle ;
}
EAPI void
edje_edit_state_gradient_angle_set ( Evas_Object * obj , const char * part , const char * state , int angle )
{
GET_PD_OR_RETURN ( ) ;
pd - > fill . angle = angle ;
edje_object_calc_force ( obj ) ;
}
2008-07-12 05:48:35 -07:00
EAPI double
edje_edit_state_gradient_rel1_relative_x_get ( Evas_Object * obj , const char * part , const char * state )
{
GET_PD_OR_RETURN ( 0 ) ;
//printf("GET GRADIENT REL1 RELX for part: %s state: %s [%f]\n", part, state, pd->gradient.rel1.relative_x);
return pd - > gradient . rel1 . relative_x ;
}
EAPI double
edje_edit_state_gradient_rel1_relative_y_get ( Evas_Object * obj , const char * part , const char * state )
{
GET_PD_OR_RETURN ( 0 ) ;
//printf("GET GRADIENT REL1 RELY for part: %s state: %s [%f]\n", part, state, pd->gradient.rel1.relative_y);
return pd - > gradient . rel1 . relative_y ;
}
EAPI double
edje_edit_state_gradient_rel2_relative_x_get ( Evas_Object * obj , const char * part , const char * state )
{
GET_PD_OR_RETURN ( 0 ) ;
//printf("GET GRADIENT REL2 RELX for part: %s state: %s [%f]\n", part, state, pd->gradient.rel2.relative_x);
return pd - > gradient . rel2 . relative_x ;
}
EAPI double
edje_edit_state_gradient_rel2_relative_y_get ( Evas_Object * obj , const char * part , const char * state )
{
GET_PD_OR_RETURN ( 0 ) ;
//printf("GET GRADIENT REL2 RELY for part: %s state: %s [%f]\n", part, state, pd->gradient.rel2.relative_y);
return pd - > gradient . rel2 . relative_y ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-07-12 05:48:35 -07:00
edje_edit_state_gradient_rel1_relative_x_set ( Evas_Object * obj , const char * part , const char * state , double val )
{
GET_PD_OR_RETURN ( 0 ) ;
2008-07-14 18:03:24 -07:00
//printf("SET GRADIENT REL1 RELX for part: %s state: %s [TO %f]\n", part, state, val);
2008-07-12 05:48:35 -07:00
pd - > gradient . rel1 . relative_x = val ;
edje_object_calc_force ( obj ) ;
return 1 ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-07-12 05:48:35 -07:00
edje_edit_state_gradient_rel1_relative_y_set ( Evas_Object * obj , const char * part , const char * state , double val )
{
GET_PD_OR_RETURN ( 0 ) ;
2009-10-26 14:28:39 -07:00
//printf("SET GRADIENT REL1 RELY for part: %s state: %s [TO %f]\n", part, state, val);
2008-07-12 05:48:35 -07:00
pd - > gradient . rel1 . relative_y = val ;
edje_object_calc_force ( obj ) ;
return 1 ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-07-12 05:48:35 -07:00
edje_edit_state_gradient_rel2_relative_x_set ( Evas_Object * obj , const char * part , const char * state , double val )
{
GET_PD_OR_RETURN ( 0 ) ;
2009-10-26 14:28:39 -07:00
//printf("SET GRADIENT REL2 RELX for part: %s state: %s [TO %f]\n", part, state, val);
2008-07-12 05:48:35 -07:00
pd - > gradient . rel2 . relative_x = val ;
edje_object_calc_force ( obj ) ;
return 1 ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-07-12 05:48:35 -07:00
edje_edit_state_gradient_rel2_relative_y_set ( Evas_Object * obj , const char * part , const char * state , double val )
{
GET_PD_OR_RETURN ( 0 ) ;
2009-10-26 14:28:39 -07:00
//printf("SET GRADIENT REL2 RELY for part: %s state: %s [TO %f]\n", part, state, val);
2008-07-12 05:48:35 -07:00
pd - > gradient . rel2 . relative_y = val ;
edje_object_calc_force ( obj ) ;
return 1 ;
}
EAPI int
edje_edit_state_gradient_rel1_offset_x_get ( Evas_Object * obj , const char * part , const char * state )
{
GET_PD_OR_RETURN ( 0 ) ;
//printf("GET GRADIENT REL1 OFFSETX for part: %s state: %s [%f]\n", part, state, pd->gradient.rel1.offset_x);
return pd - > gradient . rel1 . offset_x ;
}
EAPI int
edje_edit_state_gradient_rel1_offset_y_get ( Evas_Object * obj , const char * part , const char * state )
{
GET_PD_OR_RETURN ( 0 ) ;
//printf("GET GRADIENT REL1 OFFSETY for part: %s state: %s [%f]\n", part, state, pd->gradient.rel1.offset_y);
return pd - > gradient . rel1 . offset_y ;
}
EAPI int
edje_edit_state_gradient_rel2_offset_x_get ( Evas_Object * obj , const char * part , const char * state )
{
GET_PD_OR_RETURN ( 0 ) ;
//printf("GET GRADIENT REL2 OFFSETX for part: %s state: %s [%f]\n", part, state, pd->gradient.rel2.offset_x);
return pd - > gradient . rel2 . offset_x ;
}
EAPI int
edje_edit_state_gradient_rel2_offset_y_get ( Evas_Object * obj , const char * part , const char * state )
{
GET_PD_OR_RETURN ( 0 ) ;
//printf("GET GRADIENT REL2 OFFSETY for part: %s state: %s [%f]\n", part, state, pd->gradient.rel2.offset_y);
return pd - > gradient . rel2 . offset_y ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-07-12 05:48:35 -07:00
edje_edit_state_gradient_rel1_offset_x_set ( Evas_Object * obj , const char * part , const char * state , int val )
{
GET_PD_OR_RETURN ( 0 ) ;
2009-10-26 14:28:39 -07:00
//printf("SET GRADIENT REL1 OFFSETX for part: %s state: %s [TO %d]\n", part, state, val);
2008-07-12 05:48:35 -07:00
pd - > gradient . rel1 . offset_x = val ;
edje_object_calc_force ( obj ) ;
return 1 ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-07-12 05:48:35 -07:00
edje_edit_state_gradient_rel1_offset_y_set ( Evas_Object * obj , const char * part , const char * state , int val )
{
GET_PD_OR_RETURN ( 0 ) ;
2009-10-26 14:28:39 -07:00
//printf("SET GRADIENT REL1 OFFSETY for part: %s state: %s [TO %d]\n", part, state, val);
2008-07-12 05:48:35 -07:00
pd - > gradient . rel1 . offset_y = val ;
edje_object_calc_force ( obj ) ;
return 1 ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-07-12 05:48:35 -07:00
edje_edit_state_gradient_rel2_offset_x_set ( Evas_Object * obj , const char * part , const char * state , int val )
{
GET_PD_OR_RETURN ( 0 ) ;
2009-10-26 14:28:39 -07:00
//printf("SET GRADIENT REL2 OFFSETX for part: %s state: %s [TO %d]\n", part, state, val);
2008-07-12 05:48:35 -07:00
pd - > gradient . rel2 . offset_x = val ;
edje_object_calc_force ( obj ) ;
return 1 ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-07-12 05:48:35 -07:00
edje_edit_state_gradient_rel2_offset_y_set ( Evas_Object * obj , const char * part , const char * state , int val )
{
GET_PD_OR_RETURN ( 0 ) ;
2009-10-26 14:28:39 -07:00
//printf("SET GRADIENT REL2 OFFSETY for part: %s state: %s [TO %d]\n", part, state, val);
2008-07-12 05:48:35 -07:00
pd - > gradient . rel2 . offset_y = val ;
edje_object_calc_force ( obj ) ;
return 1 ;
}
2008-03-06 11:48:11 -08:00
/******************/
/* PROGRAMS API */
/******************/
2008-03-13 12:08:14 -07:00
Edje_Program *
2008-03-06 11:48:11 -08:00
_edje_program_get_byname ( Evas_Object * obj , const char * prog_name )
{
Edje_Program * epr ;
int i ;
2008-03-13 12:01:53 -07:00
GET_ED_OR_RETURN ( NULL ) ;
2008-03-06 11:48:11 -08:00
if ( ! prog_name ) return NULL ;
for ( i = 0 ; i < ed - > table_programs_size ; i + + )
2008-03-13 12:01:53 -07:00
{
epr = ed - > table_programs [ i ] ;
2008-11-05 08:08:39 -08:00
if ( ( epr - > name ) & & ( strcmp ( epr - > name , prog_name ) = = 0 ) )
2008-03-13 12:01:53 -07:00
return epr ;
}
2008-03-06 11:48:11 -08:00
return NULL ;
}
2008-10-22 04:34:42 -07:00
EAPI Eina_List *
2008-03-06 11:48:11 -08:00
edje_edit_programs_list_get ( Evas_Object * obj )
{
2008-10-22 04:34:42 -07:00
Eina_List * progs = NULL ;
2008-03-06 11:48:11 -08:00
int i ;
2008-03-13 12:01:53 -07:00
GET_ED_OR_RETURN ( NULL ) ;
2008-03-06 11:48:11 -08:00
//printf("EE: Found %d programs\n", ed->table_programs_size);
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
for ( i = 0 ; i < ed - > table_programs_size ; i + + )
2008-03-13 12:01:53 -07:00
{
Edje_Program * epr ;
2008-05-30 01:00:25 -07:00
2008-03-13 12:01:53 -07:00
epr = ed - > table_programs [ i ] ;
2008-10-22 04:34:42 -07:00
progs = eina_list_append ( progs , eina_stringshare_add ( epr - > name ) ) ;
2008-03-13 12:01:53 -07:00
}
2008-03-06 11:48:11 -08:00
return progs ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_program_add ( Evas_Object * obj , const char * name )
{
Edje_Program * epr ;
Edje_Part_Collection * pc ;
2008-05-30 01:00:25 -07:00
2008-03-13 12:01:53 -07:00
GET_ED_OR_RETURN ( 0 ) ;
2009-10-26 14:28:39 -07:00
//printf("ADD PROGRAM [new name: %s]\n", name);
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
//Check if program already exists
if ( _edje_program_get_byname ( obj , name ) )
2008-03-13 12:01:53 -07:00
return 0 ;
2008-03-06 11:48:11 -08:00
//Alloc Edje_Program or return
2009-08-17 07:13:26 -07:00
epr = _alloc ( sizeof ( Edje_Program ) ) ;
2008-03-06 11:48:11 -08:00
if ( ! epr ) return 0 ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
//Add program to group
pc = ed - > collection ;
2008-10-22 04:34:42 -07:00
pc - > programs = eina_list_append ( pc - > programs , epr ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
//Init Edje_Program
2008-10-22 04:34:42 -07:00
epr - > id = eina_list_count ( pc - > programs ) - 1 ;
2008-10-15 07:11:11 -07:00
epr - > name = eina_stringshare_add ( name ) ;
2008-03-06 11:48:11 -08:00
epr - > signal = NULL ;
epr - > source = NULL ;
epr - > in . from = 0.0 ;
epr - > in . range = 0.0 ;
epr - > action = 0 ;
epr - > state = NULL ;
epr - > value = 0.0 ;
epr - > state2 = NULL ;
epr - > value2 = 0.0 ;
epr - > tween . mode = 1 ;
epr - > tween . time = 0.0 ;
epr - > targets = NULL ;
epr - > after = NULL ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
//Update table_programs
ed - > table_programs_size + + ;
ed - > table_programs = realloc ( ed - > table_programs ,
2008-03-13 12:01:53 -07:00
sizeof ( Edje_Program * ) * ed - > table_programs_size ) ;
2008-03-06 11:48:11 -08:00
ed - > table_programs [ epr - > id % ed - > table_programs_size ] = epr ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
//Update patterns
if ( ed - > patterns . programs . signals_patterns )
2008-03-13 12:01:53 -07:00
{
edje_match_patterns_free ( ed - > patterns . programs . signals_patterns ) ;
edje_match_patterns_free ( ed - > patterns . programs . sources_patterns ) ;
}
2008-03-06 11:48:11 -08:00
ed - > patterns . programs . signals_patterns = edje_match_programs_signal_init ( ed - > collection - > programs ) ;
ed - > patterns . programs . sources_patterns = edje_match_programs_source_init ( ed - > collection - > programs ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
return 1 ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_program_del ( Evas_Object * obj , const char * prog )
{
2008-10-22 04:34:42 -07:00
Eina_List * l ;
2008-05-30 01:00:25 -07:00
Edje_Part_Collection * pc ;
2008-03-06 11:48:11 -08:00
int id , i ;
2008-05-30 01:00:25 -07:00
int old_id ;
2008-03-13 12:01:53 -07:00
GET_ED_OR_RETURN ( 0 ) ;
GET_EPR_OR_RETURN ( 0 ) ;
2009-10-26 14:28:39 -07:00
//printf("DEL PROGRAM: %s\n", prog);
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
//Remove program from programs list
id = epr - > id ;
pc = ed - > collection ;
2008-10-22 04:34:42 -07:00
pc - > programs = eina_list_remove ( pc - > programs , epr ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
//Free Edje_Program
2008-03-08 15:11:32 -08:00
_edje_if_string_free ( ed , epr - > name ) ;
_edje_if_string_free ( ed , epr - > signal ) ;
_edje_if_string_free ( ed , epr - > source ) ;
_edje_if_string_free ( ed , epr - > state ) ;
_edje_if_string_free ( ed , epr - > state2 ) ;
2008-03-06 11:48:11 -08:00
while ( epr - > targets )
2008-03-13 12:01:53 -07:00
{
Edje_Program_Target * prt ;
2008-10-22 04:34:42 -07:00
prt = eina_list_data_get ( epr - > targets ) ;
epr - > targets = eina_list_remove_list ( epr - > targets , epr - > targets ) ;
2008-03-13 12:01:53 -07:00
free ( prt ) ;
}
2008-03-06 11:48:11 -08:00
while ( epr - > after )
2008-03-13 12:01:53 -07:00
{
Edje_Program_After * pa ;
2008-03-06 11:48:11 -08:00
2008-10-22 04:34:42 -07:00
pa = eina_list_data_get ( epr - > after ) ;
epr - > after = eina_list_remove_list ( epr - > after , epr - > after ) ;
2008-03-13 12:01:53 -07:00
free ( pa ) ;
}
2008-03-06 11:48:11 -08:00
free ( epr ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
//Update programs table
//We move the last program in place of the deleted one
//and realloc the table without the last element.
ed - > table_programs [ id % ed - > table_programs_size ] = ed - > table_programs [ ed - > table_programs_size - 1 ] ;
ed - > table_programs_size - - ;
ed - > table_programs = realloc ( ed - > table_programs ,
sizeof ( Edje_Program * ) * ed - > table_programs_size ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
//Update the id of the moved program
if ( id < ed - > table_programs_size )
2008-03-13 12:01:53 -07:00
{
Edje_Program * p ;
2008-05-30 01:00:25 -07:00
2008-03-13 12:01:53 -07:00
p = ed - > table_programs [ id % ed - > table_programs_size ] ;
2009-10-26 14:28:39 -07:00
//printf("UPDATE: %s(id:%d) with new id: %d\n",
// p->name, p->id, id);
2008-03-13 12:01:53 -07:00
old_id = p - > id ;
p - > id = id ;
}
else
old_id = - 1 ;
2008-03-06 11:48:11 -08:00
//We also update all other programs that point to old_id and id
for ( i = 0 ; i < ed - > table_programs_size ; i + + )
2008-03-13 12:01:53 -07:00
{
Edje_Program * p ;
2008-05-30 01:00:25 -07:00
2008-03-13 12:01:53 -07:00
p = ed - > table_programs [ i ] ;
2008-03-13 12:08:14 -07:00
// printf("Check dependencies on %s\n", p->name);
2008-03-13 12:01:53 -07:00
/* check in afters */
l = p - > after ;
while ( l )
{
Edje_Program_After * pa ;
2008-10-22 04:34:42 -07:00
pa = eina_list_data_get ( l ) ;
2008-03-13 12:01:53 -07:00
if ( pa - > id = = old_id )
{
// printf(" dep on after old_id\n");
pa - > id = id ;
}
else if ( pa - > id = = id )
{
// printf(" dep on after id\n");
2008-10-22 04:34:42 -07:00
p - > after = eina_list_remove ( p - > after , pa ) ;
2008-03-13 12:01:53 -07:00
}
2008-10-22 04:34:42 -07:00
if ( l ) l = eina_list_next ( l ) ;
2008-03-13 12:01:53 -07:00
}
/* check in targets */
if ( p - > action = = EDJE_ACTION_TYPE_ACTION_STOP )
{
l = p - > targets ;
while ( l )
{
Edje_Program_Target * pt ;
2008-10-22 04:34:42 -07:00
pt = eina_list_data_get ( l ) ;
2008-03-13 12:01:53 -07:00
if ( pt - > id = = old_id )
{
// printf(" dep on target old_id\n");
pt - > id = id ;
}
else if ( pt - > id = = id )
{
// printf(" dep on target id\n");
2008-10-22 04:34:42 -07:00
p - > targets = eina_list_remove ( p - > targets , pt ) ;
2008-03-13 12:01:53 -07:00
}
2008-10-22 04:34:42 -07:00
if ( l ) l = eina_list_next ( l ) ;
2008-03-13 12:01:53 -07:00
}
}
}
2008-03-06 11:48:11 -08:00
return 1 ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_program_exist ( Evas_Object * obj , const char * prog )
{
2008-03-13 12:01:53 -07:00
GET_EPR_OR_RETURN ( 0 ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
return 1 ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_program_run ( Evas_Object * obj , const char * prog )
{
2008-03-13 12:01:53 -07:00
GET_ED_OR_RETURN ( 0 ) ;
GET_EPR_OR_RETURN ( 0 ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
_edje_program_run ( ed , epr , 0 , " " , " " ) ;
return 1 ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_program_name_set ( Evas_Object * obj , const char * prog , const char * new_name )
{
2008-03-13 12:01:53 -07:00
GET_ED_OR_RETURN ( 0 ) ;
GET_EPR_OR_RETURN ( 0 ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
if ( ! new_name ) return 0 ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
if ( _edje_program_get_byname ( obj , new_name ) ) return 0 ;
2008-03-13 12:01:53 -07:00
2009-10-26 14:28:39 -07:00
//printf("SET NAME for program: %s [new name: %s]\n", prog, new_name);
2008-03-13 12:01:53 -07:00
2008-03-08 15:11:32 -08:00
_edje_if_string_free ( ed , epr - > name ) ;
2008-10-15 07:11:11 -07:00
epr - > name = eina_stringshare_add ( new_name ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
return 1 ;
}
2008-03-13 12:08:14 -07:00
EAPI const char *
2008-03-06 11:48:11 -08:00
edje_edit_program_source_get ( Evas_Object * obj , const char * prog )
{
2008-03-13 12:01:53 -07:00
GET_EPR_OR_RETURN ( NULL ) ;
2008-03-06 11:48:11 -08:00
if ( ! epr - > source ) return NULL ;
//printf("GET SOURCE for program: %s [%s]\n", prog, epr->source);
2008-10-15 07:11:11 -07:00
return eina_stringshare_add ( epr - > source ) ;
2008-03-06 11:48:11 -08:00
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_program_source_set ( Evas_Object * obj , const char * prog , const char * source )
{
2008-03-13 12:01:53 -07:00
GET_ED_OR_RETURN ( 0 ) ;
GET_EPR_OR_RETURN ( 0 ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
if ( ! source ) return 0 ;
2008-03-13 12:01:53 -07:00
2009-10-26 14:28:39 -07:00
//printf("SET SOURCE for program: %s [%s]\n", prog, source);
2008-03-13 12:01:53 -07:00
2008-03-08 15:11:32 -08:00
_edje_if_string_free ( ed , epr - > source ) ;
2008-10-15 07:11:11 -07:00
epr - > source = eina_stringshare_add ( source ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
//Update patterns
if ( ed - > patterns . programs . sources_patterns )
edje_match_patterns_free ( ed - > patterns . programs . sources_patterns ) ;
ed - > patterns . programs . sources_patterns = edje_match_programs_source_init ( ed - > collection - > programs ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
return 1 ;
}
2008-03-13 12:01:53 -07:00
EAPI const char *
2008-03-06 11:48:11 -08:00
edje_edit_program_signal_get ( Evas_Object * obj , const char * prog )
{
2008-03-13 12:01:53 -07:00
GET_EPR_OR_RETURN ( NULL ) ;
2008-03-06 11:48:11 -08:00
if ( ! epr - > signal ) return NULL ;
//printf("GET SIGNAL for program: %s [%s]\n", prog, epr->signal);
2008-10-15 07:11:11 -07:00
return eina_stringshare_add ( epr - > signal ) ;
2008-03-06 11:48:11 -08:00
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_program_signal_set ( Evas_Object * obj , const char * prog , const char * signal )
{
2008-03-13 12:01:53 -07:00
GET_ED_OR_RETURN ( 0 ) ;
GET_EPR_OR_RETURN ( 0 ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
if ( ! signal ) return 0 ;
2008-03-13 12:01:53 -07:00
2009-10-26 14:28:39 -07:00
//printf("SET SIGNAL for program: %s [%s]\n", prog, signal);
2008-03-13 12:01:53 -07:00
2008-03-08 15:11:32 -08:00
_edje_if_string_free ( ed , epr - > signal ) ;
2008-10-15 07:11:11 -07:00
epr - > signal = eina_stringshare_add ( signal ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
//Update patterns
if ( ed - > patterns . programs . signals_patterns )
edje_match_patterns_free ( ed - > patterns . programs . signals_patterns ) ;
ed - > patterns . programs . signals_patterns = edje_match_programs_signal_init ( ed - > collection - > programs ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
return 1 ;
}
2008-03-13 12:01:53 -07:00
EAPI const char *
2008-03-06 11:48:11 -08:00
edje_edit_program_state_get ( Evas_Object * obj , const char * prog )
{
2008-03-13 12:01:53 -07:00
GET_EPR_OR_RETURN ( NULL ) ;
2008-03-06 11:48:11 -08:00
if ( ! epr - > state ) return NULL ;
//printf("GET STATE for program: %s [%s %.2f]\n", prog, epr->state, epr->value);
2008-10-15 07:11:11 -07:00
return eina_stringshare_add ( epr - > state ) ;
2008-03-06 11:48:11 -08:00
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_program_state_set ( Evas_Object * obj , const char * prog , const char * state )
{
2008-03-13 12:01:53 -07:00
GET_ED_OR_RETURN ( 0 ) ;
GET_EPR_OR_RETURN ( 0 ) ;
2009-10-26 14:28:39 -07:00
//printf("SET STATE for program: %s\n", prog);
2008-03-13 12:01:53 -07:00
2008-03-08 15:11:32 -08:00
_edje_if_string_free ( ed , epr - > state ) ;
2008-10-15 07:11:11 -07:00
epr - > state = eina_stringshare_add ( state ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
return 1 ;
}
2008-03-13 12:08:14 -07:00
EAPI const char *
2008-03-06 11:48:11 -08:00
edje_edit_program_state2_get ( Evas_Object * obj , const char * prog )
{
2008-03-13 12:01:53 -07:00
GET_EPR_OR_RETURN ( NULL ) ;
2008-03-06 11:48:11 -08:00
if ( ! epr - > state2 ) return NULL ;
//printf("GET STATE2 for program: %s [%s %.2f]\n", prog, epr->state2, epr->value2);
2008-10-15 07:11:11 -07:00
return eina_stringshare_add ( epr - > state2 ) ;
2008-03-06 11:48:11 -08:00
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_program_state2_set ( Evas_Object * obj , const char * prog , const char * state2 )
{
2008-03-13 12:01:53 -07:00
GET_ED_OR_RETURN ( 0 ) ;
GET_EPR_OR_RETURN ( 0 ) ;
2009-10-26 14:28:39 -07:00
//printf("SET STATE2 for program: %s\n", prog);
2008-03-13 12:01:53 -07:00
2008-03-08 15:11:32 -08:00
_edje_if_string_free ( ed , epr - > state2 ) ;
2008-10-15 07:11:11 -07:00
epr - > state2 = eina_stringshare_add ( state2 ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
return 1 ;
}
EAPI double
edje_edit_program_value_get ( Evas_Object * obj , const char * prog )
{
2008-03-13 12:01:53 -07:00
GET_EPR_OR_RETURN ( - 1 ) ;
2008-03-06 11:48:11 -08:00
//printf("GET VALUE for program: %s [%s %.2f]\n", prog, epr->state, epr->value);
return epr - > value ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_program_value_set ( Evas_Object * obj , const char * prog , double value )
{
2008-03-13 12:01:53 -07:00
GET_EPR_OR_RETURN ( 0 ) ;
2008-03-06 11:48:11 -08:00
//printf("SET VALUE for program: %s [%.2f]\n", prog, value);
epr - > value = value ;
return 1 ;
}
EAPI double
edje_edit_program_value2_get ( Evas_Object * obj , const char * prog )
{
2008-03-13 12:01:53 -07:00
GET_EPR_OR_RETURN ( - 1 ) ;
2008-03-06 11:48:11 -08:00
//printf("GET VALUE2 for program: %s [%s %.2f]\n", prog, epr->state2, epr->value2);
return epr - > value2 ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_program_value2_set ( Evas_Object * obj , const char * prog , double value )
{
2008-03-13 12:01:53 -07:00
GET_EPR_OR_RETURN ( 0 ) ;
2008-03-06 11:48:11 -08:00
//printf("SET VALUE for program: %s [%.2f]\n", prog, value);
epr - > value2 = value ;
return 1 ;
}
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
EAPI double
edje_edit_program_in_from_get ( Evas_Object * obj , const char * prog )
{
2008-03-13 12:01:53 -07:00
GET_EPR_OR_RETURN ( 0 ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
//printf("GET IN.FROM for program: %s [%f]\n", prog, epr->in.from);
return epr - > in . from ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_program_in_from_set ( Evas_Object * obj , const char * prog , double seconds )
{
2008-03-13 12:01:53 -07:00
GET_EPR_OR_RETURN ( 0 ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
//printf("SET IN.FROM for program: %s [%f]\n", prog, epr->in.from);
epr - > in . from = seconds ;
return 1 ;
}
EAPI double
edje_edit_program_in_range_get ( Evas_Object * obj , const char * prog )
{
2008-03-13 12:01:53 -07:00
GET_EPR_OR_RETURN ( 0 ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
//printf("GET IN.RANGE for program: %s [%f]\n", prog, epr->in.range);
return epr - > in . range ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_program_in_range_set ( Evas_Object * obj , const char * prog , double seconds )
{
2008-03-13 12:01:53 -07:00
GET_EPR_OR_RETURN ( 0 ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
//printf("SET IN.RANGE for program: %s [%f]\n", prog, epr->in.range);
epr - > in . range = seconds ;
return 1 ;
}
2009-09-15 20:37:28 -07:00
EAPI Edje_Tween_Mode
2008-03-06 11:48:11 -08:00
edje_edit_program_transition_get ( Evas_Object * obj , const char * prog )
{
2008-03-13 12:01:53 -07:00
GET_EPR_OR_RETURN ( - 1 ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
//printf("GET TRANSITION for program: %s [%d]\n", prog, epr->tween.mode);
return epr - > tween . mode ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
edje_edit_program_transition_set ( Evas_Object * obj , const char * prog , Edje_Tween_Mode transition )
2008-03-06 11:48:11 -08:00
{
2008-03-13 12:01:53 -07:00
GET_EPR_OR_RETURN ( 0 ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
//printf("GET TRANSITION for program: %s [%d]\n", prog, epr->tween.mode);
epr - > tween . mode = transition ;
return 1 ;
}
EAPI double
edje_edit_program_transition_time_get ( Evas_Object * obj , const char * prog )
{
2008-03-13 12:01:53 -07:00
GET_EPR_OR_RETURN ( - 1 ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
//printf("GET TRANSITION_TIME for program: %s [%.4f]\n", prog, epr->tween.time);
return epr - > tween . time ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_program_transition_time_set ( Evas_Object * obj , const char * prog , double seconds )
{
2008-03-13 12:01:53 -07:00
GET_EPR_OR_RETURN ( 0 ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
//printf("GET TRANSITION_TIME for program: %s [%.4f]\n", prog, epr->tween.time);
epr - > tween . time = seconds ;
return 1 ;
}
2009-09-15 20:37:28 -07:00
EAPI Edje_Action_Type
2008-03-06 11:48:11 -08:00
edje_edit_program_action_get ( Evas_Object * obj , const char * prog )
{
2008-03-13 12:01:53 -07:00
GET_EPR_OR_RETURN ( - 1 ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
//printf("GET ACTION for program: %s [%d]\n", prog, epr->action);
return epr - > action ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
edje_edit_program_action_set ( Evas_Object * obj , const char * prog , Edje_Action_Type action )
2008-03-06 11:48:11 -08:00
{
2008-03-13 12:01:53 -07:00
GET_EPR_OR_RETURN ( 0 ) ;
2008-05-30 01:00:25 -07:00
2008-03-06 11:48:11 -08:00
//printf("SET ACTION for program: %s [%d]\n", prog, action);
if ( action > = EDJE_ACTION_TYPE_LAST ) return 0 ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
epr - > action = action ;
return 1 ;
}
2008-10-22 04:34:42 -07:00
EAPI Eina_List *
2008-03-06 11:48:11 -08:00
edje_edit_program_targets_get ( Evas_Object * obj , const char * prog )
{
2008-10-22 04:34:42 -07:00
Eina_List * l , * targets = NULL ;
Edje_Program_Target * t ;
2008-03-13 12:01:53 -07:00
GET_ED_OR_RETURN ( NULL ) ;
GET_EPR_OR_RETURN ( NULL ) ;
2008-10-22 04:34:42 -07:00
//printf("GET TARGETS for program: %s [count: %d]\n", prog, eina_list_count(epr->targets));
EINA_LIST_FOREACH ( epr - > targets , l , t )
2008-03-13 12:01:53 -07:00
{
if ( epr - > action = = EDJE_ACTION_TYPE_STATE_SET )
{
/* the target is a part */
Edje_Real_Part * p = NULL ;
2008-05-30 01:00:25 -07:00
2008-03-13 12:01:53 -07:00
p = ed - > table_parts [ t - > id % ed - > table_parts_size ] ;
if ( p & & p - > part & & p - > part - > name )
2008-10-22 04:34:42 -07:00
targets = eina_list_append ( targets ,
2008-10-15 07:11:11 -07:00
eina_stringshare_add ( p - > part - > name ) ) ;
2008-03-13 12:01:53 -07:00
}
else if ( epr - > action = = EDJE_ACTION_TYPE_ACTION_STOP )
{
/* the target is a program */
Edje_Program * p ;
2008-05-30 01:00:25 -07:00
2008-03-13 12:01:53 -07:00
p = ed - > table_programs [ t - > id % ed - > table_programs_size ] ;
if ( p & & p - > name )
2008-10-22 04:34:42 -07:00
targets = eina_list_append ( targets ,
2008-10-15 07:11:11 -07:00
eina_stringshare_add ( p - > name ) ) ;
2008-03-13 12:01:53 -07:00
}
}
2008-03-06 11:48:11 -08:00
return targets ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_program_targets_clear ( Evas_Object * obj , const char * prog )
{
2008-03-13 12:01:53 -07:00
GET_EPR_OR_RETURN ( 0 ) ;
2008-03-06 11:48:11 -08:00
while ( epr - > targets )
2008-03-13 12:01:53 -07:00
{
Edje_Program_Target * prt ;
2008-10-22 04:34:42 -07:00
prt = eina_list_data_get ( epr - > targets ) ;
epr - > targets = eina_list_remove_list ( epr - > targets , epr - > targets ) ;
2008-03-13 12:01:53 -07:00
free ( prt ) ;
}
2008-03-06 11:48:11 -08:00
return 1 ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_program_target_add ( Evas_Object * obj , const char * prog , const char * target )
{
int id ;
Edje_Program_Target * t ;
2008-05-30 01:00:25 -07:00
2008-03-13 12:01:53 -07:00
GET_ED_OR_RETURN ( 0 ) ;
GET_EPR_OR_RETURN ( 0 ) ;
2008-03-06 11:48:11 -08:00
if ( epr - > action = = EDJE_ACTION_TYPE_STATE_SET )
2008-03-13 12:01:53 -07:00
{
/* the target is a part */
Edje_Real_Part * rp ;
2008-05-30 01:00:25 -07:00
2008-03-13 12:01:53 -07:00
rp = _edje_real_part_get ( ed , target ) ;
if ( ! rp ) return 0 ;
id = rp - > part - > id ;
}
2008-03-06 11:48:11 -08:00
else if ( epr - > action = = EDJE_ACTION_TYPE_ACTION_STOP )
2008-03-13 12:01:53 -07:00
{
/* the target is a program */
Edje_Program * tar ;
2008-05-30 01:00:25 -07:00
2008-03-13 12:01:53 -07:00
tar = _edje_program_get_byname ( obj , target ) ;
if ( ! tar ) return 0 ;
id = tar - > id ;
}
2008-03-06 11:48:11 -08:00
else
2008-03-13 12:01:53 -07:00
return 0 ;
2009-08-17 07:13:26 -07:00
t = _alloc ( sizeof ( Edje_Program_Target ) ) ;
2008-03-06 11:48:11 -08:00
if ( ! t ) return 0 ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
t - > id = id ;
2008-10-22 04:34:42 -07:00
epr - > targets = eina_list_append ( epr - > targets , t ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
return 1 ;
}
2008-10-22 04:34:42 -07:00
EAPI Eina_List *
2008-03-06 11:48:11 -08:00
edje_edit_program_afters_get ( Evas_Object * obj , const char * prog )
{
2008-10-22 04:34:42 -07:00
Eina_List * l , * afters = NULL ;
Edje_Program_After * a ;
2008-03-13 12:01:53 -07:00
GET_ED_OR_RETURN ( NULL ) ;
GET_EPR_OR_RETURN ( NULL ) ;
2008-10-22 04:34:42 -07:00
// printf("GET AFTERS for program: %s [count: %d]\n", prog, eina_list_count(epr->after));
EINA_LIST_FOREACH ( epr - > after , l , a )
2008-03-13 12:01:53 -07:00
{
Edje_Program * p = NULL ;
p = ed - > table_programs [ a - > id % ed - > table_programs_size ] ;
if ( p & & p - > name )
{
2009-10-26 14:28:39 -07:00
//printf(" a: %d name: %s\n", a->id, p->name);
2008-10-22 04:34:42 -07:00
afters = eina_list_append ( afters , eina_stringshare_add ( p - > name ) ) ;
2008-03-13 12:01:53 -07:00
}
}
2008-03-06 11:48:11 -08:00
return afters ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_program_afters_clear ( Evas_Object * obj , const char * prog )
{
2008-03-13 12:01:53 -07:00
GET_EPR_OR_RETURN ( 0 ) ;
2008-03-06 11:48:11 -08:00
while ( epr - > after )
2008-03-13 12:01:53 -07:00
{
Edje_Program_After * pa ;
2008-05-30 01:00:25 -07:00
2008-10-22 04:34:42 -07:00
pa = eina_list_data_get ( epr - > after ) ;
epr - > after = eina_list_remove_list ( epr - > after , epr - > after ) ;
2008-03-13 12:01:53 -07:00
free ( pa ) ;
}
2008-03-06 11:48:11 -08:00
return 1 ;
}
2009-09-15 20:37:28 -07:00
EAPI Eina_Bool
2008-03-06 11:48:11 -08:00
edje_edit_program_after_add ( Evas_Object * obj , const char * prog , const char * after )
{
Edje_Program * af ;
Edje_Program_After * a ;
2008-05-30 01:00:25 -07:00
2008-03-13 12:01:53 -07:00
GET_EPR_OR_RETURN ( 0 ) ;
2008-03-06 11:48:11 -08:00
af = _edje_program_get_byname ( obj , after ) ;
if ( ! af ) return 0 ;
2008-03-13 12:01:53 -07:00
2009-08-17 07:13:26 -07:00
a = _alloc ( sizeof ( Edje_Program_After ) ) ;
2008-03-06 11:48:11 -08:00
if ( ! a ) return 0 ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
a - > id = af - > id ;
2008-03-13 12:01:53 -07:00
2008-10-22 04:34:42 -07:00
epr - > after = eina_list_append ( epr - > after , a ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
return 1 ;
}
/*************************/
/* EMBRYO SCRIPTS API */
/*************************/
2008-03-13 12:08:14 -07:00
EAPI const char *
2008-03-06 11:48:11 -08:00
edje_edit_script_get ( Evas_Object * obj )
{
Embryo_Program * script = NULL ;
2008-03-13 12:01:53 -07:00
GET_ED_OR_RETURN ( NULL ) ;
2008-03-06 11:48:11 -08:00
if ( ! ed - > collection ) return NULL ;
if ( ! ed - > collection - > script ) return NULL ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
script = ed - > collection - > script ;
2008-03-13 12:01:53 -07:00
2008-03-13 09:01:35 -07:00
printf ( " Get Script [%p] %d \n " , script , embryo_program_recursion_get ( script ) ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
return " Not yet complete... " ;
}
2008-10-08 17:04:18 -07:00
/***************************/
/* EDC SOURCE GENERATION */
/***************************/
2008-06-13 18:13:16 -07:00
# define I0 ""
# define I1 " "
# define I2 " "
# define I3 " "
# define I4 " "
# define I5 " "
# define I6 " "
2008-10-07 07:11:11 -07:00
# define I7 " "
2008-06-13 18:13:16 -07:00
static char * types [ ] = { " NONE " , " RECT " , " TEXT " , " IMAGE " , " SWALLOW " , " TEXTBLOCK " , " GRADIENT " , " GROUP " } ;
2008-10-02 17:20:19 -07:00
static char * effects [ ] = { " NONE " , " PLAIN " , " OUTLINE " , " SOFT_OUTLINE " , " SHADOW " , " SOFT_SHADOW " , " OUTLINE_SHADOW " , " OUTLINE_SOFT_SHADOW " , " FAR_SHADOW " , " FAR_SOFT_SHADOW " , " GLOW " } ;
static char * prefers [ ] = { " NONE " , " VERTICAL " , " HORIZONTAL " , " BOTH " } ;
2008-09-23 10:47:31 -07:00
static void
_edje_generate_source_of_spectra ( Edje * ed , const char * name , FILE * f )
{
Edje_Spectrum_Directory_Entry * d ;
Edje_Spectrum_Color * color = NULL ;
2008-10-22 04:34:42 -07:00
Eina_List * l ;
2008-09-23 10:47:31 -07:00
if ( ! ed | | ! name | | ! f ) return ;
2008-10-26 21:10:31 -07:00
if ( ( d = _edje_edit_spectrum_entry_get ( ed , name ) ) )
2008-09-23 10:47:31 -07:00
{
2008-11-02 06:10:11 -08:00
fprintf ( f , I1 " spectrum { name: \" %s \" ; \n " , d - > entry ) ;
2008-09-23 10:47:31 -07:00
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( d - > color_list , l , color )
if ( color )
fprintf ( f , I2 " color: %d %d %d %d %d; \n " , color - > r , color - > g ,
color - > b , color - > a , color - > d ) ;
2008-09-23 10:47:31 -07:00
2008-09-28 15:45:47 -07:00
fprintf ( f , I1 " } \n " ) ;
2008-09-23 10:47:31 -07:00
}
}
2008-09-28 15:45:47 -07:00
static void
_edje_generate_source_of_colorclass ( Edje * ed , const char * name , FILE * f )
{
2008-10-22 04:34:42 -07:00
Eina_List * l ;
2008-09-28 15:45:47 -07:00
Edje_Color_Class * cc ;
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ed - > file - > color_classes , l , cc )
if ( ! strcmp ( cc - > name , name ) )
{
2008-11-02 06:10:11 -08:00
fprintf ( f , I1 " color_class { name: \" %s \" ; \n " , cc - > name ) ;
2008-10-22 04:34:42 -07:00
fprintf ( f , I2 " color: %d %d %d %d; \n " , cc - > r , cc - > g , cc - > b , cc - > a ) ;
fprintf ( f , I2 " color2: %d %d %d %d; \n " , cc - > r2 , cc - > g2 , cc - > b2 , cc - > a2 ) ;
fprintf ( f , I2 " color3: %d %d %d %d; \n " , cc - > r3 , cc - > g3 , cc - > b3 , cc - > a3 ) ;
fprintf ( f , I1 " } \n " ) ;
}
2008-09-28 15:45:47 -07:00
}
2008-11-02 06:10:11 -08:00
static void
_edje_generate_source_of_style ( Edje * ed , const char * name , FILE * f )
{
Eina_List * l , * ll ;
Edje_Style * s ;
Edje_Style_Tag * t ;
EINA_LIST_FOREACH ( ed - > file - > styles , l , s )
if ( ! strcmp ( s - > name , name ) )
{
t = s - > tags ? s - > tags - > data : NULL ;
fprintf ( f , I1 " style { name: \" %s \" ; \n " , s - > name ) ;
if ( t & & t - > value ) fprintf ( f , I2 " base: \" %s \" ; \n " , t - > value ) ;
EINA_LIST_FOREACH ( s - > tags , ll , t )
if ( ll - > prev & & t & & t - > value )
fprintf ( f , I2 " tag: \" %s \" \" %s \" ; \n " , t - > key , t - > value ) ; //TODO need some sort of escaping (at least for '\n')
fprintf ( f , I1 " } \n " ) ;
return ;
}
}
2008-09-28 15:45:47 -07:00
static void
2008-09-23 10:47:31 -07:00
_edje_generate_source_of_program ( Evas_Object * obj , const char * program , FILE * f )
{
2008-10-22 04:34:42 -07:00
Eina_List * l , * ll ;
2008-09-23 10:47:31 -07:00
const char * s , * s2 ;
double db , db2 ;
2008-10-22 04:34:42 -07:00
char * data ;
2008-09-23 10:47:31 -07:00
GET_ED_OR_RETURN ( ) ;
2008-11-02 06:10:11 -08:00
fprintf ( f , I3 " program { name: \" %s \" ; \n " , program ) ;
2008-09-23 10:47:31 -07:00
/* Signal */
2008-10-26 21:10:31 -07:00
if ( ( s = edje_edit_program_signal_get ( obj , program ) ) )
2008-09-23 10:47:31 -07:00
{
fprintf ( f , I4 " signal: \" %s \" ; \n " , s ) ;
edje_edit_string_free ( s ) ;
}
/* Source */
2008-10-26 21:10:31 -07:00
if ( ( s = edje_edit_program_source_get ( obj , program ) ) )
2008-09-23 10:47:31 -07:00
{
fprintf ( f , I4 " source: \" %s \" ; \n " , s ) ;
edje_edit_string_free ( s ) ;
}
/* Action */
switch ( edje_edit_program_action_get ( obj , program ) )
{
case EDJE_ACTION_TYPE_ACTION_STOP :
fprintf ( f , I4 " action: ACTION_STOP; \n " ) ;
break ;
case EDJE_ACTION_TYPE_STATE_SET :
2008-10-26 21:10:31 -07:00
if ( ( s = edje_edit_program_state_get ( obj , program ) ) )
2008-09-23 10:47:31 -07:00
{
fprintf ( f , I4 " action: STATE_SET \" %s \" %.2f; \n " , s ,
edje_edit_program_value_get ( obj , program ) ) ;
edje_edit_string_free ( s ) ;
}
break ;
case EDJE_ACTION_TYPE_SIGNAL_EMIT :
s = edje_edit_program_state_get ( obj , program ) ;
s2 = edje_edit_program_state2_get ( obj , program ) ;
if ( s & & s2 )
{
fprintf ( f , I4 " action: SIGNAL_EMIT \" %s \" \" %s \" ; \n " , s , s2 ) ;
edje_edit_string_free ( s ) ;
edje_edit_string_free ( s2 ) ;
}
break ;
2008-10-07 14:13:27 -07:00
//TODO Support Drag
2008-09-23 10:47:31 -07:00
//~ case EDJE_ACTION_TYPE_DRAG_VAL_SET:
//~ fprintf(f, I4"action: DRAG_VAL_SET TODO;\n");
//~ break;
//~ case EDJE_ACTION_TYPE_DRAG_VAL_STEP:
//~ fprintf(f, I4"action: DRAG_VAL_STEP TODO;\n");
//~ break;
//~ case EDJE_ACTION_TYPE_DRAG_VAL_PAGE:
//~ fprintf(f, I4"action: DRAG_VAL_PAGE TODO;\n");
//~ break;
}
/* Transition */
db = edje_edit_program_transition_time_get ( obj , program ) ;
switch ( edje_edit_program_transition_get ( obj , program ) )
{
case EDJE_TWEEN_MODE_LINEAR :
fprintf ( f , I4 " transition: LINEAR %.5f; \n " , db ) ;
break ;
case EDJE_TWEEN_MODE_ACCELERATE :
fprintf ( f , I4 " transition: ACCELERATE %.5f; \n " , db ) ;
break ;
case EDJE_TWEEN_MODE_DECELERATE :
fprintf ( f , I4 " transition: DECELERATE %.5f; \n " , db ) ;
break ;
case EDJE_TWEEN_MODE_SINUSOIDAL :
fprintf ( f , I4 " transition: SINUSOIDAL %.5f; \n " , db ) ;
break ;
}
/* In */
db = edje_edit_program_in_from_get ( obj , program ) ;
db2 = edje_edit_program_in_range_get ( obj , program ) ;
if ( db | | db2 )
fprintf ( f , I4 " in: %.5f %.5f; \n " , db , db2 ) ;
/* Targets */
2008-10-26 21:10:31 -07:00
if ( ( ll = edje_edit_program_targets_get ( obj , program ) ) )
2008-09-23 10:47:31 -07:00
{
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ll , l , data )
fprintf ( f , I4 " target: \" %s \" ; \n " , data ) ;
2008-09-23 10:47:31 -07:00
edje_edit_string_list_free ( ll ) ;
}
/* Afters */
2008-10-26 21:10:31 -07:00
if ( ( ll = edje_edit_program_afters_get ( obj , program ) ) )
2008-09-23 10:47:31 -07:00
{
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ll , l , data )
fprintf ( f , I4 " after: \" %s \" ; \n " , data ) ;
2008-09-23 10:47:31 -07:00
edje_edit_string_list_free ( ll ) ;
}
2008-10-07 14:13:27 -07:00
// TODO Support script {}
2008-09-23 10:47:31 -07:00
fprintf ( f , I3 " } \n " ) ;
}
2008-06-13 18:13:16 -07:00
2008-10-02 17:20:19 -07:00
static void
_edje_generate_source_of_state ( Evas_Object * obj , const char * part , const char * state , FILE * f )
{
2008-10-22 04:34:42 -07:00
Eina_List * l , * ll ;
2008-10-02 17:20:19 -07:00
Edje_Real_Part * rp ;
2008-10-07 07:11:11 -07:00
const char * str ;
2008-10-02 17:20:19 -07:00
GET_PD_OR_RETURN ( ) ;
rp = _edje_real_part_get ( ed , part ) ;
if ( ! rp ) return ;
2008-11-02 06:10:11 -08:00
fprintf ( f , I4 " description { state: \" %s \" %g; \n " , pd - > state . name , pd - > state . value ) ;
2008-10-02 17:20:19 -07:00
//TODO Support inherit
if ( ! pd - > visible )
fprintf ( f , I5 " visible: 0; \n " ) ;
if ( pd - > align . x ! = 0.5 | | pd - > align . y ! = 0.5 )
fprintf ( f , I5 " align: %g %g; \n " , pd - > align . x , pd - > align . y ) ;
//TODO Support fixed
if ( pd - > min . w | | pd - > min . h )
fprintf ( f , I5 " min: %d %d; \n " , pd - > min . w , pd - > min . h ) ;
if ( pd - > max . w ! = - 1 | | pd - > max . h ! = - 1 )
fprintf ( f , I5 " max: %d %d; \n " , pd - > max . w , pd - > max . h ) ;
//TODO Support step
if ( pd - > aspect . min | | pd - > aspect . max )
fprintf ( f , I5 " aspect: %g %g; \n " , pd - > aspect . min , pd - > aspect . max ) ;
if ( pd - > aspect . prefer )
fprintf ( f , I5 " aspect_preference: %s; \n " , prefers [ pd - > aspect . prefer ] ) ;
if ( pd - > color_class )
fprintf ( f , I5 " color_class: \" %s \" ; \n " , pd - > color_class ) ;
if ( pd - > color . r ! = 255 | | pd - > color . g ! = 255 | |
pd - > color . b ! = 255 | | pd - > color . a ! = 255 )
fprintf ( f , I5 " color: %d %d %d %d; \n " ,
pd - > color . r , pd - > color . g , pd - > color . b , pd - > color . a ) ;
if ( pd - > color2 . r ! = 0 | | pd - > color2 . g ! = 0 | |
pd - > color2 . b ! = 0 | | pd - > color2 . a ! = 255 )
fprintf ( f , I5 " color2: %d %d %d %d; \n " ,
pd - > color2 . r , pd - > color2 . g , pd - > color2 . b , pd - > color2 . a ) ;
if ( pd - > color3 . r ! = 0 | | pd - > color3 . g ! = 0 | |
pd - > color3 . b ! = 0 | | pd - > color3 . a ! = 128 )
fprintf ( f , I5 " color3: %d %d %d %d; \n " ,
pd - > color3 . r , pd - > color3 . g , pd - > color3 . b , pd - > color3 . a ) ;
//Rel1
2008-10-07 07:11:11 -07:00
if ( pd - > rel1 . relative_x | | pd - > rel1 . relative_y | | pd - > rel1 . offset_x | |
pd - > rel1 . offset_y | | pd - > rel1 . id_x ! = - 1 | | pd - > rel1 . id_y ! = - 1 )
2008-10-02 17:20:19 -07:00
{
2008-10-07 07:11:11 -07:00
fprintf ( f , I5 " rel1 { \n " ) ;
if ( pd - > rel1 . relative_x | | pd - > rel1 . relative_y )
fprintf ( f , I6 " relative: %g %g; \n " , pd - > rel1 . relative_x , pd - > rel1 . relative_y ) ;
if ( pd - > rel1 . offset_x | | pd - > rel1 . offset_y )
fprintf ( f , I6 " offset: %d %d; \n " , pd - > rel1 . offset_x , pd - > rel1 . offset_y ) ;
if ( pd - > rel1 . id_x ! = - 1 & & pd - > rel1 . id_x = = pd - > rel1 . id_y )
fprintf ( f , I6 " to: \" %s \" ; \n " , ed - > table_parts [ pd - > rel1 . id_x ] - > part - > name ) ;
else
{
if ( pd - > rel1 . id_x ! = - 1 )
fprintf ( f , I6 " to_x: \" %s \" ; \n " , ed - > table_parts [ pd - > rel1 . id_x ] - > part - > name ) ;
if ( pd - > rel1 . id_y ! = - 1 )
fprintf ( f , I6 " to_y: \" %s \" ; \n " , ed - > table_parts [ pd - > rel1 . id_y ] - > part - > name ) ;
}
fprintf ( f , I5 " } \n " ) ; //rel1
2008-10-02 17:20:19 -07:00
}
//Rel2
2008-10-07 07:11:11 -07:00
if ( pd - > rel2 . relative_x ! = 1.0 | | pd - > rel2 . relative_y ! = 1.0 | |
pd - > rel2 . offset_x ! = - 1 | | pd - > rel2 . offset_y ! = - 1 | |
pd - > rel2 . id_x ! = - 1 | | pd - > rel2 . id_y ! = - 1 )
2008-10-02 17:20:19 -07:00
{
2008-10-07 07:11:11 -07:00
fprintf ( f , I5 " rel2 { \n " ) ;
if ( pd - > rel2 . relative_x ! = 1.0 | | pd - > rel2 . relative_y ! = 1.0 )
fprintf ( f , I6 " relative: %g %g; \n " , pd - > rel2 . relative_x , pd - > rel2 . relative_y ) ;
if ( pd - > rel2 . offset_x ! = - 1 | | pd - > rel2 . offset_y ! = - 1 )
fprintf ( f , I6 " offset: %d %d; \n " , pd - > rel2 . offset_x , pd - > rel2 . offset_y ) ;
if ( pd - > rel2 . id_x ! = - 1 & & pd - > rel2 . id_x = = pd - > rel2 . id_y )
fprintf ( f , I6 " to: \" %s \" ; \n " , ed - > table_parts [ pd - > rel2 . id_x ] - > part - > name ) ;
else
{
if ( pd - > rel2 . id_x ! = - 1 )
fprintf ( f , I6 " to_x: \" %s \" ; \n " , ed - > table_parts [ pd - > rel2 . id_x ] - > part - > name ) ;
if ( pd - > rel2 . id_y ! = - 1 )
fprintf ( f , I6 " to_y: \" %s \" ; \n " , ed - > table_parts [ pd - > rel2 . id_y ] - > part - > name ) ;
}
fprintf ( f , I5 " } \n " ) ; //rel2
2008-10-02 17:20:19 -07:00
}
//Image
if ( rp - > part - > type = = EDJE_PART_TYPE_IMAGE )
2008-10-07 07:11:11 -07:00
{
2008-10-22 04:34:42 -07:00
char * data ;
2008-10-07 07:11:11 -07:00
fprintf ( f , I5 " image { \n " ) ;
fprintf ( f , I6 " normal: \" %s \" ; \n " , _edje_image_name_find ( obj , pd - > image . id ) ) ;
ll = edje_edit_state_tweens_list_get ( obj , part , state ) ;
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ll , l , data )
fprintf ( f , I6 " tween: \" %s \" ; \n " , data ) ;
2008-10-07 07:11:11 -07:00
edje_edit_string_list_free ( ll ) ;
2008-10-02 17:20:19 -07:00
2008-10-07 07:11:11 -07:00
if ( pd - > border . l | | pd - > border . r | | pd - > border . t | | pd - > border . b )
fprintf ( f , I6 " border: %d %d %d %d; \n " , pd - > border . l , pd - > border . r , pd - > border . t , pd - > border . b ) ;
2009-02-12 05:39:15 -08:00
if ( pd - > border . no_fill = = 1 )
fprintf ( f , I6 " middle: NONE; \n " ) ;
else if ( pd - > border . no_fill = = 0 )
fprintf ( f , I6 " middle: DEFAULT; \n " ) ;
else if ( pd - > border . no_fill = = 2 )
fprintf ( f , I6 " middle: SOLID; \n " ) ;
2008-10-07 14:13:27 -07:00
2008-10-07 07:11:11 -07:00
fprintf ( f , I5 " } \n " ) ; //image
}
//Fill
if ( rp - > part - > type = = EDJE_PART_TYPE_IMAGE | |
rp - > part - > type = = EDJE_PART_TYPE_GRADIENT )
{
fprintf ( f , I5 " fill { \n " ) ;
2008-10-07 09:01:56 -07:00
if ( rp - > part - > type = = EDJE_PART_TYPE_IMAGE & & ! pd - > fill . smooth )
2008-10-07 07:11:11 -07:00
fprintf ( f , I6 " smooth: 0; \n " ) ;
//TODO Support spread
2008-10-07 09:01:56 -07:00
if ( rp - > part - > type = = EDJE_PART_TYPE_GRADIENT & & pd - > fill . angle )
fprintf ( f , I6 " angle: %d; \n " , pd - > fill . angle ) ;
2008-10-07 07:11:11 -07:00
//TODO Support type
if ( pd - > fill . pos_rel_x | | pd - > fill . pos_rel_y | |
pd - > fill . pos_abs_x | | pd - > fill . pos_abs_y )
{
fprintf ( f , I6 " origin { \n " ) ;
if ( pd - > fill . pos_rel_x | | pd - > fill . pos_rel_y )
fprintf ( f , I7 " relative: %g %g; \n " , pd - > fill . pos_rel_x , pd - > fill . pos_rel_y ) ;
if ( pd - > fill . pos_abs_x | | pd - > fill . pos_abs_y )
fprintf ( f , I7 " offset: %d %d; \n " , pd - > fill . pos_abs_x , pd - > fill . pos_abs_y ) ;
fprintf ( f , I6 " } \n " ) ;
}
if ( pd - > fill . rel_x ! = 1.0 | | pd - > fill . rel_y ! = 1.0 | |
pd - > fill . abs_x | | pd - > fill . abs_y )
{
fprintf ( f , I6 " size { \n " ) ;
if ( pd - > fill . rel_x ! = 1.0 | | pd - > fill . rel_y ! = 1.0 )
fprintf ( f , I7 " relative: %g %g; \n " , pd - > fill . rel_x , pd - > fill . rel_y ) ;
if ( pd - > fill . abs_x | | pd - > fill . abs_y )
fprintf ( f , I7 " offset: %d %d; \n " , pd - > fill . abs_x , pd - > fill . abs_y ) ;
fprintf ( f , I6 " } \n " ) ;
}
fprintf ( f , I5 " } \n " ) ;
}
2008-10-02 17:20:19 -07:00
2008-10-07 07:11:11 -07:00
//Text
if ( rp - > part - > type = = EDJE_PART_TYPE_TEXT )
{
fprintf ( f , I5 " text { \n " ) ;
if ( pd - > text . text )
fprintf ( f , I6 " text: \" %s \" ; \n " , pd - > text . text ) ;
fprintf ( f , I6 " font: \" %s \" ; \n " , pd - > text . font ) ;
fprintf ( f , I6 " size: %d; \n " , pd - > text . size ) ;
if ( pd - > text . text_class )
fprintf ( f , I6 " text_class: \" %s \" ; \n " , pd - > text . text_class ) ;
2008-10-07 09:01:56 -07:00
if ( pd - > text . fit_x | | pd - > text . fit_y )
fprintf ( f , I6 " fit: %d %d; \n " , pd - > text . fit_x , pd - > text . fit_y ) ;
2008-10-07 07:11:11 -07:00
//TODO Support min & max
2008-10-07 09:01:56 -07:00
if ( pd - > text . align . x ! = 0.5 | | pd - > text . align . y ! = 0.5 )
2008-10-07 07:11:11 -07:00
fprintf ( f , I6 " align: %g %g; \n " , pd - > text . align . x , pd - > text . align . y ) ;
//TODO Support source
//TODO Support text_source
2008-10-07 09:01:56 -07:00
if ( pd - > text . elipsis )
fprintf ( f , I6 " elipsis: %g; \n " , pd - > text . elipsis ) ;
2008-10-07 07:11:11 -07:00
fprintf ( f , I5 " } \n " ) ;
}
//Gradient
if ( rp - > part - > type = = EDJE_PART_TYPE_GRADIENT )
{
fprintf ( f , I5 " gradient { \n " ) ;
fprintf ( f , I6 " type: \" %s \" ; \n " , pd - > gradient . type ) ;
str = edje_edit_state_gradient_spectra_get ( obj , part , state ) ;
if ( str )
{
fprintf ( f , I6 " spectrum: \" %s \" ; \n " , str ) ;
edje_edit_string_free ( str ) ;
}
//TODO rel1 and 2 seems unused
fprintf ( f , I5 " } \n " ) ;
}
2008-10-02 17:20:19 -07:00
fprintf ( f , I4 " } \n " ) ; //description
}
2008-06-19 05:39:58 -07:00
static void
2008-06-13 18:13:16 -07:00
_edje_generate_source_of_part ( Evas_Object * obj , const char * part , FILE * f )
{
2008-10-02 17:20:19 -07:00
const char * str ;
2008-10-22 04:34:42 -07:00
Eina_List * l , * ll ;
char * data ;
2008-11-02 06:10:11 -08:00
fprintf ( f , I3 " part { name: \" %s \" ; \n " , part ) ;
2008-06-13 18:13:16 -07:00
fprintf ( f , I4 " type: %s; \n " , types [ edje_edit_part_type_get ( obj , part ) ] ) ;
if ( ! edje_edit_part_mouse_events_get ( obj , part ) )
fprintf ( f , I4 " mouse_events: 0; \n " ) ;
if ( edje_edit_part_repeat_events_get ( obj , part ) )
fprintf ( f , I4 " repeat_events: 1; \n " ) ;
2008-10-02 17:20:19 -07:00
//TODO Support ignore_flags
//TODO Support scale
//TODO Support pointer_mode
//TODO Support precise_is_inside
//TODO Support use_alternate_font_metrics
if ( ( str = edje_edit_part_clip_to_get ( obj , part ) ) )
{
fprintf ( f , I4 " clip_to: \" %s \" ; \n " , str ) ;
edje_edit_string_free ( str ) ;
}
if ( ( str = edje_edit_part_source_get ( obj , part ) ) )
{
fprintf ( f , I4 " source: \" %s \" ; \n " , str ) ;
edje_edit_string_free ( str ) ;
}
if ( edje_edit_part_effect_get ( obj , part ) )
fprintf ( f , I4 " effect: %s; \n " , effects [ edje_edit_part_effect_get ( obj , part ) ] ) ;
2008-10-09 07:38:22 -07:00
//Dragable
if ( edje_edit_part_drag_x_get ( obj , part ) | |
edje_edit_part_drag_x_get ( obj , part ) )
{
fprintf ( f , I4 " dragable { \n " ) ;
fprintf ( f , I5 " x: %d %d %d; \n " , edje_edit_part_drag_x_get ( obj , part ) ,
edje_edit_part_drag_step_x_get ( obj , part ) ,
edje_edit_part_drag_count_x_get ( obj , part ) ) ;
fprintf ( f , I5 " y: %d %d %d; \n " , edje_edit_part_drag_y_get ( obj , part ) ,
edje_edit_part_drag_step_y_get ( obj , part ) ,
edje_edit_part_drag_count_y_get ( obj , part ) ) ;
2008-10-26 21:10:31 -07:00
if ( ( str = edje_edit_part_drag_confine_get ( obj , part ) ) )
2008-10-09 07:38:22 -07:00
{
fprintf ( f , I5 " confine: \" %s \" ; \n " , str ) ;
edje_edit_string_free ( str ) ;
}
2008-10-26 21:10:31 -07:00
if ( ( str = edje_edit_part_drag_event_get ( obj , part ) ) )
2008-10-09 07:38:22 -07:00
{
fprintf ( f , I5 " events: \" %s \" ; \n " , str ) ;
edje_edit_string_free ( str ) ;
}
fprintf ( f , I4 " } \n " ) ;
}
2008-10-02 17:20:19 -07:00
//Descriptions
ll = edje_edit_part_states_list_get ( obj , part ) ;
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ll , l , data )
_edje_generate_source_of_state ( obj , part , data , f ) ;
2008-10-02 17:20:19 -07:00
edje_edit_string_list_free ( ll ) ;
2008-06-13 18:13:16 -07:00
fprintf ( f , I3 " } \n " ) ; //part
}
2008-06-19 05:39:58 -07:00
static void
2008-06-13 18:13:16 -07:00
_edje_generate_source_of_group ( Edje * ed , const char * group , FILE * f )
{
Evas_Object * obj ;
2008-10-22 04:34:42 -07:00
Eina_List * l , * ll ;
2008-06-13 18:13:16 -07:00
int w , h ;
2008-10-22 04:34:42 -07:00
char * data ;
2008-06-13 18:13:16 -07:00
obj = edje_object_add ( ed - > evas ) ;
2008-06-19 05:39:58 -07:00
if ( ! edje_object_file_set ( obj , ed - > file - > path , group ) ) return ;
2008-06-13 18:13:16 -07:00
2008-11-02 06:10:11 -08:00
fprintf ( f , I1 " group { name: \" %s \" ; \n " , group ) ;
2008-06-13 18:13:16 -07:00
//TODO Support alias:
2008-12-05 19:08:17 -08:00
w = edje_edit_group_min_w_get ( obj ) ;
h = edje_edit_group_min_h_get ( obj ) ;
if ( ( w > 0 ) | | ( h > 0 ) )
2008-06-13 18:13:16 -07:00
fprintf ( f , I2 " min: %d %d; \n " , w , h ) ;
2008-12-05 19:08:17 -08:00
w = edje_edit_group_max_w_get ( obj ) ;
h = edje_edit_group_max_h_get ( obj ) ;
if ( ( w > - 1 ) | | ( h > - 1 ) )
2008-06-13 18:13:16 -07:00
fprintf ( f , I2 " max: %d %d; \n " , w , h ) ;
//TODO Support data
//TODO Support script
2008-09-23 10:47:31 -07:00
/* Parts */
2008-06-13 18:13:16 -07:00
fprintf ( f , I2 " parts { \n " ) ;
ll = edje_edit_parts_list_get ( obj ) ;
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ll , l , data )
_edje_generate_source_of_part ( obj , data , f ) ;
2008-06-13 18:13:16 -07:00
edje_edit_string_list_free ( ll ) ;
fprintf ( f , I2 " } \n " ) ; //parts
2008-09-23 10:47:31 -07:00
/* Programs */
2008-10-26 21:10:31 -07:00
if ( ( ll = edje_edit_programs_list_get ( obj ) ) )
2008-09-23 10:47:31 -07:00
{
fprintf ( f , I2 " programs { \n " ) ;
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ll , l , data )
_edje_generate_source_of_program ( obj , data , f ) ;
2008-09-23 10:47:31 -07:00
fprintf ( f , I2 " } \n " ) ;
edje_edit_string_list_free ( ll ) ;
}
2008-06-13 18:13:16 -07:00
fprintf ( f , " } \n " ) ; //group
//TODO Free the Evas_Object *obj
}
2008-10-08 17:04:18 -07:00
static const char * //return the name of the temp file containing the edc
2008-06-13 18:13:16 -07:00
_edje_generate_source ( Evas_Object * obj )
2008-03-06 11:48:11 -08:00
{
2008-06-13 18:13:16 -07:00
printf ( " \n ****** GENERATE EDC SOURCE ********* \n " ) ;
2008-06-06 11:31:49 -07:00
char tmpn [ PATH_MAX ] ;
2008-03-06 11:48:11 -08:00
int fd ;
FILE * f ;
2008-10-08 17:04:18 -07:00
2008-10-22 04:34:42 -07:00
Eina_List * l , * ll ;
char * entry ;
2008-03-06 11:48:11 -08:00
2008-10-26 21:10:31 -07:00
GET_ED_OR_RETURN ( NULL ) ;
2008-06-13 18:13:16 -07:00
2008-03-06 11:48:11 -08:00
/* Open a temp file */
2009-10-08 14:45:55 -07:00
# ifdef HAVE_EVIL
snprintf ( tmpn , PATH_MAX , " %s/edje_edit.edc-tmp-XXXXXX " , evil_tmpdir_get ( ) ) ;
# else
2008-03-06 11:48:11 -08:00
strcpy ( tmpn , " /tmp/edje_edit.edc-tmp-XXXXXX " ) ;
2009-10-08 14:45:55 -07:00
# endif
2008-10-08 17:04:18 -07:00
if ( ! ( fd = mkstemp ( tmpn ) ) ) return NULL ;
2008-03-06 11:48:11 -08:00
printf ( " *** tmp file: %s \n " , tmpn ) ;
2009-10-07 04:50:58 -07:00
if ( ! ( f = fdopen ( fd , " wb " ) ) ) return NULL ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
/* Write edc into file */
2008-06-13 18:13:16 -07:00
//TODO Probably we need to save the file before generation
/* Images */
2008-10-26 21:10:31 -07:00
if ( ( ll = edje_edit_images_list_get ( obj ) ) )
2008-06-13 18:13:16 -07:00
{
2008-07-30 15:41:04 -07:00
fprintf ( f , I0 " images { \n " ) ;
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ll , l , entry )
2008-07-30 15:41:04 -07:00
{
int comp = edje_edit_image_compression_type_get ( obj , entry ) ;
if ( comp < 0 ) continue ;
fprintf ( f , I1 " image: \" %s \" " , entry ) ;
if ( comp = = EDJE_EDIT_IMAGE_COMP_LOSSY )
fprintf ( f , " LOSSY %d; \n " ,
edje_edit_image_compression_rate_get ( obj , entry ) ) ;
else if ( comp = = EDJE_EDIT_IMAGE_COMP_RAW )
fprintf ( f , " RAW; \n " ) ;
else if ( comp = = EDJE_EDIT_IMAGE_COMP_USER )
fprintf ( f , " USER; \n " ) ;
else fprintf ( f , " COMP; \n " ) ;
}
fprintf ( f , I0 " } \n \n " ) ;
2008-09-23 10:47:31 -07:00
edje_edit_string_list_free ( ll ) ;
2008-06-13 18:13:16 -07:00
}
2008-07-30 15:41:04 -07:00
2008-06-13 18:13:16 -07:00
/* Fonts */
2008-10-26 21:10:31 -07:00
if ( ( ll = edje_edit_fonts_list_get ( obj ) ) )
2008-07-30 15:41:04 -07:00
{
fprintf ( f , I0 " fonts { \n " ) ;
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ll , l , entry )
2008-07-30 15:41:04 -07:00
{
2008-10-07 14:13:27 -07:00
// TODO Fixme the filename is wrong
fprintf ( f , I1 " font: \" %s.ttf \" \" %s \" ; \n " , entry , entry ) ;
2008-07-30 15:41:04 -07:00
}
fprintf ( f , I0 " } \n \n " ) ;
2008-09-23 10:47:31 -07:00
edje_edit_string_list_free ( ll ) ;
2008-07-30 15:41:04 -07:00
}
2008-06-13 18:13:16 -07:00
/* Data */
2008-10-26 21:10:31 -07:00
if ( ( ll = edje_edit_data_list_get ( obj ) ) )
2008-09-23 10:47:31 -07:00
{
fprintf ( f , I0 " data { \n " ) ;
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ll , l , entry )
2008-09-23 10:47:31 -07:00
{
2008-10-22 04:34:42 -07:00
fprintf ( f , I1 " item: \" %s \" \" %s \" ; \n " , entry ,
edje_edit_data_value_get ( obj , entry ) ) ;
2008-09-23 10:47:31 -07:00
}
fprintf ( f , I0 " } \n \n " ) ;
edje_edit_string_list_free ( ll ) ;
}
2008-06-13 18:13:16 -07:00
/* Color Classes */
2008-10-26 21:10:31 -07:00
if ( ( ll = edje_edit_color_classes_list_get ( obj ) ) )
2008-09-28 15:45:47 -07:00
{
fprintf ( f , I0 " color_classes { \n " ) ;
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ll , l , entry )
_edje_generate_source_of_colorclass ( ed , entry , f ) ;
2008-09-28 15:45:47 -07:00
fprintf ( f , I0 " } \n \n " ) ;
edje_edit_string_list_free ( ll ) ;
}
2008-06-13 18:13:16 -07:00
2008-09-23 10:47:31 -07:00
/* Spectrum */
2008-10-26 21:10:31 -07:00
if ( ( ll = edje_edit_spectrum_list_get ( obj ) ) )
2008-09-23 10:47:31 -07:00
{
fprintf ( f , I0 " spectra { \n " ) ;
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ll , l , entry )
_edje_generate_source_of_spectra ( ed , entry , f ) ;
2008-09-23 10:47:31 -07:00
fprintf ( f , I0 " } \n \n " ) ;
edje_edit_string_list_free ( ll ) ;
}
2008-10-07 14:13:27 -07:00
2008-06-13 18:13:16 -07:00
/* Styles */
2008-11-02 06:10:11 -08:00
if ( ( ll = edje_edit_styles_list_get ( obj ) ) )
{
fprintf ( f , I0 " styles { \n " ) ;
EINA_LIST_FOREACH ( ll , l , entry )
_edje_generate_source_of_style ( ed , entry , f ) ;
fprintf ( f , I0 " } \n \n " ) ;
edje_edit_string_list_free ( ll ) ;
}
2008-10-07 14:13:27 -07:00
2008-06-13 18:13:16 -07:00
/* Collections */
fprintf ( f , " collections { \n " ) ;
ll = edje_file_collection_list ( ed - > file - > path ) ;
2008-10-22 04:34:42 -07:00
EINA_LIST_FOREACH ( ll , l , entry )
_edje_generate_source_of_group ( ed , entry , f ) ;
2008-06-13 18:13:16 -07:00
fprintf ( f , " } \n \n " ) ;
edje_file_collection_list_free ( ll ) ;
2008-10-07 14:13:27 -07:00
2008-03-06 11:48:11 -08:00
fclose ( f ) ;
2008-03-13 12:01:53 -07:00
2008-10-15 07:11:11 -07:00
return eina_stringshare_add ( tmpn ) ;
2008-10-08 17:04:18 -07:00
}
2008-03-13 12:01:53 -07:00
2008-10-08 17:04:18 -07:00
/*********************/
/* SAVING ROUTINES */
/*********************/
////////////////////////////////////////
2009-08-17 07:49:26 -07:00
typedef struct _SrcFile SrcFile ;
typedef struct _SrcFile_List SrcFile_List ;
struct _SrcFile
{
char * name ;
char * file ;
} ;
struct _SrcFile_List
{
Eina_List * list ;
} ;
2008-10-08 17:04:18 -07:00
static Eet_Data_Descriptor * _srcfile_edd = NULL ;
static Eet_Data_Descriptor * _srcfile_list_edd = NULL ;
2008-03-13 12:01:53 -07:00
2009-09-01 03:02:40 -07:00
static void
2008-10-08 17:04:18 -07:00
source_edd ( void )
{
Eet_Data_Descriptor_Class eddc ;
2008-03-06 11:48:11 -08:00
2009-08-13 06:26:43 -07:00
eet_eina_stream_data_descriptor_class_set ( & eddc , " srcfile " , sizeof ( SrcFile ) ) ;
2009-08-13 05:53:12 -07:00
_srcfile_edd = eet_data_descriptor_stream_new ( & eddc ) ;
2008-10-08 17:04:18 -07:00
EET_DATA_DESCRIPTOR_ADD_BASIC ( _srcfile_edd , SrcFile , " name " , name , EET_T_INLINED_STRING ) ;
EET_DATA_DESCRIPTOR_ADD_BASIC ( _srcfile_edd , SrcFile , " file " , file , EET_T_INLINED_STRING ) ;
2009-08-13 06:26:43 -07:00
eet_eina_stream_data_descriptor_class_set ( & eddc , " srcfile_list " , sizeof ( SrcFile_List ) ) ;
2009-08-13 05:53:12 -07:00
_srcfile_list_edd = eet_data_descriptor_stream_new ( & eddc ) ;
2008-10-08 17:04:18 -07:00
EET_DATA_DESCRIPTOR_ADD_LIST ( _srcfile_list_edd , SrcFile_List , " list " , list , _srcfile_edd ) ;
}
/////////////////////////////////////////
2008-03-06 11:48:11 -08:00
EAPI int
edje_edit_save ( Evas_Object * obj )
{
2008-05-30 01:00:25 -07:00
char buf [ 256 ] ;
2008-03-06 11:48:11 -08:00
Edje_File * ef ;
Eet_File * eetf ;
int bytes ;
2008-03-13 12:01:53 -07:00
GET_ED_OR_RETURN ( 0 ) ;
2008-03-06 11:48:11 -08:00
ef = ed - > file ;
if ( ! ef ) return 0 ;
printf ( " *********** Saving file ****************** \n " ) ;
printf ( " ** path: %s \n " , ef - > path ) ;
2008-10-08 17:04:18 -07:00
/* Set compiler name */
if ( strcmp ( ef - > compiler , " edje_edit " ) )
{
_edje_if_string_free ( ed , ef - > compiler ) ;
ef - > compiler = strdup ( " edje_edit " ) ;
}
2008-03-13 12:01:53 -07:00
2008-10-08 17:04:18 -07:00
/* Open the eet file */
2008-03-06 11:48:11 -08:00
eetf = eet_open ( ef - > path , EET_FILE_MODE_READ_WRITE ) ;
if ( ! eetf )
2008-03-13 12:01:53 -07:00
{
2008-10-08 17:04:18 -07:00
fprintf ( stderr , " Error. unable to open \" %s \" for writing output \n " ,
ef - > path ) ;
2008-03-13 12:01:53 -07:00
return 0 ;
}
2008-10-08 17:04:18 -07:00
/* Write Edje_File structure */
2008-03-06 11:48:11 -08:00
printf ( " ** Writing Edje_File* ed->file \n " ) ;
bytes = eet_data_write ( eetf , _edje_edd_edje_file , " edje_file " , ef , 1 ) ;
if ( bytes < = 0 )
2008-03-13 12:01:53 -07:00
{
2008-10-08 17:04:18 -07:00
fprintf ( stderr , " Error. unable to write \" edje_file \" "
" entry to \" %s \" \n " , ef - > path ) ;
eet_close ( eetf ) ;
return 0 ;
2008-03-13 12:01:53 -07:00
}
2008-03-06 11:48:11 -08:00
2008-10-08 17:04:18 -07:00
/* Write all the collections */
2008-03-06 11:48:11 -08:00
if ( ed - > collection )
2008-03-13 12:01:53 -07:00
{
printf ( " ** Writing Edje_Part_Collection* ed->collection "
" [id: %d] \n " , ed - > collection - > id ) ;
snprintf ( buf , sizeof ( buf ) , " collections/%i " , ed - > collection - > id ) ;
bytes = eet_data_write ( eetf , _edje_edd_edje_part_collection ,
buf , ed - > collection , 1 ) ;
if ( bytes < = 0 )
{
2008-10-08 17:04:18 -07:00
fprintf ( stderr , " Error. unable to write \" %s \" part entry to %s \n " ,
buf , ef - > path ) ;
eet_close ( eetf ) ;
return 0 ;
2008-03-13 12:01:53 -07:00
}
}
2008-10-08 17:04:18 -07:00
/* Write the new edc source */
SrcFile * sf ;
SrcFile_List * sfl ;
const char * source_file ;
FILE * f ;
long sz ;
source_file = _edje_generate_source ( obj ) ;
if ( ! source_file )
{
fprintf ( stderr , " Error: can't create edc source \n " ) ;
eet_close ( eetf ) ;
return 0 ;
}
printf ( " ** Writing EDC Source [from: %s] \n " , source_file ) ;
//open the temp file and put the contents in SrcFile
2009-08-17 07:13:26 -07:00
sf = _alloc ( sizeof ( SrcFile ) ) ;
2009-08-17 06:54:17 -07:00
if ( ! sf ) return 0 ;
2009-08-17 14:28:40 -07:00
sf - > name = strdup ( " generated_source.edc " ) ;
2008-10-08 17:04:18 -07:00
f = fopen ( source_file , " rb " ) ;
if ( ! f )
{
fprintf ( stderr , " Error. unable to read the created edc source [%s] \n " ,
source_file ) ;
eet_close ( eetf ) ;
return 0 ;
}
fseek ( f , 0 , SEEK_END ) ;
sz = ftell ( f ) ;
fseek ( f , 0 , SEEK_SET ) ;
2009-08-17 06:54:17 -07:00
sf - > file = _alloc ( sz + 1 ) ; //TODO check result and return nicely
2008-10-08 17:04:18 -07:00
fread ( sf - > file , sz , 1 , f ) ;
sf - > file [ sz ] = ' \0 ' ;
fseek ( f , 0 , SEEK_SET ) ;
fclose ( f ) ;
//create the needed list of source files (only one)
2009-08-17 07:13:26 -07:00
sfl = _alloc ( sizeof ( SrcFile_List ) ) ; //TODO check result and return nicely
2008-10-08 17:04:18 -07:00
sfl - > list = NULL ;
2008-10-22 04:34:42 -07:00
sfl - > list = eina_list_append ( sfl - > list , sf ) ;
2008-10-08 17:04:18 -07:00
// write the sources list to the eet file
source_edd ( ) ;
bytes = eet_data_write ( eetf , _srcfile_list_edd , " edje_sources " , sfl , 1 ) ;
if ( bytes < = 0 )
{
fprintf ( stderr , " Error. unable to write edc source \n " ) ;
eet_close ( eetf ) ;
return 0 ;
}
/* Clear stuff */
unlink ( source_file ) ;
2008-10-15 07:11:11 -07:00
eina_stringshare_del ( source_file ) ;
2008-03-06 11:48:11 -08:00
eet_close ( eetf ) ;
printf ( " *********** Saving DONE ****************** \n " ) ;
return 1 ;
}
EAPI void
edje_edit_print_internal_status ( Evas_Object * obj )
{
2008-10-22 04:34:42 -07:00
Eina_List * l ;
Edje_Part * p ;
Edje_Program * epr ;
2008-05-30 01:00:25 -07:00
2008-03-13 12:01:53 -07:00
GET_ED_OR_RETURN ( ) ;
2008-06-13 18:13:16 -07:00
_edje_generate_source ( obj ) ;
return ;
2008-03-06 11:48:11 -08:00
printf ( " \n ****** CHECKIN' INTERNAL STRUCTS STATUS ********* \n " ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
printf ( " *** Edje \n " ) ;
printf ( " path: '%s' \n " , ed - > path ) ;
2008-08-14 11:04:43 -07:00
printf ( " group: '%s' \n " , ed - > group ) ;
2008-03-06 11:48:11 -08:00
printf ( " parent: '%s' \n " , ed - > parent ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
printf ( " \n *** Parts [table:%d list:%d] \n " , ed - > table_parts_size ,
2008-10-22 04:34:42 -07:00
eina_list_count ( ed - > collection - > parts ) ) ;
EINA_LIST_FOREACH ( ed - > collection - > parts , l , p )
2008-03-13 12:01:53 -07:00
{
Edje_Real_Part * rp ;
rp = ed - > table_parts [ p - > id % ed - > table_parts_size ] ;
2008-03-13 12:08:14 -07:00
printf ( " [%d]%s " , p - > id , p - > name ) ;
2008-03-13 12:01:53 -07:00
if ( p = = rp - > part )
printf ( " OK! \n " ) ;
else
printf ( " WRONG (table[%id]->name = '%s') \n " , p - > id , rp - > part - > name ) ;
}
2008-03-06 11:48:11 -08:00
printf ( " \n *** Programs [table:%d list:%d] \n " , ed - > table_programs_size ,
2008-10-22 04:34:42 -07:00
eina_list_count ( ed - > collection - > programs ) ) ;
EINA_LIST_FOREACH ( ed - > collection - > programs , l , epr )
2008-03-13 12:01:53 -07:00
{
Edje_Program * epr2 ;
epr2 = ed - > table_programs [ epr - > id % ed - > table_programs_size ] ;
printf ( " [%d]%s " , epr - > id , epr - > name ) ;
if ( epr = = epr2 )
printf ( " OK! \n " ) ;
else
printf ( " WRONG (table[%id]->name = '%s') \n " , epr - > id , epr2 - > name ) ;
}
2008-03-06 11:48:11 -08:00
printf ( " \n " ) ;
2008-03-13 12:01:53 -07:00
2008-03-06 11:48:11 -08:00
printf ( " ****************** END ************************ \n \n " ) ;
}