2010-04-06 04:26:32 -07:00
# include "edje_private.h"
2011-11-11 18:23:33 -08:00
# include <ctype.h>
2010-04-06 04:26:32 -07:00
2011-11-18 01:52:58 -08:00
# define RASTER_FORGOT_WHY "this is here."
2011-05-18 09:11:31 -07:00
# ifdef _WIN32
# define FMT_SIZE_T "%Iu"
# else
# define FMT_SIZE_T "%zu"
# endif
2011-11-13 16:13:36 -08:00
//--------------------------------------------------------------------------//
# define MAX_LUA_MEM (4 * (1024 * 1024))
# define ELO "|-ELO"
# define LC(...) EINA_LOG_DOM_CRIT(_log_domain, __VA_ARGS__)
# define LE(...) EINA_LOG_DOM_ERR(_log_domain, __VA_ARGS__)
# define LW(...) EINA_LOG_DOM_WARN(_log_domain, __VA_ARGS__)
# define LI(...) EINA_LOG_DOM_INFO(_log_domain, __VA_ARGS__)
# define LD(...) EINA_LOG_DOM_DBG(_log_domain, __VA_ARGS__)
2011-11-12 06:33:08 -08:00
/**
@ page luaref Edje Lua scripting
@ section intro Introduction
Lua is intended for script - only objects at this point ( with embryo left
for augmenting standard programs ) . Since script - only objects effectively
define objects entirely via Lua script ( resize handling , event handling
etc . etc . ) this places many more demands on them , and thus a more powerful
language is in order . Lua is that language .
2011-11-17 10:13:58 -08:00
To get you started , here ' s an example that uses most of this lua API :
2011-11-12 06:33:08 -08:00
@ ref lua_script . edc
2011-11-17 09:42:29 -08:00
Most of these lua functions are wrappers around various evas , ecore , and edje C
functions . Refer to their documentation for more in depth details and up to
date documentation . A lot of this documentation is simple copied from the C
functions it wraps .
2011-11-12 11:39:01 -08:00
@ section args Lua function argument and return syntax
2011-11-12 06:33:08 -08:00
Some of the lua functions can accept a table as well as separate arguments .
2011-11-12 11:39:01 -08:00
Some of them return tables .
@ section classes Lua classes
2011-11-17 06:21:53 -08:00
*/
/*
Lua functions stack usage .
In the definition of the lua functions provided , always mention the stack usage ,
using the same notation that is used in the Lua 5.1 Reference Manual .
http : //www.lua.org/manual/5.1/manual.html#3.7 describes that notation.
2011-11-17 09:42:29 -08:00
On the other hand , lua discards excess stack entries when control passes back to
it , but it ' s good to maintain proper discipline .
Should do the same for the support functions . These ARE more important to check .
2011-11-17 06:21:53 -08:00
*/
2011-11-12 06:33:08 -08:00
2010-04-06 04:26:32 -07:00
//--------------------------------------------------------------------------//
2010-07-12 23:17:15 -07:00
typedef struct _Edje_Lua_Alloc Edje_Lua_Alloc ;
typedef struct _Edje_Lua_Obj Edje_Lua_Obj ;
typedef struct _Edje_Lua_Animator Edje_Lua_Animator ;
2011-11-12 02:42:56 -08:00
typedef struct _Edje_Lua_Timer Edje_Lua_Timer ;
2010-07-12 23:17:15 -07:00
typedef struct _Edje_Lua_Transition Edje_Lua_Transition ;
typedef struct _Edje_Lua_Evas_Object Edje_Lua_Evas_Object ;
2011-11-06 06:59:44 -08:00
typedef struct _Edje_Lua_Map Edje_Lua_Map ;
2010-04-06 04:26:32 -07:00
struct _Edje_Lua_Alloc
{
size_t max , cur ;
} ;
struct _Edje_Lua_Obj
{
EINA_INLIST ;
2011-11-06 01:00:21 -08:00
2010-04-06 04:26:32 -07:00
Edje * ed ;
void ( * free_func ) ( void * obj ) ;
2011-11-11 08:23:06 -08:00
const char * meta ;
2010-04-06 04:26:32 -07:00
} ;
2011-11-06 01:00:21 -08:00
2011-11-12 02:42:56 -08:00
struct _Edje_Lua_Animator
2010-04-06 04:26:32 -07:00
{
Edje_Lua_Obj obj ;
2011-11-12 02:42:56 -08:00
Ecore_Animator * animator ;
2010-04-06 04:26:32 -07:00
int fn_ref ;
} ;
2011-11-12 02:42:56 -08:00
struct _Edje_Lua_Timer
2010-04-06 04:26:32 -07:00
{
Edje_Lua_Obj obj ;
2011-11-12 02:42:56 -08:00
Ecore_Timer * timer ;
2010-04-06 04:26:32 -07:00
int fn_ref ;
} ;
2010-07-06 17:58:34 -07:00
struct _Edje_Lua_Transition
{
Edje_Lua_Obj obj ;
Ecore_Animator * animator ;
double transition , start ;
int fn_ref ;
} ;
2010-07-12 23:17:15 -07:00
struct _Edje_Lua_Evas_Object
{
Edje_Lua_Obj obj ;
Evas_Object * evas_obj ;
2011-11-05 21:44:13 -07:00
int x , y ;
2010-07-12 23:17:15 -07:00
} ;
2011-11-06 06:59:44 -08:00
struct _Edje_Lua_Map
{
Edje_Lua_Obj obj ;
Evas_Map * map ;
} ;
2010-04-06 04:26:32 -07:00
2011-11-12 11:39:01 -08:00
static void _elua_add_functions ( lua_State * L , const char * api , const luaL_Reg * funcs , const char * meta , const char * parent , const char * base ) ;
static Eina_Bool _elua_isa ( Edje_Lua_Obj * obj , const char * type ) ;
2010-07-13 22:32:48 -07:00
2010-04-06 04:26:32 -07:00
//--------------------------------------------------------------------------//
2011-11-18 01:52:58 -08:00
# ifndef RASTER_FORGOT_WHY
2010-04-06 04:26:32 -07:00
static lua_State * lstate = NULL ;
2011-11-18 01:52:58 -08:00
# endif
2011-11-12 02:42:56 -08:00
static const char * _elua_key = " key " ;
static const char * _elua_objs = " objs " ;
2010-07-06 20:24:05 -07:00
static jmp_buf panic_jmp ;
2011-11-13 16:13:36 -08:00
static int _log_domain = - 1 ;
static int _log_count = 0 ;
2010-04-06 04:26:32 -07:00
2011-11-06 01:00:21 -08:00
// FIXME: methods lua script can provide that edje will call (not done yet):
2010-07-13 22:32:48 -07:00
// // scale set
// // key down
// // key up
// // get dragable pos
// // set dragable pos
2010-07-25 23:52:36 -07:00
// // set drag size, step, page
// // get drag size, step, page
// // dragable step
// // dragable page
2010-07-13 22:32:48 -07:00
// // get part text
// // set part text
// // get swallow part
// // set swallow part
2010-07-25 23:52:36 -07:00
// // unswallow part
2010-07-13 22:32:48 -07:00
// // textclass change
// // colorclass change
2010-07-25 23:52:36 -07:00
// // min size get <- ?? maybe set fn
// // max size get <- ?? maybe set fn
// // min size caclc (min/max restriction)
// // preload
// // preload cancel
// // play set
// // animation set
// // parts extends calc
// // part object get
// // part geometry get
2011-11-06 01:00:21 -08:00
//
2010-07-25 23:52:36 -07:00
// // LATER: all the entry calls
// // LATER: box and table calls
// // LATER: perspective stuff change
2011-11-06 01:00:21 -08:00
//
2011-11-11 13:32:15 -08:00
2011-11-12 11:39:01 -08:00
// Grumble, pre-declare these.
2011-11-11 13:32:15 -08:00
static const char * _elua_edje_meta = " edje_meta " ;
static const char * _elua_evas_meta = " evas_meta " ;
static const char * _elua_evas_edje_meta = " evas_edje_meta " ;
static const char * _elua_evas_image_meta = " evas_image_meta " ;
2011-11-17 17:50:47 -08:00
static const char * _elua_evas_line_meta = " evas_line_meta " ;
2011-11-11 13:32:15 -08:00
static const char * _elua_evas_map_meta = " evas_map_meta " ;
static const char * _elua_evas_polygon_meta = " evas_polygon_meta " ;
static const char * _elua_evas_text_meta = " evas_text_meta " ;
2011-11-17 18:27:16 -08:00
static const char * _elua_ecore_animator_meta = " ecore_animator_meta " ;
static const char * _elua_ecore_timer_meta = " ecore_timer_meta " ;
2011-11-12 11:39:01 -08:00
static int _elua_obj_gc ( lua_State * L ) ;
2011-11-11 13:32:15 -08:00
static const struct luaL_reg _elua_edje_gc_funcs [ ] =
2010-04-06 04:26:32 -07:00
{
{ " __gc " , _elua_obj_gc } , // garbage collector func for edje objects
2011-11-06 01:00:21 -08:00
2010-04-06 04:26:32 -07:00
{ NULL , NULL } // end
} ;
2010-07-13 22:32:48 -07:00
2010-04-06 04:26:32 -07:00
static const luaL_Reg _elua_libs [ ] =
{
{ " " , luaopen_base } ,
// {LUA_LOADLIBNAME, luaopen_package}, // disable this lib - don't want
{ LUA_TABLIBNAME , luaopen_table } ,
// {LUA_IOLIBNAME, luaopen_io}, // disable this lib - don't want
2010-11-02 06:43:54 -07:00
// {LUA_OSLIBNAME, luaopen_os}, // FIXME: audit os lib - maybe not provide or only provide specific calls
2010-04-06 04:26:32 -07:00
{ LUA_STRLIBNAME , luaopen_string } ,
{ LUA_MATHLIBNAME , luaopen_math } ,
// {LUA_DBLIBNAME, luaopen_debug}, // disable this lib - don't want
{ NULL , NULL } // end
} ;
//--------------------------------------------------------------------------//
static void *
_elua_alloc ( void * ud , void * ptr , size_t osize , size_t nsize )
{
Edje_Lua_Alloc * ela = ud ;
void * ptr2 ;
2011-11-06 01:00:21 -08:00
2010-04-06 04:26:32 -07:00
ela - > cur + = nsize - osize ;
if ( ela - > cur > ela - > max )
{
2011-11-13 16:13:36 -08:00
ERR ( " Lua memory limit of " FMT_SIZE_T " bytes reached ( " FMT_SIZE_T " allocated) " ,
2010-04-06 04:26:32 -07:00
ela - > max , ela - > cur ) ;
return NULL ;
}
if ( nsize = = 0 )
{
free ( ptr ) ;
return NULL ;
}
2011-11-06 01:00:21 -08:00
2010-04-06 04:26:32 -07:00
ptr2 = realloc ( ptr , nsize ) ;
if ( ptr2 ) return ptr2 ;
2011-11-13 16:13:36 -08:00
ERR ( " Lua cannot re-allocate " FMT_SIZE_T " bytes " , nsize ) ;
2010-04-06 04:26:32 -07:00
return ptr2 ;
}
static int
2010-08-19 07:57:23 -07:00
_elua_custom_panic ( lua_State * L __UNUSED__ )
2010-04-06 04:26:32 -07:00
{
ERR ( " Lua Panic!!!! " ) ;
return 1 ;
}
2011-11-12 02:42:56 -08:00
// Really only used to manage the pointer to our edje.
static void
2011-11-17 09:42:29 -08:00
_elua_table_ptr_set ( lua_State * L , const void * key , const void * val ) // Stack usage [-?, +?, ?]
2010-04-06 04:26:32 -07:00
{
2011-11-12 02:42:56 -08:00
lua_pushlightuserdata ( L , ( void * ) key ) ;
lua_pushlightuserdata ( L , ( void * ) val ) ;
lua_settable ( L , LUA_REGISTRYINDEX ) ;
}
2011-11-06 01:00:21 -08:00
2011-11-12 02:42:56 -08:00
static const void *
2011-11-17 09:42:29 -08:00
_elua_table_ptr_get ( lua_State * L , const void * key ) // Stack usage [-?, +?, ?]
2011-11-12 02:42:56 -08:00
{
const void * ptr ;
lua_pushlightuserdata ( L , ( void * ) key ) ;
lua_gettable ( L , LUA_REGISTRYINDEX ) ;
ptr = lua_topointer ( L , - 1 ) ;
lua_pop ( L , 1 ) ;
return ptr ;
2010-04-06 04:26:32 -07:00
}
2011-11-12 02:42:56 -08:00
/* XXX: not used
2010-04-06 04:26:32 -07:00
static void
2011-11-17 09:42:29 -08:00
_elua_table_ptr_del ( lua_State * L , const void * key ) // Stack usage [-?, +?, ?]
2010-04-06 04:26:32 -07:00
{
2011-11-12 02:42:56 -08:00
lua_pushlightuserdata ( L , ( void * ) key ) ;
lua_pushnil ( L ) ;
lua_settable ( L , LUA_REGISTRYINDEX ) ;
}
*/
2010-04-06 04:26:32 -07:00
2011-11-12 06:33:08 -08:00
/*
2010-07-13 22:32:48 -07:00
* Cori : Assumes object to be saved on top of stack
*/
static void
2011-11-17 09:42:29 -08:00
_elua_ref_set ( lua_State * L , void * key ) // Stack usage [-?, +?, ?]
2010-07-13 22:32:48 -07:00
{
lua_pushlightuserdata ( L , & _elua_objs ) ;
lua_rawget ( L , LUA_REGISTRYINDEX ) ;
lua_pushlightuserdata ( L , key ) ;
lua_pushvalue ( L , - 3 ) ; // key & obj table & obj
lua_rawset ( L , - 3 ) ;
lua_pop ( L , 1 ) ; // pop obj table
}
2011-11-06 01:00:21 -08:00
2011-11-12 06:33:08 -08:00
/*
2010-07-13 22:32:48 -07:00
* Cori : Get an object from the object table
*/
static void *
2011-11-17 09:42:29 -08:00
_elua_ref_get ( lua_State * L , void * key ) // Stack usage [-?, +?, ?]
2010-07-13 22:32:48 -07:00
{
lua_pushlightuserdata ( L , & _elua_objs ) ;
lua_rawget ( L , LUA_REGISTRYINDEX ) ;
lua_pushlightuserdata ( L , key ) ;
lua_rawget ( L , - 2 ) ;
lua_remove ( L , - 2 ) ; // kill obj table
return lua_touserdata ( L , - 2 ) ;
}
2010-04-06 04:26:32 -07:00
static Edje_Lua_Obj *
2011-11-17 09:42:29 -08:00
_elua_obj_new ( lua_State * L , Edje * ed , int size , const char * metatable ) // Stack usage [-?, +?, ?]
2010-04-06 04:26:32 -07:00
{
Edje_Lua_Obj * obj ;
2010-07-13 22:32:48 -07:00
2010-07-06 02:35:34 -07:00
obj = ( Edje_Lua_Obj * ) lua_newuserdata ( L , size ) ;
2010-04-06 04:26:32 -07:00
memset ( obj , 0 , size ) ;
ed - > lua_objs = eina_inlist_append ( ed - > lua_objs , EINA_INLIST_GET ( obj ) ) ;
2010-07-13 22:32:48 -07:00
2011-11-06 06:59:44 -08:00
luaL_getmetatable ( L , metatable ) ;
2010-07-06 02:35:34 -07:00
lua_setmetatable ( L , - 2 ) ;
2010-04-06 04:26:32 -07:00
obj - > ed = ed ;
2011-11-11 08:23:06 -08:00
obj - > meta = metatable ;
2010-07-13 22:32:48 -07:00
_elua_ref_set ( L , obj ) ;
2010-04-06 04:26:32 -07:00
return obj ;
}
static void
2010-08-19 07:57:23 -07:00
_elua_obj_free ( lua_State * L __UNUSED__ , Edje_Lua_Obj * obj )
2010-04-06 04:26:32 -07:00
{
if ( ! obj - > free_func ) return ;
obj - > free_func ( obj ) ;
obj - > ed - > lua_objs = eina_inlist_remove ( obj - > ed - > lua_objs , EINA_INLIST_GET ( obj ) ) ;
obj - > free_func = NULL ;
obj - > ed = NULL ;
}
static int
2011-11-17 09:42:29 -08:00
_elua_obj_gc ( lua_State * L ) // Stack usage [-?, +?, ?]
2010-04-06 04:26:32 -07:00
{
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
2011-11-06 01:00:21 -08:00
if ( ! obj ) return 0 ;
2010-04-06 04:26:32 -07:00
_elua_obj_free ( L , obj ) ;
return 0 ;
}
static int
_elua_obj_del ( lua_State * L )
{
return _elua_obj_gc ( L ) ;
}
2011-11-12 02:42:56 -08:00
static void
2011-11-17 09:42:29 -08:00
_elua_gc ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-12 02:42:56 -08:00
{
lua_gc ( L , LUA_GCCOLLECT , 0 ) ;
}
2011-11-11 18:23:33 -08:00
// These are what the various symbols are for each type -
// int %
// num #
// str $
// bool !
// FIXME: Still to do, if we ever use them -
// func &
// userdata +
// lightuserdata *
// table @
// thread ^
// nil ~
static char *
2011-11-17 09:42:29 -08:00
_elua_push_name ( lua_State * L , char * q , int index ) // Stack usage [-?, +?, ?]
2011-11-11 18:23:33 -08:00
{
char * p = q ;
char temp = ' \0 ' ;
// A simplistic scan through an identifier, it's wrong, but it's quick,
// and we don't mind that it's wrong, coz this is only internal.
while ( isalnum ( * q ) )
q + + ;
temp = * q ;
* q = ' \0 ' ;
if ( index > 0 )
lua_getfield ( L , index , p ) ;
else
lua_pushstring ( L , p ) ;
* q = temp ;
return q ;
}
static int
2011-11-17 09:42:29 -08:00
_elua_scan_params ( lua_State * L , int i , Eina_Bool tr , char * params , . . . ) // Stack usage [-?, +?, ?]
2011-11-11 18:23:33 -08:00
{
va_list vl ;
char * f = strdup ( params ) ;
char * p = f ;
int n = 0 , j = i , count = 0 ;
2011-11-11 18:31:09 -08:00
Eina_Bool table = EINA_FALSE ;
2011-11-11 18:23:33 -08:00
if ( ! f ) return - 1 ;
va_start ( vl , params ) ;
if ( lua_istable ( L , i ) )
{
j = - 1 ;
2011-11-11 18:31:09 -08:00
table = EINA_TRUE ;
2011-11-11 18:23:33 -08:00
}
while ( * p )
{
char * q ;
2011-11-11 18:31:09 -08:00
Eina_Bool get = EINA_TRUE ;
2011-11-11 18:23:33 -08:00
while ( isspace ( * p ) )
p + + ;
q = p + 1 ;
switch ( * p )
{
case ' % ' :
{
if ( table )
{
q = _elua_push_name ( L , q , i ) ;
}
if ( lua_isnumber ( L , j ) )
{
int * v = va_arg ( vl , int * ) ;
* v = lua_tointeger ( L , j ) ;
n + + ;
}
break ;
}
case ' # ' :
{
if ( table )
{
q = _elua_push_name ( L , q , i ) ;
}
if ( lua_isnumber ( L , j ) )
{
double * v = va_arg ( vl , double * ) ;
* v = lua_tonumber ( L , j ) ;
n + + ;
}
break ;
}
case ' $ ' :
{
if ( table )
{
q = _elua_push_name ( L , q , i ) ;
}
if ( lua_isstring ( L , j ) )
{
char * * v = va_arg ( vl , char * * ) ;
size_t len ;
char * temp = ( char * ) lua_tolstring ( L , j , & len ) ;
len + + ; // Cater for the null at the end.
* v = malloc ( len ) ;
if ( * v )
{
memcpy ( * v , temp , len ) ;
n + + ;
}
}
break ;
}
case ' ! ' :
{
if ( table )
{
q = _elua_push_name ( L , q , i ) ;
}
if ( lua_isboolean ( L , j ) )
{
int * v = va_arg ( vl , int * ) ;
* v = lua_toboolean ( L , j ) ;
n + + ;
}
break ;
}
default :
{
2011-11-11 18:31:09 -08:00
get = EINA_FALSE ;
2011-11-11 18:23:33 -08:00
break ;
}
}
if ( get )
{
if ( table )
{
}
else
j + + ;
count + + ;
}
p = q ;
}
if ( tr )
{
if ( table )
lua_settop ( L , i ) ;
else
lua_newtable ( L ) ;
}
free ( f ) ;
va_end ( vl ) ;
if ( count > n )
n = 0 ;
else if ( table )
n = 1 ;
return n ;
}
static int
2011-11-17 09:42:29 -08:00
_elua_ret ( lua_State * L , char * params , . . . ) // Stack usage [-?, +?, ?]
2011-11-11 18:23:33 -08:00
{
va_list vl ;
char * f = strdup ( params ) ;
char * p = f ;
int n = 0 ;
if ( ! f ) return - 1 ;
va_start ( vl , params ) ;
while ( * p )
{
char * q ;
2011-11-11 18:31:09 -08:00
Eina_Bool set = EINA_TRUE ;
2011-11-11 18:23:33 -08:00
while ( isspace ( * p ) )
p + + ;
q = p + 1 ;
switch ( * p )
{
case ' % ' :
{
q = _elua_push_name ( L , q , - 1 ) ;
lua_pushinteger ( L , va_arg ( vl , int ) ) ;
break ;
}
case ' # ' :
{
q = _elua_push_name ( L , q , - 1 ) ;
lua_pushnumber ( L , va_arg ( vl , double ) ) ;
break ;
}
case ' $ ' :
{
q = _elua_push_name ( L , q , - 1 ) ;
lua_pushstring ( L , va_arg ( vl , char * ) ) ;
break ;
}
case ' ! ' :
{
q = _elua_push_name ( L , q , - 1 ) ;
lua_pushboolean ( L , va_arg ( vl , int ) ) ;
break ;
}
default :
{
2011-11-11 18:31:09 -08:00
set = EINA_FALSE ;
2011-11-11 18:23:33 -08:00
break ;
}
}
if ( set )
{
lua_settable ( L , - 3 ) ;
n + + ;
}
p = q ;
}
2011-11-12 11:39:01 -08:00
free ( f ) ;
va_end ( vl ) ;
return n ;
}
static void
_elua_color_fix ( int * r , int * g , int * b , int * a )
{
if ( * r > * a ) * r = * a ;
if ( * g > * a ) * g = * a ;
if ( * b > * a ) * b = * a ;
}
//--------------------------------------------------------------------------//
/**
@ page luaref
@ subsection edje Edje class .
The lua edje class includes functions for dealing with the lua script only group
as an edje object , basic functions , and functions to create other objects .
2011-11-17 06:21:53 -08:00
In the following , " edje " is the actual global table used to access these edje functions .
2011-11-12 11:39:01 -08:00
*/
static int _elua_echo ( lua_State * L ) ;
static int _elua_date ( lua_State * L ) ;
static int _elua_looptime ( lua_State * L ) ;
static int _elua_seconds ( lua_State * L ) ;
static int _elua_objgeom ( lua_State * L ) ;
static int _elua_objpos ( lua_State * L ) ;
static int _elua_objsize ( lua_State * L ) ;
static int _elua_emit ( lua_State * L ) ;
static int _elua_messagesend ( lua_State * L ) ;
static int _elua_animator ( lua_State * L ) ;
static int _elua_timer ( lua_State * L ) ;
static int _elua_transition ( lua_State * L ) ;
static int _elua_color_class ( lua_State * L ) ;
static int _elua_text_class ( lua_State * L ) ;
2011-11-11 18:23:33 -08:00
2011-11-12 11:39:01 -08:00
static int _elua_edje ( lua_State * L ) ;
static int _elua_image ( lua_State * L ) ;
static int _elua_line ( lua_State * L ) ;
static int _elua_map ( lua_State * L ) ;
static int _elua_polygon ( lua_State * L ) ;
static int _elua_rect ( lua_State * L ) ;
static int _elua_text ( lua_State * L ) ;
//static int _elua_textblock(lua_State *L); /* XXX: disabled until there are enough textblock functions implemented to make it actually useful
static const char * _elua_edje_api = " edje " ;
static const struct luaL_reg _elua_edje_funcs [ ] =
2010-07-08 22:12:35 -07:00
{
2011-11-12 11:39:01 -08:00
// add an echo too to make it more shelly
{ " echo " , _elua_echo } , // test func - echo (i know we have print. test)
2011-11-13 16:13:36 -08:00
// FIXME: add logging functions here, probably to it's own domain, or even a script defined domain.
2010-07-08 22:12:35 -07:00
2011-11-12 11:39:01 -08:00
// system information (time, date blah blah)
{ " date " , _elua_date } , // get date in a table
{ " looptime " , _elua_looptime } , // get loop time
{ " seconds " , _elua_seconds } , // get seconds
2011-11-12 06:33:08 -08:00
2011-11-12 11:39:01 -08:00
// query edje - size, pos
{ " geom " , _elua_objgeom } , // get while edje object geometry in canvas
{ " pos " , _elua_objpos } , // get while edje object pos in canvas
{ " size " , _elua_objsize } , // get while edje object pos in canvas
2011-11-12 06:33:08 -08:00
2011-11-12 11:39:01 -08:00
// talk to application/caller
{ " emit " , _elua_emit } , // emit signal + src
{ " messagesend " , _elua_messagesend } , // send a structured message
// time based "callback" systems
{ " animator " , _elua_animator } , // add animator
{ " timer " , _elua_timer } , // add timer
{ " transition " , _elua_transition } , // add transition
// FIXME: need poller
// set and query color / text class
{ " color_class " , _elua_color_class } ,
{ " text_class " , _elua_text_class } ,
// create new objects
{ " edje " , _elua_edje } ,
{ " image " , _elua_image } , // defaults to a filled image.
{ " line " , _elua_line } ,
{ " map " , _elua_map } ,
{ " polygon " , _elua_polygon } ,
{ " rect " , _elua_rect } ,
{ " text " , _elua_text } ,
// {"textblock", _elua_textblock}, /* XXX: disabled until there are enough textblock functions implemented to make it actually useful
// FIXME: add the new sound stuff.
{ NULL , NULL } // end
} ;
2011-11-12 06:33:08 -08:00
/**
@ page luaref
2011-11-17 09:42:29 -08:00
@ subsubsection edje_echo edje : echo ( text )
2011-11-12 06:33:08 -08:00
2011-11-17 09:42:29 -08:00
Make lua a bit shelly . Prints a string to the console
2011-11-12 06:33:08 -08:00
2011-11-17 09:42:29 -08:00
@ param text The string to print .
2011-11-12 06:33:08 -08:00
*/
2011-11-12 02:42:56 -08:00
static int
2011-11-17 09:42:29 -08:00
_elua_echo ( lua_State * L ) // Stack usage [-0, +0, vm]
2010-07-08 22:12:35 -07:00
{
2011-11-12 02:42:56 -08:00
const char * string = luaL_checkstring ( L , 1 ) ;
2011-11-17 21:53:44 -08:00
LD ( " %s \n " , string ) ;
2011-11-12 02:42:56 -08:00
return 0 ;
2010-07-08 22:12:35 -07:00
}
2011-11-12 02:42:56 -08:00
//-------------
2011-11-12 06:33:08 -08:00
/**
@ page luaref
2011-11-17 06:21:53 -08:00
@ subsubsection edje_date edje : date ( )
2011-11-12 06:33:08 -08:00
2011-11-17 09:42:29 -08:00
Retrieves the current time and date .
2011-11-12 06:33:08 -08:00
2011-11-17 09:42:29 -08:00
Wraps gettimeofday ( ) , as passed through localtime ( ) .
@ return A table with these fields :
- integer year : Year .
- integer month : Month of the year .
- integer day : Day of the month .
- integer yearday : Day of the year .
- integer weekday : Day of the week .
- integer hour : Hour of the day ( 24 hour format ) .
- integer min : Minute of the hour .
- number sec : Seconds as a number .
2011-11-12 06:33:08 -08:00
*/
2011-11-12 02:42:56 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_date ( lua_State * L ) // Stack usage [-?, +?, ?]
2010-07-08 22:12:35 -07:00
{
2011-11-12 02:42:56 -08:00
static time_t last_tzset = 0 ;
struct timeval timev ;
struct tm * tm ;
time_t tt ;
2011-11-06 01:00:21 -08:00
2011-11-12 02:42:56 -08:00
lua_newtable ( L ) ;
gettimeofday ( & timev , NULL ) ;
tt = ( time_t ) ( timev . tv_sec ) ;
if ( ( tt > ( last_tzset + 1 ) ) | | ( tt < ( last_tzset - 1 ) ) )
2010-07-08 22:12:35 -07:00
{
2011-11-12 02:42:56 -08:00
last_tzset = tt ;
tzset ( ) ;
2010-07-08 22:12:35 -07:00
}
2011-11-12 02:42:56 -08:00
tm = localtime ( & tt ) ;
if ( tm )
{
_elua_ret ( L , " %year %month %day %yearday %weekday %hour %min #sec " ,
( int ) ( tm - > tm_year + 1900 ) ,
( int ) ( tm - > tm_mon + 1 ) ,
( int ) ( tm - > tm_mday ) ,
( int ) ( tm - > tm_yday ) ,
( int ) ( ( tm - > tm_wday + 6 ) % 7 ) ,
( int ) ( tm - > tm_hour ) ,
( int ) ( tm - > tm_min ) ,
( double ) ( ( double ) tm - > tm_sec + ( ( ( double ) timev . tv_usec ) / 1000000 ) )
) ;
2010-07-08 22:12:35 -07:00
2010-07-25 23:52:36 -07:00
2010-07-08 22:12:35 -07:00
}
2011-11-12 02:42:56 -08:00
return 1 ;
2010-07-08 22:12:35 -07:00
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection edje_looptime edje : looptime ( )
2011-11-17 09:42:29 -08:00
Retrieves the time at which the last loop stopped waiting for timeouts or events .
This gets the time that the main loop ceased waiting for timouts and / or events
to come in or for signals or any other interrupt source . This should be
considered a reference point for all time based activity that should calculate
its timepoint from the return of edje : looptime ( ) . Use this UNLESS you absolutely
must get the current actual timepoint - then use edje : seconds ( ) . Note that this
time is meant to be used as relative to other times obtained on this run .
2011-11-17 06:21:53 -08:00
2011-11-17 09:42:29 -08:00
Wraps ecore_loop_time_get ( ) .
@ returns A number of seconds .
2011-11-17 06:21:53 -08:00
*/
2011-11-12 02:42:56 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_looptime ( lua_State * L ) // Stack usage [-?, +?, ?]
2010-07-08 22:12:35 -07:00
{
2011-11-12 02:42:56 -08:00
double t = ecore_loop_time_get ( ) ;
lua_pushnumber ( L , t ) ;
return 1 ;
}
2011-11-06 01:00:21 -08:00
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection edje_seconds edje : seconds ( )
2011-11-17 09:42:29 -08:00
Retrieves the current system time as a floating point value in seconds .
This uses a monotonic clock and thus never goes back in time while machine is
live ( even if user changes time or timezone changes , however it may be reset
whenever the machine is restarted ) .
2011-11-17 06:21:53 -08:00
2011-11-17 09:42:29 -08:00
Wraps ecore_time_get ( ) .
@ returns A number of seconds .
2011-11-17 06:21:53 -08:00
*/
2011-11-12 02:42:56 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_seconds ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-12 02:42:56 -08:00
{
double t = ecore_time_get ( ) ;
lua_pushnumber ( L , t ) ;
return 1 ;
2010-07-08 22:12:35 -07:00
}
2011-11-12 02:42:56 -08:00
//-------------
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection edje_geom edje : geom ( )
2011-11-17 09:42:29 -08:00
Retrieves the position and size of the edje object that this lua group is in .
2011-11-17 06:21:53 -08:00
2011-11-17 09:42:29 -08:00
@ returns A table with these fields :
- integer x : The edjes X position .
- integer y : The edjes Y position .
- integer w : The edjes width .
- integer h : The edjes height .
2011-11-17 06:21:53 -08:00
*/
2011-11-12 02:42:56 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_objgeom ( lua_State * L ) // Stack usage [-?, +?, ?]
2010-07-08 22:12:35 -07:00
{
2011-11-12 02:42:56 -08:00
Edje * ed = ( Edje * ) _elua_table_ptr_get ( L , _elua_key ) ;
if ( ! lua_istable ( L , 1 ) ) lua_newtable ( L ) ;
_elua_ret ( L , " %x %y %w %h " , ed - > x , ed - > y , ed - > w , ed - > h ) ;
return 1 ;
}
2011-11-06 01:00:21 -08:00
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection edje_pos edje : pos ( )
2011-11-17 09:42:29 -08:00
Retrieves the position of the edje object that this lua group is in .
@ returns A table with these fields :
- integer x : The edjes X position .
- integer y : The edjes Y position .
2011-11-17 06:21:53 -08:00
*/
static int
_elua_objpos ( lua_State * L ) // Stack usage [-?, +?, ?]
2010-07-06 17:58:34 -07:00
{
Edje * ed = ( Edje * ) _elua_table_ptr_get ( L , _elua_key ) ;
2011-11-12 02:42:56 -08:00
if ( ! lua_istable ( L , 1 ) ) lua_newtable ( L ) ;
_elua_ret ( L , " %x %y " , ed - > x , ed - > y ) ;
2010-07-06 19:40:46 -07:00
return 1 ;
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection edje_size edje : size ( )
2011-11-17 09:42:29 -08:00
Retrieves the size of the edje object that this lua group is in .
@ returns A table with these fields :
- integer w : The edjes width .
- integer h : The edjes height .
2011-11-17 06:21:53 -08:00
*/
2010-07-06 19:40:46 -07:00
static int
2011-11-17 06:21:53 -08:00
_elua_objsize ( lua_State * L ) // Stack usage [-?, +?, ?]
2010-07-06 19:40:46 -07:00
{
2011-11-12 02:42:56 -08:00
Edje * ed = ( Edje * ) _elua_table_ptr_get ( L , _elua_key ) ;
if ( ! lua_istable ( L , 1 ) ) lua_newtable ( L ) ;
_elua_ret ( L , " %w %h " , ed - > w , ed - > h ) ;
2010-07-06 19:40:46 -07:00
return 1 ;
}
2010-07-08 17:46:42 -07:00
//-------------
2011-11-17 06:21:53 -08:00
/**
@ page luaref
2011-11-17 09:42:29 -08:00
@ subsubsection edje_emit edje : emit ( signal , source )
Emit a signal .
Wraps edje_object_signal_emit ( ) .
@ param signal The signal string to send .
@ param source The source string of the signal .
NOTE : The source string will have a name and a colon prepended to in when it is
delivered to things that are not this edje , like C and other edje groups .
If this edje is a top level edje , then it will be the name of the group ( I think ) .
If this edje is swallowed into some other part , then it will be the name of the
part :
2011-11-17 06:21:53 -08:00
2011-11-17 09:42:29 -08:00
group_name : source
2011-11-17 06:21:53 -08:00
2011-11-17 09:42:29 -08:00
FIXME : I actually have no idea what happens if it ' s swallowed into another lua
edje group .
2011-11-17 06:21:53 -08:00
*/
2010-07-08 17:46:42 -07:00
static int
2011-11-17 06:21:53 -08:00
_elua_emit ( lua_State * L ) // Stack usage [-?, +?, ?]
2010-07-08 17:46:42 -07:00
{
Edje * ed = ( Edje * ) _elua_table_ptr_get ( L , _elua_key ) ;
const char * sig = luaL_checkstring ( L , 1 ) ;
const char * src = luaL_checkstring ( L , 2 ) ;
if ( ( ! sig ) | | ( ! src ) ) return 0 ;
_edje_emit ( ed , sig , src ) ;
return 0 ;
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
2011-11-17 09:42:29 -08:00
@ subsubsection edje_message_send edje : messagesend ( id , type , . . . )
2011-11-17 06:21:53 -08:00
2011-11-17 09:42:29 -08:00
Send a message to this edje , and all it ' s child objects .
2011-11-17 06:21:53 -08:00
2011-11-17 09:42:29 -08:00
Wraps edje_object_message_send ( ) .
@ param id An identification integer for the message .
@ param type The type of message to send .
@ param . . . Zero or more things to send as part of the message , depending on the type .
The type can be one of :
- none : No msg .
- sig : The msg is two strings ( signal , source ) , sent as a signal .
- str : The msg is a C string .
- int : The message is a C integer .
- float : The message is a C float .
- strset : The message is an array of C strings .
- intset : The message is an array of C integers .
- floatset : The message is an array of C floats .
- strint : The message is a C stnring and a C integer .
- strfloat : The message is a C string and a C float .
- strintset : The message is a C string and an array of C integers .
- strfloatset : The message is a G string and an array of C floats .
2011-11-17 10:13:58 -08:00
For the array types , the lua caller passes a table .
2011-11-17 06:21:53 -08:00
*/
2010-07-08 17:46:42 -07:00
static int
2011-11-17 06:21:53 -08:00
_elua_messagesend ( lua_State * L ) // Stack usage [-?, +?, ?]
2010-07-08 17:46:42 -07:00
{
Edje * ed = ( Edje * ) _elua_table_ptr_get ( L , _elua_key ) ;
int id = luaL_checkinteger ( L , 1 ) ;
const char * type = luaL_checkstring ( L , 2 ) ;
if ( ! type ) return 0 ;
if ( ! strcmp ( type , " none " ) )
{
_edje_message_send ( ed , EDJE_QUEUE_APP , EDJE_MESSAGE_NONE , id , NULL ) ;
}
else if ( ! strcmp ( type , " sig " ) )
{
const char * sig = luaL_checkstring ( L , 3 ) ;
const char * src = luaL_checkstring ( L , 4 ) ;
_edje_emit ( ed , sig , src ) ;
}
else if ( ! strcmp ( type , " str " ) )
{
Edje_Message_String * emsg ;
const char * str = luaL_checkstring ( L , 3 ) ;
emsg = alloca ( sizeof ( Edje_Message_String ) ) ;
emsg - > str = ( char * ) str ;
_edje_message_send ( ed , EDJE_QUEUE_APP , EDJE_MESSAGE_STRING , id , emsg ) ;
}
else if ( ! strcmp ( type , " int " ) )
{
Edje_Message_Int * emsg ;
int val = luaL_checkinteger ( L , 3 ) ;
emsg = alloca ( sizeof ( Edje_Message_Int ) ) ;
emsg - > val = val ;
_edje_message_send ( ed , EDJE_QUEUE_APP , EDJE_MESSAGE_INT , id , emsg ) ;
}
else if ( ! strcmp ( type , " float " ) )
{
Edje_Message_Float * emsg ;
float val = luaL_checknumber ( L , 3 ) ;
emsg = alloca ( sizeof ( Edje_Message_Float ) ) ;
emsg - > val = val ;
_edje_message_send ( ed , EDJE_QUEUE_APP , EDJE_MESSAGE_FLOAT , id , emsg ) ;
}
else if ( ! strcmp ( type , " strset " ) )
{
Edje_Message_String_Set * emsg ;
2010-08-18 09:55:49 -07:00
int i , n ;
2010-07-08 17:46:42 -07:00
const char * str ;
luaL_checktype ( L , 3 , LUA_TTABLE ) ;
n = lua_objlen ( L , 3 ) ;
emsg = alloca ( sizeof ( Edje_Message_String_Set ) + ( ( n - 1 ) * sizeof ( char * ) ) ) ;
emsg - > count = n ;
for ( i = 1 ; i < = n ; i + + )
{
lua_rawgeti ( L , 3 , i ) ;
str = lua_tostring ( L , - 1 ) ;
emsg - > str [ i - 1 ] = ( char * ) str ;
}
_edje_message_send ( ed , EDJE_QUEUE_APP , EDJE_MESSAGE_STRING_SET , id , emsg ) ;
}
else if ( ! strcmp ( type , " intset " ) )
{
Edje_Message_Int_Set * emsg ;
int i , n ;
luaL_checktype ( L , 3 , LUA_TTABLE ) ;
n = lua_objlen ( L , 3 ) ;
emsg = alloca ( sizeof ( Edje_Message_Int_Set ) + ( ( n - 1 ) * sizeof ( int ) ) ) ;
emsg - > count = n ;
for ( i = 1 ; i < = n ; i + + )
{
lua_rawgeti ( L , 3 , i ) ;
emsg - > val [ i - 1 ] = lua_tointeger ( L , - 1 ) ;
}
_edje_message_send ( ed , EDJE_QUEUE_APP , EDJE_MESSAGE_INT_SET , id , emsg ) ;
}
else if ( ! strcmp ( type , " floatset " ) )
{
Edje_Message_Float_Set * emsg ;
int i , n ;
luaL_checktype ( L , 3 , LUA_TTABLE ) ;
n = lua_objlen ( L , 3 ) ;
emsg = alloca ( sizeof ( Edje_Message_Float_Set ) + ( ( n - 1 ) * sizeof ( double ) ) ) ;
emsg - > count = n ;
for ( i = 1 ; i < = n ; i + + )
{
lua_rawgeti ( L , 3 , i ) ;
emsg - > val [ i - 1 ] = lua_tonumber ( L , - 1 ) ;
}
_edje_message_send ( ed , EDJE_QUEUE_APP , EDJE_MESSAGE_FLOAT_SET , id , emsg ) ;
}
else if ( ! strcmp ( type , " strint " ) )
{
Edje_Message_String_Int * emsg ;
const char * str = luaL_checkstring ( L , 3 ) ;
emsg = alloca ( sizeof ( Edje_Message_String_Int ) ) ;
emsg - > str = ( char * ) str ;
emsg - > val = luaL_checkinteger ( L , 4 ) ;
_edje_message_send ( ed , EDJE_QUEUE_APP , EDJE_MESSAGE_STRING_INT , id , emsg ) ;
}
else if ( ! strcmp ( type , " strfloat " ) )
{
Edje_Message_String_Float * emsg ;
const char * str = luaL_checkstring ( L , 3 ) ;
emsg = alloca ( sizeof ( Edje_Message_String_Float ) ) ;
emsg - > str = ( char * ) str ;
emsg - > val = luaL_checknumber ( L , 4 ) ;
_edje_message_send ( ed , EDJE_QUEUE_APP , EDJE_MESSAGE_STRING_FLOAT , id , emsg ) ;
}
else if ( ! strcmp ( type , " strintset " ) )
{
Edje_Message_String_Int_Set * emsg ;
int i , n ;
const char * str = luaL_checkstring ( L , 3 ) ;
if ( ! str ) return 0 ;
luaL_checktype ( L , 4 , LUA_TTABLE ) ;
n = lua_objlen ( L , 4 ) ;
emsg = alloca ( sizeof ( Edje_Message_String_Int_Set ) + ( ( n - 1 ) * sizeof ( int ) ) ) ;
emsg - > str = ( char * ) str ;
emsg - > count = n ;
for ( i = 1 ; i < = n ; i + + )
{
lua_rawgeti ( L , 4 , i ) ;
emsg - > val [ i - 1 ] = lua_tointeger ( L , - 1 ) ;
}
_edje_message_send ( ed , EDJE_QUEUE_APP , EDJE_MESSAGE_STRING_INT_SET , id , emsg ) ;
}
else if ( ! strcmp ( type , " strfloatset " ) )
{
Edje_Message_String_Float_Set * emsg ;
int i , n ;
const char * str = luaL_checkstring ( L , 3 ) ;
if ( ! str ) return 0 ;
luaL_checktype ( L , 4 , LUA_TTABLE ) ;
n = lua_objlen ( L , 4 ) ;
emsg = alloca ( sizeof ( Edje_Message_String_Float_Set ) + ( ( n - 1 ) * sizeof ( double ) ) ) ;
emsg - > str = ( char * ) str ;
emsg - > count = n ;
for ( i = 1 ; i < = n ; i + + )
{
lua_rawgeti ( L , 4 , i ) ;
emsg - > val [ i - 1 ] = lua_tonumber ( L , - 1 ) ;
}
_edje_message_send ( ed , EDJE_QUEUE_APP , EDJE_MESSAGE_STRING_FLOAT_SET , id , emsg ) ;
}
2011-11-12 02:42:56 -08:00
return 0 ;
}
//-------------
static Eina_Bool
_elua_animator_cb ( void * data )
{
Edje_Lua_Animator * ela = data ;
lua_State * L ;
int ret = 0 , err = 0 ;
if ( ! ela - > obj . ed ) return 0 ;
L = ela - > obj . ed - > L ;
if ( ! L ) return 0 ;
lua_rawgeti ( L , LUA_REGISTRYINDEX , ela - > fn_ref ) ;
if ( setjmp ( panic_jmp ) = = 1 )
{
2011-11-13 16:13:36 -08:00
LE ( " Animator callback panic " ) ;
2011-11-12 02:42:56 -08:00
_edje_lua2_error ( L , err ) ;
_elua_obj_free ( L , ( Edje_Lua_Obj * ) ela ) ;
_elua_gc ( L ) ;
return 0 ;
}
if ( ( err = lua_pcall ( L , 0 , 1 , 0 ) ) )
{
_edje_lua2_error ( L , err ) ;
_elua_obj_free ( L , ( Edje_Lua_Obj * ) ela ) ;
_elua_gc ( L ) ;
return 0 ;
}
ret = lua_toboolean ( L , - 1 ) ;
lua_pop ( L , 1 ) ;
if ( ret = = 0 ) _elua_obj_free ( L , ( Edje_Lua_Obj * ) ela ) ;
_elua_gc ( L ) ;
return ret ;
}
static void
_elua_animator_free ( void * obj )
{
Edje_Lua_Animator * ela = obj ;
lua_State * L ;
if ( ! ela - > obj . ed ) return ;
L = ela - > obj . ed - > L ;
luaL_unref ( L , LUA_REGISTRYINDEX , ela - > fn_ref ) ;
ela - > fn_ref = 0 ;
ecore_animator_del ( ela - > animator ) ;
ela - > animator = NULL ;
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
2011-11-17 09:42:29 -08:00
@ subsubsection edje_animator edje : animator ( func )
This function adds an animator and returns its handle on success and NULL on
failure . The function func will be called every frame tick . Note that setting
the frame tick is not available as a lua function , so has to be done from C .
The default tick is 1 / 30 second .
When the animator func is called , it must return a value of either true or false .
If it returns true it will be called again at the next tick , or if it returns
false it will be deleted automatically making any references / handles for it
invalid .
2011-11-17 06:21:53 -08:00
2011-11-17 09:42:29 -08:00
Wraps ecore_animator_add ( ) .
2011-11-17 06:21:53 -08:00
2011-11-17 09:42:29 -08:00
@ param func The function to call when the animator triggers .
@ returns A userdata that is an ecore animator .
2011-11-17 06:21:53 -08:00
*/
2011-11-12 02:42:56 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_animator ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-12 02:42:56 -08:00
{
Edje * ed = ( Edje * ) _elua_table_ptr_get ( L , _elua_key ) ;
Edje_Lua_Animator * ela ;
luaL_checkany ( L , 1 ) ;
2011-11-17 09:42:29 -08:00
// FIXME: Allow lua to set a data to be sent back with the callback.
2011-11-17 18:27:16 -08:00
ela = ( Edje_Lua_Animator * ) _elua_obj_new ( L , ed , sizeof ( Edje_Lua_Animator ) , _elua_ecore_animator_meta ) ;
2011-11-12 02:42:56 -08:00
ela - > obj . free_func = _elua_animator_free ;
ela - > animator = ecore_animator_add ( _elua_animator_cb , ela ) ;
lua_pushvalue ( L , 1 ) ;
ela - > fn_ref = luaL_ref ( L , LUA_REGISTRYINDEX ) ;
_elua_gc ( L ) ;
return 1 ;
}
static Eina_Bool
_elua_timer_cb ( void * data )
{
Edje_Lua_Timer * elt = data ;
lua_State * L ;
int ret = 0 , err = 0 ;
if ( ! elt - > obj . ed ) return 0 ;
L = elt - > obj . ed - > L ;
if ( ! L ) return 0 ;
lua_rawgeti ( L , LUA_REGISTRYINDEX , elt - > fn_ref ) ;
if ( setjmp ( panic_jmp ) = = 1 )
{
2011-11-13 16:13:36 -08:00
LE ( " Timer callback panic " ) ;
2011-11-12 02:42:56 -08:00
_edje_lua2_error ( L , err ) ;
_elua_obj_free ( L , ( Edje_Lua_Obj * ) elt ) ;
_elua_gc ( L ) ;
return 0 ;
}
if ( ( err = lua_pcall ( L , 0 , 1 , 0 ) ) )
{
_edje_lua2_error ( L , err ) ;
_elua_obj_free ( L , ( Edje_Lua_Obj * ) elt ) ;
_elua_gc ( L ) ;
return 0 ;
}
ret = lua_toboolean ( L , - 1 ) ;
lua_pop ( L , 1 ) ;
if ( ret = = 0 ) _elua_obj_free ( L , ( Edje_Lua_Obj * ) elt ) ;
_elua_gc ( L ) ;
return ret ;
}
static void
_elua_timer_free ( void * obj )
{
Edje_Lua_Timer * elt = obj ;
lua_State * L ;
if ( ! elt - > obj . ed ) return ;
L = elt - > obj . ed - > L ;
luaL_unref ( L , LUA_REGISTRYINDEX , elt - > fn_ref ) ; //0
elt - > fn_ref = 0 ;
ecore_timer_del ( elt - > timer ) ;
elt - > timer = NULL ;
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
2011-11-17 09:42:29 -08:00
@ subsubsection edje_timer edje : timer ( tick , func )
This function adds a timer and returns its handle on success and NULL on failure .
The function func will be called every tick seconds .
When the timer func is called , it must return a value of either true or false .
If it returns true , it will be called again at the next tick , or if it returns
false it will be deleted automatically making any references / handles for it
invalid .
2011-11-17 06:21:53 -08:00
2011-11-17 09:42:29 -08:00
Wraps ecore_timer_add ( ) .
2011-11-17 06:21:53 -08:00
2011-11-17 09:42:29 -08:00
@ param tick How often , in seconds , to call the function .
@ param func The function to call when the timer triggers .
@ returns A userdata that is an ecore timer .
2011-11-17 06:21:53 -08:00
*/
2011-11-12 02:42:56 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_timer ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-12 02:42:56 -08:00
{
Edje * ed = ( Edje * ) _elua_table_ptr_get ( L , _elua_key ) ;
Edje_Lua_Timer * elt ;
double val ;
val = luaL_checknumber ( L , 1 ) ;
luaL_checkany ( L , 2 ) ;
2011-11-17 18:27:16 -08:00
elt = ( Edje_Lua_Timer * ) _elua_obj_new ( L , ed , sizeof ( Edje_Lua_Timer ) , _elua_ecore_timer_meta ) ;
2011-11-12 02:42:56 -08:00
elt - > obj . free_func = _elua_timer_free ;
elt - > timer = ecore_timer_add ( val , _elua_timer_cb , elt ) ;
lua_pushvalue ( L , 2 ) ;
elt - > fn_ref = luaL_ref ( L , LUA_REGISTRYINDEX ) ;
_elua_gc ( L ) ;
return 1 ;
}
static Eina_Bool
_elua_transition_cb ( void * data )
{
Edje_Lua_Transition * elt = data ;
lua_State * L ;
int ret = 0 , err = 0 ;
double t ;
if ( ! elt - > obj . ed ) return 0 ;
L = elt - > obj . ed - > L ;
if ( ! L ) return 0 ;
t = ( ecore_loop_time_get ( ) - elt - > start ) / elt - > transition ;
if ( t > 1.0 ) t = 1.0 ;
lua_rawgeti ( L , LUA_REGISTRYINDEX , elt - > fn_ref ) ;
lua_pushnumber ( L , t ) ;
if ( setjmp ( panic_jmp ) = = 1 )
{
2011-11-13 16:13:36 -08:00
LE ( " Transition callback panic " ) ;
2011-11-12 02:42:56 -08:00
_edje_lua2_error ( L , err ) ;
_elua_obj_free ( L , ( Edje_Lua_Obj * ) elt ) ;
_elua_gc ( L ) ;
return 0 ;
}
if ( ( err = lua_pcall ( L , 1 , 1 , 0 ) ) )
{
_edje_lua2_error ( L , err ) ;
_elua_obj_free ( L , ( Edje_Lua_Obj * ) elt ) ;
_elua_gc ( L ) ;
return 0 ;
}
ret = lua_toboolean ( L , - 1 ) ;
lua_pop ( L , 1 ) ;
if ( t > = 1.0 ) ret = 0 ;
if ( ret = = 0 ) _elua_obj_free ( L , ( Edje_Lua_Obj * ) elt ) ;
_elua_gc ( L ) ;
return ret ;
2010-07-08 17:46:42 -07:00
}
2011-11-12 02:42:56 -08:00
static void
_elua_transition_free ( void * obj )
2010-07-12 23:17:15 -07:00
{
2011-11-12 02:42:56 -08:00
Edje_Lua_Transition * elt = obj ;
lua_State * L ;
if ( ! elt - > obj . ed ) return ;
L = elt - > obj . ed - > L ;
luaL_unref ( L , LUA_REGISTRYINDEX , elt - > fn_ref ) ; //0
elt - > fn_ref = 0 ;
ecore_animator_del ( elt - > animator ) ;
elt - > animator = NULL ;
2010-07-12 23:17:15 -07:00
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
2011-11-17 09:42:29 -08:00
@ subsubsection edje_transition edje : transition ( div , func )
Just like edje : animator ( ) , except that the callback function gets called with an
argument . The argument is the amount of time since the transition was created ,
divided by the div parameter .
2011-11-17 06:21:53 -08:00
2011-11-17 09:42:29 -08:00
@ param div A number to divide the time since creation by .
@ param func The function to call when the transition triggers .
2011-11-17 06:21:53 -08:00
2011-11-17 09:42:29 -08:00
@ returns A userdata that is a transition ( ecore animator , plus other info ) .
2011-11-17 06:21:53 -08:00
*/
2010-07-12 23:17:15 -07:00
static int
2011-11-17 06:21:53 -08:00
_elua_transition ( lua_State * L ) // Stack usage [-?, +?, ?]
2010-07-12 23:17:15 -07:00
{
Edje * ed = ( Edje * ) _elua_table_ptr_get ( L , _elua_key ) ;
2011-11-12 02:42:56 -08:00
Edje_Lua_Transition * elt ;
double val ;
2010-07-12 23:17:15 -07:00
2011-11-12 02:42:56 -08:00
val = luaL_checknumber ( L , 1 ) ;
luaL_checkany ( L , 2 ) ;
2010-07-12 23:17:15 -07:00
2011-11-17 18:27:16 -08:00
elt = ( Edje_Lua_Transition * ) _elua_obj_new ( L , ed , sizeof ( Edje_Lua_Transition ) , _elua_ecore_animator_meta ) ;
2011-11-12 02:42:56 -08:00
elt - > obj . free_func = _elua_transition_free ;
elt - > animator = ecore_animator_add ( _elua_transition_cb , elt ) ;
if ( val < 0.0000001 ) val = 0.0000001 ;
elt - > transition = val ;
elt - > start = ecore_loop_time_get ( ) ;
lua_pushvalue ( L , 2 ) ;
elt - > fn_ref = luaL_ref ( L , LUA_REGISTRYINDEX ) ;
_elua_gc ( L ) ;
return 1 ;
2010-07-12 23:17:15 -07:00
}
//-------------
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection edje_colour_class edje : color_class ( )
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
2011-11-06 01:00:21 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_color_class ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-06 01:00:21 -08:00
{
Edje * ed = ( Edje * ) _elua_table_ptr_get ( L , _elua_key ) ;
Edje_Color_Class * c_class ;
const char * class = luaL_checkstring ( L , 1 ) ;
int r , g , b , a ;
if ( ! class ) return 0 ;
2011-11-11 18:23:33 -08:00
if ( _elua_scan_params ( L , 2 , EINA_TRUE , " %r %g %b %a " , & r , & g , & b , & a ) > 0 )
2011-11-06 01:00:21 -08:00
{
_elua_color_fix ( & r , & g , & b , & a ) ;
// This is the way that embryo does it -
//edje_object_color_class_set(ed->obj, class, r, g, b, a, r, g, b, a, r, g, b, a);
// But that deals with object scope, which is currently useless in lua,
// since we have no objects that can use color_class yet.
// So we do it at global scope instead.
// LATER - Should do both?
edje_color_class_set ( class , r , g , b , a , r , g , b , a , r , g , b , a ) ;
}
c_class = _edje_color_class_find ( ed , class ) ;
if ( ! c_class ) return 0 ;
2011-11-11 18:23:33 -08:00
_elua_ret ( L , " %r %g %b %a " , c_class - > r , c_class - > g , c_class - > b , c_class - > a ) ;
2011-11-06 01:00:21 -08:00
return 1 ;
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection edje_text_class edje : text_class ( )
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
2011-11-06 01:00:21 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_text_class ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-06 01:00:21 -08:00
{
Edje * ed = ( Edje * ) _elua_table_ptr_get ( L , _elua_key ) ;
Edje_Text_Class * t_class ;
const char * class = luaL_checkstring ( L , 1 ) ;
char * font = NULL ;
Evas_Font_Size size = 0 ;
if ( ! class ) return 0 ;
// Just like color_class above, this does things differently from embryo,
// for the same reason.
2011-11-11 18:23:33 -08:00
if ( _elua_scan_params ( L , 2 , EINA_TRUE , " $font %size " , & font , & size ) > 0 )
2011-11-06 01:00:21 -08:00
edje_text_class_set ( class , font , size ) ;
t_class = _edje_text_class_find ( ed , class ) ;
if ( ! t_class ) return 0 ;
2011-11-11 18:23:33 -08:00
_elua_ret ( L , " $font %size " , t_class - > font , t_class - > size ) ;
2011-11-06 01:00:21 -08:00
return 1 ;
}
//-------------
2011-11-12 02:42:56 -08:00
static void
_elua_evas_obj_free ( void * obj )
{
Edje_Lua_Evas_Object * elo = obj ;
2011-11-13 09:58:11 -08:00
2011-11-12 02:42:56 -08:00
if ( ! elo - > obj . ed ) return ;
evas_object_del ( elo - > evas_obj ) ;
elo - > evas_obj = NULL ;
}
# define _ELUA_PLANT_EVAS_OBJECT(type, meta, free) \
Edje * ed = ( Edje * ) _elua_table_ptr_get ( L , _elua_key ) ; \
type * elo ; \
elo = ( type * ) _elua_obj_new ( L , ed , sizeof ( type ) , meta ) ; \
elo - > obj . free_func = free ;
2011-11-12 11:39:01 -08:00
static void
_elua_polish_evas_object ( Edje * ed , Edje_Lua_Evas_Object * elo )
{
evas_object_smart_member_add ( elo - > evas_obj , ed - > obj ) ;
evas_object_clip_set ( elo - > evas_obj , ed - > base . clipper ) ;
evas_object_move ( elo - > evas_obj , ed - > x , ed - > y ) ;
evas_object_resize ( elo - > evas_obj , 0 , 0 ) ;
evas_object_data_set ( elo - > evas_obj , ELO , elo ) ;
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection edje_edje edje : edje ( )
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
2011-11-12 11:39:01 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_edje ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-12 11:39:01 -08:00
{
_ELUA_PLANT_EVAS_OBJECT ( Edje_Lua_Evas_Object , _elua_evas_edje_meta , _elua_evas_obj_free )
elo - > evas_obj = edje_object_add ( evas_object_evas_get ( ed - > obj ) ) ;
2011-11-18 02:35:38 -08:00
_edje_subobj_register ( ed , elo - > evas_obj ) ;
2011-11-12 11:39:01 -08:00
_elua_polish_evas_object ( ed , elo ) ;
return 1 ;
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection edje_image edje : image ( )
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
2011-11-12 11:39:01 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_image ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-12 11:39:01 -08:00
{
_ELUA_PLANT_EVAS_OBJECT ( Edje_Lua_Evas_Object , _elua_evas_image_meta , _elua_evas_obj_free )
elo - > evas_obj = evas_object_image_filled_add ( evas_object_evas_get ( ed - > obj ) ) ;
_elua_polish_evas_object ( ed , elo ) ;
return 1 ;
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection edje_line edje : line ( )
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
2011-11-12 11:39:01 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_line ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-12 11:39:01 -08:00
{
_ELUA_PLANT_EVAS_OBJECT ( Edje_Lua_Evas_Object , _elua_evas_line_meta , _elua_evas_obj_free )
elo - > evas_obj = evas_object_line_add ( evas_object_evas_get ( ed - > obj ) ) ;
_elua_polish_evas_object ( ed , elo ) ;
return 1 ;
}
static void
_elua_map_free ( void * obj )
{
Edje_Lua_Map * elm = obj ;
if ( ! elm - > obj . ed ) return ;
evas_map_free ( elm - > map ) ;
elm - > map = NULL ;
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection edje_map edje : map ( )
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
2011-11-12 11:39:01 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_map ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-12 11:39:01 -08:00
{
Edje * ed = ( Edje * ) _elua_table_ptr_get ( L , _elua_key ) ;
Edje_Lua_Map * elm ;
int count ;
count = luaL_checkinteger ( L , 1 ) ;
elm = ( Edje_Lua_Map * ) _elua_obj_new ( L , ed , sizeof ( Edje_Lua_Map ) , _elua_evas_map_meta ) ;
elm - > obj . free_func = _elua_map_free ;
elm - > map = evas_map_new ( count ) ;
lua_pushvalue ( L , 2 ) ;
_elua_gc ( L ) ;
return 1 ;
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection edje_polygon edje : polygon ( )
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
2011-11-12 11:39:01 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_polygon ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-12 11:39:01 -08:00
{
_ELUA_PLANT_EVAS_OBJECT ( Edje_Lua_Evas_Object , _elua_evas_polygon_meta , _elua_evas_obj_free )
elo - > evas_obj = evas_object_polygon_add ( evas_object_evas_get ( ed - > obj ) ) ;
_elua_polish_evas_object ( ed , elo ) ;
return 1 ;
}
/**
@ page luaref
2011-11-17 06:21:53 -08:00
@ subsubsection edje_rect edje : rect ( )
2011-11-12 11:39:01 -08:00
2011-11-17 09:42:29 -08:00
Create an evas rectangle , and add it to the edje .
2011-11-12 11:39:01 -08:00
2011-11-17 09:42:29 -08:00
@ returns A userdata that is an evas rectangle .
2011-11-12 11:39:01 -08:00
*/
static int
2011-11-17 06:21:53 -08:00
_elua_rect ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-12 11:39:01 -08:00
{
_ELUA_PLANT_EVAS_OBJECT ( Edje_Lua_Evas_Object , _elua_evas_meta , _elua_evas_obj_free )
elo - > evas_obj = evas_object_rectangle_add ( evas_object_evas_get ( ed - > obj ) ) ;
_elua_polish_evas_object ( ed , elo ) ;
return 1 ;
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection edje_text edje : text ( )
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
2011-11-12 11:39:01 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_text ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-12 11:39:01 -08:00
{
_ELUA_PLANT_EVAS_OBJECT ( Edje_Lua_Evas_Object , _elua_evas_text_meta , _elua_evas_obj_free )
elo - > evas_obj = evas_object_text_add ( evas_object_evas_get ( ed - > obj ) ) ;
_elua_polish_evas_object ( ed , elo ) ;
return 1 ;
}
/* XXX: disabled until there are enough textblock functions implemented to make it actually useful
2011-11-17 06:21:53 -08:00
_elua_textblock ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-12 11:39:01 -08:00
{
_ELUA_PLANT_EVAS_OBJECT ( Edje_Lua_Evas_Object , _elua_evas_textblock_meta , _elua_evas_obj_free )
elo - > evas_obj = evas_object_textblock_add ( evas_object_evas_get ( ed - > obj ) ) ;
_elua_polish_evas_object ( ed , elo ) ;
return 1 ;
}
*/
//-------------
//-------------
/**
@ page luaref
@ subsection evas Evas class .
2011-11-17 06:21:53 -08:00
The lua evas class includes functions for dealing with evas objects . The evas
objects must have been previously created by lua using one of the lua ezas
object creation functions from the lua edje class .
In the following , " evas_object " is a place holder for any lua variable that
holds a reference to an evas object .
2011-11-12 11:39:01 -08:00
*/
static int _elua_obj_del ( lua_State * L ) ;
static int _elua_hide ( lua_State * L ) ;
static int _elua_show ( lua_State * L ) ;
static int _elua_visible ( lua_State * L ) ;
static int _elua_above ( lua_State * L ) ;
static int _elua_below ( lua_State * L ) ;
static int _elua_bottom ( lua_State * L ) ;
static int _elua_lower ( lua_State * L ) ;
static int _elua_raise ( lua_State * L ) ;
static int _elua_top ( lua_State * L ) ;
static int _elua_geom ( lua_State * L ) ;
static int _elua_move ( lua_State * L ) ;
static int _elua_pos ( lua_State * L ) ;
static int _elua_resize ( lua_State * L ) ;
static int _elua_size ( lua_State * L ) ;
static int _elua_clip ( lua_State * L ) ;
static int _elua_clipees ( lua_State * L ) ;
static int _elua_unclip ( lua_State * L ) ;
static int _elua_type ( lua_State * L ) ;
static int _elua_pass ( lua_State * L ) ;
static int _elua_precise ( lua_State * L ) ;
static int _elua_repeat ( lua_State * L ) ;
static int _elua_color ( lua_State * L ) ;
static int _elua_obj_map ( lua_State * L ) ;
static int _elua_obj_map_enable ( lua_State * L ) ;
static int _elua_obj_map_source ( lua_State * L ) ;
static const char * _elua_evas_api = " evas " ;
static const struct luaL_reg _elua_evas_funcs [ ] =
{
// generic object methods
{ " del " , _elua_obj_del } , // generic del any object created for edje (evas objects, timers, animators, transitions... everything)
// now evas stuff (manipulate, delete etc.)
{ " hide " , _elua_hide } , // hide, return current visibility
{ " show " , _elua_show } , // show, return current visibility
{ " visible " , _elua_visible } , // get object visibility
{ " above " , _elua_above } , // get object above or stack obj above given obj
{ " below " , _elua_below } , // get object below or stack obj below given obj
{ " bottom " , _elua_bottom } , // get bottom
{ " lower " , _elua_lower } , // lower to bottom
{ " raise " , _elua_raise } , // raise to top
{ " top " , _elua_top } , // get top
{ " geom " , _elua_geom } , // move and resize and return current geometry
{ " move " , _elua_move } , // move, return current position
{ " pos " , _elua_pos } , // move, return current position
{ " resize " , _elua_resize } , // resize, return current size
{ " size " , _elua_size } , // resize, return current size
{ " clip " , _elua_clip } , // set clip obj, return clip object
{ " clipees " , _elua_clipees } , // get clip children
{ " unclip " , _elua_unclip } , // clear clip obj
{ " type " , _elua_type } , // get object type
2011-11-12 02:42:56 -08:00
2011-11-12 11:39:01 -08:00
{ " pass " , _elua_pass } , // set pass events, get pass events
{ " precise " , _elua_precise } , // set precise inside flag, get precise
{ " repeat " , _elua_repeat } , // set repeat events, get repeat events
2011-11-12 06:33:08 -08:00
2011-11-12 11:39:01 -08:00
{ " color " , _elua_color } , // set color, return color
// {"color_class", _elua_object_color_class}, // get or set object color class
2011-11-12 06:33:08 -08:00
2011-11-12 11:39:01 -08:00
// FIXME: set callbacks (mouse down, up, blah blah blah)
//
// FIXME: set scale (explicit value)
// FIXME: need to set auto-scale (same as scale: 1)
2011-11-12 02:42:56 -08:00
2011-11-12 11:39:01 -08:00
// FIXME: later - set render op, anti-alias, pointer mode (autograb, nograb)
// FIXME: later -
2011-11-12 06:33:08 -08:00
2011-11-12 11:39:01 -08:00
// map api here
{ " map " , _elua_obj_map } ,
{ " map_enable " , _elua_obj_map_enable } ,
{ " map_source " , _elua_obj_map_source } ,
2011-11-12 06:33:08 -08:00
2011-11-12 11:39:01 -08:00
{ NULL , NULL } // end
} ;
//-------------
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection evas_hide evas_object : hide ( )
*/
2011-11-12 02:42:56 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_hide ( lua_State * L ) // Stack usage [-?, +?, ?]
2010-07-09 00:52:53 -07:00
{
2010-07-12 23:17:15 -07:00
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Evas_Object * elo = ( Edje_Lua_Evas_Object * ) obj ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj , _elua_evas_meta ) ) return 0 ;
2011-11-12 02:42:56 -08:00
evas_object_hide ( elo - > evas_obj ) ;
2010-07-12 23:17:15 -07:00
lua_pushboolean ( L , evas_object_visible_get ( elo - > evas_obj ) ) ;
return 1 ;
2010-07-09 00:52:53 -07:00
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection evas_show evas_object : show ( )
*/
2010-07-09 00:52:53 -07:00
static int
2011-11-17 06:21:53 -08:00
_elua_show ( lua_State * L ) // Stack usage [-?, +?, ?]
2010-07-09 00:52:53 -07:00
{
2010-07-12 23:17:15 -07:00
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Evas_Object * elo = ( Edje_Lua_Evas_Object * ) obj ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj , _elua_evas_meta ) ) return 0 ;
2011-11-12 02:42:56 -08:00
evas_object_show ( elo - > evas_obj ) ;
2010-07-12 23:17:15 -07:00
lua_pushboolean ( L , evas_object_visible_get ( elo - > evas_obj ) ) ;
return 1 ;
2010-07-09 00:52:53 -07:00
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection evas_visible evas_object : visible ( )
*/
2010-07-09 00:52:53 -07:00
static int
2011-11-17 06:21:53 -08:00
_elua_visible ( lua_State * L ) // Stack usage [-?, +?, ?]
2010-07-09 00:52:53 -07:00
{
2010-07-12 23:17:15 -07:00
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Evas_Object * elo = ( Edje_Lua_Evas_Object * ) obj ;
int n ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj , _elua_evas_meta ) ) return 0 ;
2010-07-12 23:17:15 -07:00
n = lua_gettop ( L ) ;
if ( n = = 2 )
{
if ( lua_isboolean ( L , 2 ) )
{
if ( lua_toboolean ( L , 2 ) ) evas_object_show ( elo - > evas_obj ) ;
else evas_object_hide ( elo - > evas_obj ) ;
}
}
lua_pushboolean ( L , evas_object_visible_get ( elo - > evas_obj ) ) ;
return 1 ;
2010-07-09 00:52:53 -07:00
}
2011-11-12 02:42:56 -08:00
//-------------
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection evas_above evas_object : above ( )
*/
2010-07-09 00:52:53 -07:00
static int
2011-11-17 06:21:53 -08:00
_elua_above ( lua_State * L ) // Stack usage [-?, +?, ?]
2010-07-09 00:52:53 -07:00
{
2010-07-12 23:17:15 -07:00
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Evas_Object * elo = ( Edje_Lua_Evas_Object * ) obj ;
2011-11-12 02:42:56 -08:00
Edje_Lua_Evas_Object * elo2 ;
Evas_Object * o ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj , _elua_evas_meta ) ) return 0 ;
2011-11-12 02:42:56 -08:00
if ( ! ( o = evas_object_above_get ( elo - > evas_obj ) ) ) return 0 ;
if ( ! ( elo2 = evas_object_data_get ( o , ELO ) ) ) return 0 ;
_elua_ref_get ( L , elo2 ) ;
2010-07-12 23:17:15 -07:00
return 1 ;
2010-07-09 00:52:53 -07:00
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection evas_below evas_object : below ( )
*/
2010-07-09 00:52:53 -07:00
static int
2011-11-17 06:21:53 -08:00
_elua_below ( lua_State * L ) // Stack usage [-?, +?, ?]
2010-07-09 00:52:53 -07:00
{
2010-07-12 23:17:15 -07:00
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Evas_Object * elo = ( Edje_Lua_Evas_Object * ) obj ;
2011-11-12 02:42:56 -08:00
Edje_Lua_Evas_Object * elo2 ;
Evas_Object * o ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj , _elua_evas_meta ) ) return 0 ;
2011-11-12 02:42:56 -08:00
if ( ! ( o = evas_object_below_get ( elo - > evas_obj ) ) ) return 0 ;
if ( ! ( elo2 = evas_object_data_get ( o , ELO ) ) ) return 0 ;
_elua_ref_get ( L , elo2 ) ;
2010-07-12 23:17:15 -07:00
return 1 ;
2010-07-09 00:52:53 -07:00
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection evas_bottom evas_object : bottom ( )
*/
2010-07-09 00:52:53 -07:00
static int
2011-11-17 06:21:53 -08:00
_elua_bottom ( lua_State * L ) // Stack usage [-?, +?, ?]
2010-07-09 00:52:53 -07:00
{
2010-07-12 23:17:15 -07:00
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
2011-11-12 02:42:56 -08:00
// Edje_Lua_Evas_Object *elo = (Edje_Lua_Evas_Object *)obj;
Edje_Lua_Evas_Object * elo2 ;
Evas_Object * o ;
Eina_List * list , * l ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj , _elua_evas_meta ) ) return 0 ;
2011-11-12 02:42:56 -08:00
if ( ! ( list = ( Eina_List * ) evas_object_smart_members_get ( obj - > ed - > obj ) ) ) return 0 ;
for ( l = list ; l ; l = l - > next )
2010-07-12 23:17:15 -07:00
{
2011-11-12 02:42:56 -08:00
o = l - > data ;
if ( ( elo2 = evas_object_data_get ( o , ELO ) ) )
2010-07-12 23:17:15 -07:00
{
2011-11-12 02:42:56 -08:00
_elua_ref_get ( L , elo2 ) ;
return 1 ;
2010-07-12 23:17:15 -07:00
}
}
2011-11-12 02:42:56 -08:00
return 0 ;
2010-07-09 00:52:53 -07:00
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection evas_lower evas_object : lower ( )
*/
2010-07-09 00:52:53 -07:00
static int
2011-11-17 06:21:53 -08:00
_elua_lower ( lua_State * L ) // Stack usage [-?, +?, ?]
2010-07-09 00:52:53 -07:00
{
2010-07-12 23:47:18 -07:00
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Evas_Object * elo = ( Edje_Lua_Evas_Object * ) obj ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj , _elua_evas_meta ) ) return 0 ;
2011-11-12 02:42:56 -08:00
evas_object_lower ( elo - > evas_obj ) ;
2010-07-09 00:52:53 -07:00
return 0 ;
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection evas_raise evas_object : raise ( )
*/
2010-07-09 00:52:53 -07:00
static int
2011-11-17 06:21:53 -08:00
_elua_raise ( lua_State * L ) // Stack usage [-?, +?, ?]
2010-07-09 00:52:53 -07:00
{
2010-07-12 23:47:18 -07:00
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Evas_Object * elo = ( Edje_Lua_Evas_Object * ) obj ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj , _elua_evas_meta ) ) return 0 ;
2011-11-12 02:42:56 -08:00
evas_object_raise ( elo - > evas_obj ) ;
2010-07-09 00:52:53 -07:00
return 0 ;
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection evas_top evas_object : top ( )
*/
2010-07-09 00:52:53 -07:00
static int
2011-11-17 06:21:53 -08:00
_elua_top ( lua_State * L ) // Stack usage [-?, +?, ?]
2010-07-09 00:52:53 -07:00
{
2010-07-12 23:47:18 -07:00
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
2011-11-12 02:42:56 -08:00
// Edje_Lua_Evas_Object *elo = (Edje_Lua_Evas_Object *)obj;
2010-07-12 23:47:18 -07:00
Edje_Lua_Evas_Object * elo2 ;
Evas_Object * o ;
2011-11-12 02:42:56 -08:00
Eina_List * list , * l ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj , _elua_evas_meta ) ) return 0 ;
2011-11-12 02:42:56 -08:00
if ( ! ( list = ( Eina_List * ) evas_object_smart_members_get ( obj - > ed - > obj ) ) ) return 0 ;
if ( ! list ) return 0 ;
for ( l = eina_list_last ( list ) ; l ; l = l - > prev )
{
o = l - > data ;
if ( ( elo2 = evas_object_data_get ( o , ELO ) ) )
{
_elua_ref_get ( L , elo2 ) ;
return 1 ;
}
}
return 0 ;
2010-07-09 00:52:53 -07:00
}
2011-11-12 02:42:56 -08:00
//-------------
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection evas_geom evas_object : geom ( )
*/
2010-07-09 00:52:53 -07:00
static int
2011-11-17 06:21:53 -08:00
_elua_geom ( lua_State * L ) // Stack usage [-?, +?, ?]
2010-07-09 00:52:53 -07:00
{
2010-07-13 22:32:48 -07:00
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Evas_Object * elo = ( Edje_Lua_Evas_Object * ) obj ;
2011-11-13 09:58:11 -08:00
Evas_Coord ox , oy , ow , oh ;
2011-11-12 02:42:56 -08:00
int x , y , w , h ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj , _elua_evas_meta ) ) return 0 ;
2011-11-13 09:58:11 -08:00
evas_object_geometry_get ( elo - > evas_obj , & ox , & oy , & ow , & oh ) ;
2011-11-12 02:42:56 -08:00
if ( _elua_scan_params ( L , 2 , EINA_TRUE , " %x %y %w %h " , & x , & y , & w , & h ) > 0 )
{
2011-11-13 09:58:11 -08:00
if ( ( x ! = ( ox - obj - > ed - > x ) ) | | ( y ! = ( oy - obj - > ed - > y ) ) )
2011-11-12 02:42:56 -08:00
{
evas_object_move ( elo - > evas_obj ,
2011-11-13 09:58:11 -08:00
obj - > ed - > x + x ,
obj - > ed - > y + y ) ;
2011-11-12 02:42:56 -08:00
}
if ( ( w ! = ow ) | | ( h ! = oh ) )
{
evas_object_resize ( elo - > evas_obj , w , h ) ;
}
2011-11-13 09:58:11 -08:00
evas_object_geometry_get ( elo - > evas_obj , & ox , & oy , & ow , & oh ) ;
elo - > x = ox - obj - > ed - > x ;
elo - > y = oy - obj - > ed - > y ;
2011-11-12 02:42:56 -08:00
}
_elua_ret ( L , " %x %y %w %h " , elo - > x , elo - > y , ow , oh ) ;
2010-07-13 22:32:48 -07:00
return 1 ;
2010-07-09 00:52:53 -07:00
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection evas_move evas_object : move ( )
*/
2010-07-09 00:52:53 -07:00
static int
2011-11-17 06:21:53 -08:00
_elua_move ( lua_State * L ) // Stack usage [-?, +?, ?]
2010-07-09 00:52:53 -07:00
{
2010-07-13 22:32:48 -07:00
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
2011-11-12 02:42:56 -08:00
Edje_Lua_Evas_Object * elo = ( Edje_Lua_Evas_Object * ) obj ;
2011-11-13 09:58:11 -08:00
Evas_Coord ox , oy ;
2011-11-12 02:42:56 -08:00
int x , y ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj , _elua_evas_meta ) ) return 0 ;
2011-11-13 09:58:11 -08:00
evas_object_geometry_get ( elo - > evas_obj , & ox , & oy , NULL , NULL ) ;
2011-11-12 02:42:56 -08:00
if ( _elua_scan_params ( L , 2 , EINA_TRUE , " %x %y " , & x , & y ) > 0 )
2010-07-13 22:32:48 -07:00
{
2011-11-13 09:58:11 -08:00
if ( ( x ! = ( ox - obj - > ed - > x ) ) | | ( y ! = ( oy - obj - > ed - > y ) ) )
2010-07-13 22:32:48 -07:00
{
2011-11-12 02:42:56 -08:00
evas_object_move ( elo - > evas_obj ,
2011-11-13 09:58:11 -08:00
obj - > ed - > x + x ,
obj - > ed - > y + y ) ;
evas_object_geometry_get ( elo - > evas_obj , & ox , & oy , NULL , NULL ) ;
2010-07-13 22:32:48 -07:00
}
2011-11-13 09:58:11 -08:00
elo - > x = ox - obj - > ed - > x ;
elo - > y = oy - obj - > ed - > y ;
2010-07-13 22:32:48 -07:00
}
2011-11-12 02:42:56 -08:00
_elua_ret ( L , " %x %y " , elo - > x , elo - > y ) ;
return 1 ;
2010-07-09 00:52:53 -07:00
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection evas_pos evas_object : pos ( )
*/
2010-07-09 00:52:53 -07:00
static int
2011-11-17 06:21:53 -08:00
_elua_pos ( lua_State * L ) // Stack usage [-?, +?, ?]
2010-07-09 00:52:53 -07:00
{
2011-11-12 02:42:56 -08:00
return _elua_move ( L ) ;
2010-07-09 00:52:53 -07:00
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection evas_resize evas_object : resize ( )
*/
2010-07-09 00:52:53 -07:00
static int
2011-11-17 06:21:53 -08:00
_elua_resize ( lua_State * L ) // Stack usage [-?, +?, ?]
2010-07-09 00:52:53 -07:00
{
2010-07-12 23:17:15 -07:00
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Evas_Object * elo = ( Edje_Lua_Evas_Object * ) obj ;
2011-11-12 02:42:56 -08:00
Evas_Coord ow , oh ;
int w , h ;
2010-08-18 09:55:49 -07:00
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj , _elua_evas_meta ) ) return 0 ;
2011-11-12 02:42:56 -08:00
evas_object_geometry_get ( elo - > evas_obj , NULL , NULL , & ow , & oh ) ;
if ( _elua_scan_params ( L , 2 , EINA_TRUE , " %w %h " , & w , & h ) > 0 )
2010-07-12 23:17:15 -07:00
{
2011-11-12 02:42:56 -08:00
if ( ( w ! = ow ) | | ( h ! = oh ) )
{
evas_object_resize ( elo - > evas_obj , w , h ) ;
evas_object_geometry_get ( elo - > evas_obj , NULL , NULL , & ow , & oh ) ;
}
2010-07-12 23:17:15 -07:00
}
2011-11-12 02:42:56 -08:00
_elua_ret ( L , " %w %h " , ow , oh ) ;
2010-07-12 23:17:15 -07:00
return 1 ;
2010-07-09 00:52:53 -07:00
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection evas_size evas_object : size ( )
*/
2011-11-12 02:42:56 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_size ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-12 02:42:56 -08:00
{
return _elua_resize ( L ) ;
}
//-------------
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection evas_clip evas_object : clip ( )
*/
2010-07-09 00:52:53 -07:00
static int
2011-11-17 06:21:53 -08:00
_elua_clip ( lua_State * L ) // Stack usage [-?, +?, ?]
2010-07-09 00:52:53 -07:00
{
2010-07-14 01:07:26 -07:00
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Evas_Object * elo2 , * elo = ( Edje_Lua_Evas_Object * ) obj ;
Evas_Object * o ;
int n ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj , _elua_evas_meta ) ) return 0 ;
2010-07-14 01:07:26 -07:00
n = lua_gettop ( L ) ;
if ( n = = 2 )
{
Edje_Lua_Obj * obj2 = ( Edje_Lua_Obj * ) lua_touserdata ( L , 2 ) ;
elo2 = ( Edje_Lua_Evas_Object * ) obj2 ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj2 , _elua_evas_meta ) ) return 0 ;
2010-07-14 01:07:26 -07:00
evas_object_clip_set ( elo - > evas_obj , elo2 - > evas_obj ) ;
}
o = evas_object_clip_get ( elo - > evas_obj ) ;
if ( ! o ) return 0 ;
if ( ! ( elo2 = evas_object_data_get ( o , ELO ) ) ) return 0 ;
_elua_ref_get ( L , elo2 ) ;
return 1 ;
2010-07-09 00:52:53 -07:00
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection evas_clipees evas_object : clipees ( )
*/
2010-07-09 00:52:53 -07:00
static int
2011-11-17 06:21:53 -08:00
_elua_clipees ( lua_State * L ) // Stack usage [-?, +?, ?]
2010-07-09 00:52:53 -07:00
{
2010-07-14 01:07:26 -07:00
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Evas_Object * elo2 , * elo = ( Edje_Lua_Evas_Object * ) obj ;
Eina_List * list , * l ;
Evas_Object * o ;
int n = 0 ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj , _elua_evas_meta ) ) return 0 ;
2010-07-14 01:07:26 -07:00
list = ( Eina_List * ) evas_object_clipees_get ( elo - > evas_obj ) ;
lua_newtable ( L ) ;
EINA_LIST_FOREACH ( list , l , o )
{
if ( ! ( elo2 = evas_object_data_get ( o , ELO ) ) ) continue ;
lua_pushinteger ( L , n + 1 ) ;
_elua_ref_get ( L , elo2 ) ;
lua_settable ( L , - 3 ) ;
n + + ;
}
return 1 ;
2010-07-09 00:52:53 -07:00
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection evas_unclip evas_object : unclip ( )
*/
2011-11-12 02:42:56 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_unclip ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-12 02:42:56 -08:00
{
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Evas_Object * elo = ( Edje_Lua_Evas_Object * ) obj ;
if ( ! _elua_isa ( obj , _elua_evas_meta ) ) return 0 ;
evas_object_clip_unset ( elo - > evas_obj ) ;
return 0 ;
}
//-------------
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection evas_type evas_object : type ( )
*/
2010-07-09 00:52:53 -07:00
static int
2011-11-17 06:21:53 -08:00
_elua_type ( lua_State * L ) // Stack usage [-?, +?, ?]
2010-07-09 00:52:53 -07:00
{
2010-07-14 01:07:26 -07:00
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Evas_Object * elo = ( Edje_Lua_Evas_Object * ) obj ;
const char * t ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj , _elua_evas_meta ) ) return 0 ;
2010-07-14 01:07:26 -07:00
t = evas_object_type_get ( elo - > evas_obj ) ;
if ( ! t ) return 0 ;
lua_pushstring ( L , t ) ;
return 1 ;
2010-07-09 00:52:53 -07:00
}
2011-11-12 02:42:56 -08:00
//-------------
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection evas_pass evas_object : pass ( )
*/
2010-07-09 00:52:53 -07:00
static int
2011-11-17 06:21:53 -08:00
_elua_pass ( lua_State * L ) // Stack usage [-?, +?, ?]
2010-07-09 00:52:53 -07:00
{
2010-07-14 01:07:26 -07:00
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Evas_Object * elo = ( Edje_Lua_Evas_Object * ) obj ;
int n ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj , _elua_evas_meta ) ) return 0 ;
2010-07-14 01:07:26 -07:00
n = lua_gettop ( L ) ;
if ( n = = 2 )
{
if ( lua_isboolean ( L , 2 ) )
{
evas_object_pass_events_set ( elo - > evas_obj , lua_toboolean ( L , 2 ) ) ;
}
}
lua_pushboolean ( L , evas_object_pass_events_get ( elo - > evas_obj ) ) ;
return 1 ;
2010-07-09 00:52:53 -07:00
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection evas_precise evas_object : precise ( )
*/
2011-11-12 02:42:56 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_precise ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-12 02:42:56 -08:00
{
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Evas_Object * elo = ( Edje_Lua_Evas_Object * ) obj ;
int n ;
if ( ! _elua_isa ( obj , _elua_evas_meta ) ) return 0 ;
n = lua_gettop ( L ) ;
if ( n = = 2 )
{
evas_object_precise_is_inside_set ( elo - > evas_obj , lua_toboolean ( L , 2 ) ) ;
}
lua_pushboolean ( L , evas_object_precise_is_inside_get ( elo - > evas_obj ) ) ;
return 1 ;
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection evas_repeat evas_object : repeat ( )
*/
2010-07-09 00:52:53 -07:00
static int
2011-11-17 06:21:53 -08:00
_elua_repeat ( lua_State * L ) // Stack usage [-?, +?, ?]
2010-07-09 00:52:53 -07:00
{
2010-07-14 01:07:26 -07:00
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Evas_Object * elo = ( Edje_Lua_Evas_Object * ) obj ;
int n ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj , _elua_evas_meta ) ) return 0 ;
2010-07-14 01:07:26 -07:00
n = lua_gettop ( L ) ;
if ( n = = 2 )
{
if ( lua_isboolean ( L , 2 ) )
{
evas_object_repeat_events_set ( elo - > evas_obj , lua_toboolean ( L , 2 ) ) ;
}
}
lua_pushboolean ( L , evas_object_repeat_events_get ( elo - > evas_obj ) ) ;
return 1 ;
2010-07-09 00:52:53 -07:00
}
2011-11-12 02:42:56 -08:00
//-------------
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection evas_colour evas_object : color ( )
*/
2010-07-25 23:52:36 -07:00
static int
2011-11-17 06:21:53 -08:00
_elua_color ( lua_State * L ) // Stack usage [-?, +?, ?]
2010-07-25 23:52:36 -07:00
{
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Evas_Object * elo = ( Edje_Lua_Evas_Object * ) obj ;
2011-11-12 02:42:56 -08:00
int r , g , b , a ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj , _elua_evas_meta ) ) return 0 ;
2011-11-12 02:42:56 -08:00
if ( _elua_scan_params ( L , 2 , EINA_TRUE , " %r %g %b %a " , & r , & g , & b , & a ) > 0 )
2010-07-25 23:52:36 -07:00
{
2011-11-12 02:42:56 -08:00
_elua_color_fix ( & r , & g , & b , & a ) ;
evas_object_color_set ( elo - > evas_obj , r , g , b , a ) ;
2010-07-25 23:52:36 -07:00
}
2011-11-12 02:42:56 -08:00
evas_object_color_get ( elo - > evas_obj , & r , & g , & b , & a ) ;
_elua_ret ( L , " %r %g %b %a " , r , g , b , a ) ;
2010-07-25 23:52:36 -07:00
return 1 ;
}
2011-11-12 02:42:56 -08:00
//-------------
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection evas_map evas_object : map ( )
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
2011-11-06 06:59:44 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_obj_map ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-06 06:59:44 -08:00
{
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Evas_Object * elo = ( Edje_Lua_Evas_Object * ) obj ;
Edje_Lua_Obj * obj2 = ( Edje_Lua_Obj * ) lua_touserdata ( L , 2 ) ;
2011-11-07 02:18:31 -08:00
Edje_Lua_Map * elm = ( Edje_Lua_Map * ) obj2 ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj , _elua_evas_meta ) ) return 0 ;
if ( ! _elua_isa ( obj2 , _elua_evas_map_meta ) ) return 0 ;
2011-11-06 06:59:44 -08:00
evas_object_map_set ( elo - > evas_obj , elm - > map ) ;
2011-11-13 23:35:23 -08:00
return 0 ;
2011-11-06 06:59:44 -08:00
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection evas_map_enable evas_object : map_enable ( )
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
2011-11-06 06:59:44 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_obj_map_enable ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-06 06:59:44 -08:00
{
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Evas_Object * elo = ( Edje_Lua_Evas_Object * ) obj ;
int n ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj , _elua_evas_meta ) ) return 0 ;
2011-11-06 06:59:44 -08:00
n = lua_gettop ( L ) ;
if ( n = = 2 )
{
evas_object_map_enable_set ( elo - > evas_obj , lua_toboolean ( L , 2 ) ) ;
}
lua_pushboolean ( L , evas_object_map_enable_get ( elo - > evas_obj ) ) ;
return 1 ;
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection evas_map_source evas_object : map_source ( )
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
2011-11-06 23:02:02 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_obj_map_source ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-06 23:02:02 -08:00
{
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Evas_Object * elo = ( Edje_Lua_Evas_Object * ) obj ;
2011-11-11 08:34:14 -08:00
Evas_Object * o ;
Edje_Lua_Evas_Object * elo2 ;
2011-11-06 23:02:02 -08:00
int n ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj , _elua_evas_meta ) ) return 0 ;
2011-11-06 23:02:02 -08:00
n = lua_gettop ( L ) ;
if ( n = = 2 )
{
Edje_Lua_Obj * obj2 = ( Edje_Lua_Obj * ) lua_touserdata ( L , 2 ) ;
const Edje_Lua_Evas_Object * source = ( Edje_Lua_Evas_Object * ) obj2 ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj2 , _elua_evas_meta ) ) return 0 ;
2011-11-06 23:02:02 -08:00
evas_object_map_source_set ( elo - > evas_obj , source - > evas_obj ) ;
}
2011-11-11 08:34:14 -08:00
if ( ! ( o = evas_object_map_source_get ( elo - > evas_obj ) ) ) return 0 ;
if ( ! ( elo2 = evas_object_data_get ( o , ELO ) ) ) return 0 ;
_elua_ref_get ( L , elo2 ) ;
2011-11-06 23:02:02 -08:00
return 1 ;
}
2011-11-17 18:27:16 -08:00
//-------------
//-------------
/**
@ page luaref
@ subsection ecore_animator Ecore animator class .
The lua ecore animator class includes functions for dealing with ecore animator objects .
The ecore animator objects must have been previously created by lua using the lua
edje object creation function edje : animator ( ) or edje : transition ( ) .
In the following , " animator_object " is a place holder for any lua variable that
holds a reference to an ecore animator object .
*/
static const char * _elua_ecore_animator_api = " ecore_animator " ;
static const struct luaL_reg _elua_ecore_animator_funcs [ ] =
{
{ NULL , NULL } // end
} ;
//-------------
//-------------
/**
@ page luaref
@ subsection ecore_timer Ecore timer class .
The lua ecore timer class includes functions for dealing with ecore timer objects .
The ecore timer objects must have been previously created by lua using the lua
edje object creation function edje : timer ( ) .
In the following , " timer_object " is a place holder for any lua variable that
holds a reference to an ecore timer object .
*/
static const char * _elua_ecore_timer_api = " ecore_timer " ;
static const struct luaL_reg _elua_ecore_timer_funcs [ ] =
{
{ NULL , NULL } // end
} ;
2011-11-12 02:42:56 -08:00
//-------------
//-------------
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsection evas_edje Evas edje class .
2011-11-17 18:27:16 -08:00
The lua evas edje class includes functions for dealing with evas edje objects .
2011-11-17 06:21:53 -08:00
The evas edje objects must have been previously created by lua using the lua
edje object creation function edje : edje ( ) .
In the following , " edje_object " is a place holder for any lua variable that
holds a reference to an evas edje object . NOT the edje class specified earlier
though .
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
2011-11-12 02:42:56 -08:00
2011-11-12 11:39:01 -08:00
static int _elua_edje_file ( lua_State * L ) ;
static const char * _elua_evas_edje_api = " evas_edje " ;
static const char * _elua_evas_edje_parent = " evas_edje_parent " ;
static const struct luaL_reg _elua_evas_edje_funcs [ ] =
2011-11-06 01:00:21 -08:00
{
2011-11-12 11:39:01 -08:00
// edje object specific
{ " file " , _elua_edje_file } , // get or set edje file and group
{ NULL , NULL } // end
} ;
2011-11-06 01:00:21 -08:00
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection edje_file edje_object : file ( )
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
2011-11-06 01:00:21 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_edje_file ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-06 01:00:21 -08:00
{
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Evas_Object * elo = ( Edje_Lua_Evas_Object * ) obj ;
2011-11-12 02:42:56 -08:00
const char * file = NULL , * group = NULL ;
2011-11-13 16:13:36 -08:00
int n = lua_gettop ( L ) ;
2011-11-11 13:32:15 -08:00
2011-11-12 02:42:56 -08:00
if ( ! _elua_isa ( obj , _elua_evas_edje_meta ) ) return 0 ;
2011-11-06 01:00:21 -08:00
2011-11-13 16:13:36 -08:00
n = _elua_scan_params ( L , 2 , EINA_TRUE , " $file $group " , & file , & group ) ;
if ( 0 > = n )
{
file = ( char * ) obj - > ed - > file - > path ;
group = ( char * ) lua_tostring ( L , 2 ) ;
n = 2 ;
}
if ( 1 < n )
2011-11-12 02:42:56 -08:00
{
// Sandbox lua - Only allow access to groups within the same file.
// By the simple expedient of completely ignoring what file was requested.
2011-11-13 16:13:36 -08:00
file = ( char * ) obj - > ed - > file - > path ;
if ( ! edje_object_file_set ( elo - > evas_obj , file , group ) )
{
Edje_Load_Error err = edje_object_load_error_get ( elo - > evas_obj ) ;
switch ( err )
{
case EDJE_LOAD_ERROR_NONE : LE ( " Edje file loading errer %s %s - no error happened, but you should not see this. \n " , obj - > ed - > file - > path , group ) ; break ;
case EDJE_LOAD_ERROR_GENERIC : LE ( " Edje file loading errer %s %s - generic error. \n " , obj - > ed - > file - > path , group ) ; break ;
case EDJE_LOAD_ERROR_DOES_NOT_EXIST : LE ( " Edje file loading errer %s %s - file does not exist. \n " , obj - > ed - > file - > path , group ) ; break ;
case EDJE_LOAD_ERROR_PERMISSION_DENIED : LE ( " Edje file loading errer %s %s - permission denied reading the file. \n " , obj - > ed - > file - > path , group ) ; break ;
case EDJE_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED : LE ( " Edje file loading errer %s %s - resource allocation failed. \n " , obj - > ed - > file - > path , group ) ; break ;
case EDJE_LOAD_ERROR_CORRUPT_FILE : LE ( " Edje file loading errer %s %s - corrupt file. \n " , obj - > ed - > file - > path , group ) ; break ;
case EDJE_LOAD_ERROR_UNKNOWN_FORMAT : LE ( " Edje file loading errer %s %s - unknown file format. \n " , obj - > ed - > file - > path , group ) ; break ;
case EDJE_LOAD_ERROR_INCOMPATIBLE_FILE : LE ( " Edje file loading errer %s %s - incompatible file. \n " , obj - > ed - > file - > path , group ) ; break ;
case EDJE_LOAD_ERROR_UNKNOWN_COLLECTION : LE ( " Edje file loading errer %s %s - unknown group. \n " , obj - > ed - > file - > path , group ) ; break ;
case EDJE_LOAD_ERROR_RECURSIVE_REFERENCE : LE ( " Edje file loading errer %s %s - recursive reference in group. \n " , obj - > ed - > file - > path , group ) ; break ;
}
}
2011-11-06 01:00:21 -08:00
}
2011-11-12 02:42:56 -08:00
edje_object_file_get ( elo - > evas_obj , & file , & group ) ;
_elua_ret ( L , " $file $group " , file , group ) ;
2011-11-06 01:00:21 -08:00
return 1 ;
}
2011-11-12 02:42:56 -08:00
//-------------
//-------------
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsection evas_image Evas image class .
The lua evas image class includes functions for dealing with evas image objects .
The evas image objects must have been previously created by lua using the lua
image object creation function edje : image ( ) .
In the following , " image_object " is a place holder for any lua variable that
holds a reference to an evas image object .
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
2011-11-12 02:42:56 -08:00
2011-11-12 11:39:01 -08:00
static int _elua_image_fill ( lua_State * L ) ;
static int _elua_image_filled ( lua_State * L ) ;
static int _elua_image_image ( lua_State * L ) ;
static const char * _elua_evas_image_api = " evas_image " ;
static const char * _elua_evas_image_parent = " evas_image_parent " ;
static const struct luaL_reg _elua_evas_image_funcs [ ] =
2011-11-06 01:00:21 -08:00
{
2011-11-12 11:39:01 -08:00
// image object specific
{ " fill " , _elua_image_fill } , // get or set the fill parameters
{ " filled " , _elua_image_filled } , // get or set the filled state (overrides fill())
{ " image " , _elua_image_image } , // get or set image
{ NULL , NULL } // end
} ;
2011-11-06 01:00:21 -08:00
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection image_fill image_object : fill ( )
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
2011-11-06 01:00:21 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_image_fill ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-06 01:00:21 -08:00
{
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Evas_Object * elo = ( Edje_Lua_Evas_Object * ) obj ;
Evas_Coord x , y , w , h ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj , _elua_evas_image_meta ) ) return 0 ;
2011-11-06 01:00:21 -08:00
2011-11-11 18:23:33 -08:00
if ( _elua_scan_params ( L , 2 , EINA_TRUE , " %x %y %w %h " , & x , & y , & w , & h ) > 0 )
2011-11-06 01:00:21 -08:00
{
evas_object_image_fill_set ( elo - > evas_obj , x , y , w , h ) ;
}
evas_object_image_fill_get ( elo - > evas_obj , & x , & y , & w , & h ) ;
2011-11-11 18:23:33 -08:00
_elua_ret ( L , " %x %y %w %h " , x , y , w , h ) ;
2011-11-06 01:00:21 -08:00
return 1 ;
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection image_filled image_object : filled ( )
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
2011-11-06 01:00:21 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_image_filled ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-06 01:00:21 -08:00
{
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Evas_Object * elo = ( Edje_Lua_Evas_Object * ) obj ;
int n ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj , _elua_evas_image_meta ) ) return 0 ;
2011-11-06 01:00:21 -08:00
2011-11-12 02:42:56 -08:00
n = lua_gettop ( L ) ;
if ( n = = 2 )
{
evas_object_image_filled_set ( elo - > evas_obj , lua_toboolean ( L , 2 ) ) ;
}
lua_pushboolean ( L , evas_object_image_filled_get ( elo - > evas_obj ) ) ;
return 1 ;
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection image_image image_object : image ( )
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
2011-11-12 02:42:56 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_image_image ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-12 02:42:56 -08:00
{
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Evas_Object * elo = ( Edje_Lua_Evas_Object * ) obj ;
const char * file = NULL , * key = NULL ;
2011-11-13 09:58:11 -08:00
int n , id = - 1 ;
2011-11-12 02:42:56 -08:00
if ( ! _elua_isa ( obj , _elua_evas_image_meta ) ) return 0 ;
2011-11-13 09:58:11 -08:00
n = _elua_scan_params ( L , 2 , EINA_TRUE , " $file $key " , & file , & key ) ;
if ( 0 > = n )
2011-11-12 02:42:56 -08:00
{
file = ( char * ) obj - > ed - > file - > path ;
key = ( char * ) lua_tostring ( L , 2 ) ;
2011-11-13 09:58:11 -08:00
n = 2 ;
2011-11-12 02:42:56 -08:00
}
if ( 1 < n )
2011-11-06 01:00:21 -08:00
{
2011-11-13 09:58:11 -08:00
if ( obj - > ed - > file - > image_dir )
{
Edje_Image_Directory_Entry * de ;
unsigned int i ;
char * name ;
/* Image name */
if ( ( name = strrchr ( key , ' / ' ) ) ) name + + ;
else name = ( char * ) key ;
/* Loop through image directory to find if image exists */
for ( i = 0 ; i < obj - > ed - > file - > image_dir - > entries_count ; + + i )
{
de = obj - > ed - > file - > image_dir - > entries + i ;
if ( de - > entry )
{
if ( strcmp ( name , de - > entry ) = = 0 )
{
char buf [ 32 ] ;
id = i ;
// This is copied from _edje_image_recalc_apply()), dunno if it provides any benefit over sprintf().
/* Replace snprint("edje/images/%i") == memcpy + itoa */
# define IMAGES "edje / images / "
memcpy ( buf , IMAGES , strlen ( IMAGES ) ) ;
eina_convert_itoa ( id , buf + strlen ( IMAGES ) ) ; /* No need to check length as 2³² need only 10 characters. */
evas_object_image_file_set ( elo - > evas_obj , obj - > ed - > file - > path , buf ) ;
break ;
}
}
}
}
2011-11-13 16:13:36 -08:00
/* Sandbox lua - Only allow access to images within the same edje file. I'm not so sure we need this level of sandboxing though. So leaving it here, just in case.
2011-11-13 09:58:11 -08:00
if ( - 1 = = id )
{
2011-11-13 16:13:36 -08:00
LI ( " Image %s not found in our edje file, trying external image file %s. \n " , key , file ) ;
2011-11-13 09:58:11 -08:00
evas_object_image_file_set ( elo - > evas_obj , file , key ) ;
}
2011-11-13 16:13:36 -08:00
*/
2011-11-06 01:00:21 -08:00
}
2011-11-12 02:42:56 -08:00
evas_object_image_file_get ( elo - > evas_obj , & file , & key ) ;
_elua_ret ( L , " $file $key " , file , key ) ;
2011-11-06 01:00:21 -08:00
return 1 ;
}
2011-11-12 02:42:56 -08:00
//-------------
//-------------
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsection evas_line Evas line class .
The lua evas line class includes functions for dealing with evas line objects .
The evas line objects must have been previously created by lua using the lua
line object creation function edje : line ( ) .
In the following , " line_object " is a place holder for any lua variable that
holds a reference to an evas line object .
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
2011-11-12 02:42:56 -08:00
2011-11-12 11:39:01 -08:00
static int _elua_line_xy ( lua_State * L ) ;
static const char * _elua_evas_line_api = " evas_line " ;
static const char * _elua_evas_line_parent = " evas_line_parent " ;
static const struct luaL_reg _elua_evas_line_funcs [ ] =
2011-11-06 01:00:21 -08:00
{
2011-11-12 11:39:01 -08:00
// line object specific
{ " xy " , _elua_line_xy } , // get or set line coords
{ NULL , NULL } // end
} ;
2011-11-06 01:00:21 -08:00
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection line_xy line_object : xy ( )
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
static int _elua_line_xy ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-06 01:00:21 -08:00
{
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Evas_Object * elo = ( Edje_Lua_Evas_Object * ) obj ;
Evas_Coord x1 , y1 , x2 , y2 ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj , _elua_evas_line_meta ) ) return 0 ;
2011-11-06 01:00:21 -08:00
2011-11-11 18:23:33 -08:00
if ( _elua_scan_params ( L , 2 , EINA_TRUE , " %x1 %y1 %x2 %y2 " , & x1 , & y1 , & x2 , & y2 ) > 0 )
2011-11-06 01:00:21 -08:00
{
evas_object_line_xy_set ( elo - > evas_obj , x1 , y1 , x2 , y2 ) ;
}
evas_object_line_xy_get ( elo - > evas_obj , & x1 , & y1 , & x2 , & y2 ) ;
2011-11-11 18:23:33 -08:00
_elua_ret ( L , " %x1 %y1 %x2 %y2 " , x1 , y1 , x2 , y2 ) ;
2011-11-06 01:00:21 -08:00
return 1 ;
}
2011-11-12 02:42:56 -08:00
//-------------
//-------------
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsection evas_object_map Evas map class .
The lua evas map class includes functions for dealing with evas map objects .
The evas map objects must have been previously created by lua using the lua
map object creation function edje : map ( ) .
In the following , " map_object " is a place holder for any lua variable that
holds a reference to an evas map object .
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
2011-11-06 01:00:21 -08:00
2011-11-12 11:39:01 -08:00
static int _elua_map_alpha ( lua_State * L ) ;
static int _elua_map_clockwise ( lua_State * L ) ;
static int _elua_map_colour ( lua_State * L ) ;
static int _elua_map_coord ( lua_State * L ) ;
static int _elua_map_lighting ( lua_State * L ) ;
static int _elua_map_perspective ( lua_State * L ) ;
static int _elua_map_populate ( lua_State * L ) ;
static int _elua_map_rotate ( lua_State * L ) ;
static int _elua_map_rotate3d ( lua_State * L ) ;
static int _elua_map_smooth ( lua_State * L ) ;
static int _elua_map_uv ( lua_State * L ) ;
static int _elua_map_zoom ( lua_State * L ) ;
2011-11-06 01:00:21 -08:00
2011-11-12 11:39:01 -08:00
static const char * _elua_evas_map_api = " ewas_map " ;
static const struct luaL_reg _elua_evas_map_funcs [ ] =
2011-11-06 01:00:21 -08:00
{
2011-11-12 11:39:01 -08:00
{ " alpha " , _elua_map_alpha } ,
// {"dup", _elua_map_dup}, // not sure of proper api for this.
{ " clockwise " , _elua_map_clockwise } ,
{ " color " , _elua_map_colour } ,
{ " coord " , _elua_map_coord } ,
{ " lighting " , _elua_map_lighting } ,
{ " perspective " , _elua_map_perspective } ,
{ " populate " , _elua_map_populate } ,
{ " rotate " , _elua_map_rotate } ,
{ " rotate3d " , _elua_map_rotate3d } ,
// {"size", _elua_map_size}, // not sure of proper API for this
{ " smooth " , _elua_map_smooth } ,
{ " uv " , _elua_map_uv } ,
{ " zoom " , _elua_map_zoom } ,
2011-11-12 02:42:56 -08:00
2011-11-12 11:39:01 -08:00
{ NULL , NULL } // end
} ;
2011-11-06 01:00:21 -08:00
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection map_alpha map_object : alpha ( )
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
2011-11-06 23:02:02 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_map_alpha ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-06 23:02:02 -08:00
{
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Map * elm = ( Edje_Lua_Map * ) obj ;
int n ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj , _elua_evas_map_meta ) ) return 0 ;
2011-11-06 23:02:02 -08:00
n = lua_gettop ( L ) ;
if ( n = = 2 )
{
evas_map_alpha_set ( elm - > map , lua_toboolean ( L , 2 ) ) ;
}
lua_pushboolean ( L , evas_map_alpha_get ( elm - > map ) ) ;
return 1 ;
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection map_clockwise map_object : clockwise ( )
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
2011-11-06 23:02:02 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_map_clockwise ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-06 23:02:02 -08:00
{
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Map * elm = ( Edje_Lua_Map * ) obj ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj , _elua_evas_map_meta ) ) return 0 ;
2011-11-06 23:02:02 -08:00
lua_pushboolean ( L , evas_map_util_clockwise_get ( elm - > map ) ) ;
return 1 ;
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection map_colour map_object : colour ( )
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
2011-11-06 23:02:02 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_map_colour ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-06 23:02:02 -08:00
{
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Map * elm = ( Edje_Lua_Map * ) obj ;
int r , g , b , a ;
int n ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj , _elua_evas_map_meta ) ) return 0 ;
2011-11-06 23:02:02 -08:00
n = lua_gettop ( L ) ;
switch ( n )
{
case 5 :
{
2011-11-11 18:23:33 -08:00
if ( _elua_scan_params ( L , 2 , EINA_FALSE , " %r %g %b %a " , & r , & g , & b , & a ) > 0 )
2011-11-06 23:02:02 -08:00
{
evas_map_util_points_color_set ( elm - > map , r , g , b , a ) ;
}
break ;
}
case 1 :
case 6 :
{
2011-11-11 18:23:33 -08:00
if ( _elua_scan_params ( L , 3 , EINA_TRUE , " %r %g %b %a " , & r , & g , & b , & a ) > 0 )
2011-11-06 23:02:02 -08:00
{
evas_map_point_color_set ( elm - > map , lua_tointeger ( L , 2 ) , r , g , b , a ) ;
}
evas_map_point_color_get ( elm - > map , lua_tointeger ( L , 2 ) , & r , & g , & b , & a ) ;
2011-11-11 18:23:33 -08:00
_elua_ret ( L , " %r %g %b %a " , r , g , b , a ) ;
2011-11-13 23:35:23 -08:00
return 1 ;
2011-11-06 23:02:02 -08:00
}
}
2011-11-13 23:35:23 -08:00
return 0 ;
2011-11-06 23:02:02 -08:00
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection map_coord map_object : coord ( )
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
2011-11-06 06:59:44 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_map_coord ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-06 06:59:44 -08:00
{
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Map * elm = ( Edje_Lua_Map * ) obj ;
Evas_Coord x , y , z ;
int n ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj , _elua_evas_map_meta ) ) return 0 ;
2011-11-06 06:59:44 -08:00
n = lua_gettop ( L ) ;
if ( 2 > n ) return 0 ;
2011-11-11 18:23:33 -08:00
if ( _elua_scan_params ( L , 2 , EINA_TRUE , " %x %y %z " , & x , & y , & z ) > 0 )
2011-11-06 06:59:44 -08:00
{
2011-11-07 00:55:03 -08:00
evas_map_point_coord_set ( elm - > map , lua_tointeger ( L , 2 ) , x , y , z ) ;
2011-11-06 06:59:44 -08:00
}
2011-11-07 00:55:03 -08:00
evas_map_point_coord_get ( elm - > map , lua_tointeger ( L , 2 ) , & x , & y , & z ) ;
2011-11-11 18:23:33 -08:00
_elua_ret ( L , " %x %y %z " , x , y , z ) ;
2011-11-06 06:59:44 -08:00
return 1 ;
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection map_lighting map_object : lighting ( )
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
2011-11-06 23:02:02 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_map_lighting ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-06 23:02:02 -08:00
{
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Map * elm = ( Edje_Lua_Map * ) obj ;
Evas_Coord x , y , z ;
int r , g , b , r1 , g1 , b1 ;
int n ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj , _elua_evas_map_meta ) ) return 0 ;
2011-11-06 23:02:02 -08:00
2011-11-13 20:47:44 -08:00
if ( ( n = _elua_scan_params ( L , 2 , EINA_FALSE , " %x %y %z " , & x , & y , & z ) ) > 0 )
2011-11-11 18:23:33 -08:00
if ( n + = _elua_scan_params ( L , 2 + n , EINA_FALSE , " %r %g %b " , & r , & g , & b ) > 0 )
if ( _elua_scan_params ( L , 2 + n , EINA_FALSE , " %r %g %b " , & r1 , & g1 , & b1 ) > 0 )
2011-11-06 23:02:02 -08:00
{
evas_map_util_3d_lighting ( elm - > map , x , y , z , r , g , b , r1 , g1 , b1 ) ;
}
return 0 ;
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection map_perspective map_object : perspective ( )
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
2011-11-06 23:02:02 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_map_perspective ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-06 23:02:02 -08:00
{
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Map * elm = ( Edje_Lua_Map * ) obj ;
Evas_Coord x , y , z , f ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj , _elua_evas_map_meta ) ) return 0 ;
2011-11-06 23:02:02 -08:00
2011-11-11 18:23:33 -08:00
if ( _elua_scan_params ( L , 2 , EINA_FALSE , " %x %y %z %f " , & x , & y , & z , & f ) > 0 )
2011-11-06 23:02:02 -08:00
{
evas_map_util_3d_perspective ( elm - > map , x , y , z , f ) ;
}
return 0 ;
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection map_populate map_object : populate ( )
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
2011-11-06 06:59:44 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_map_populate ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-06 06:59:44 -08:00
{
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Map * elm = ( Edje_Lua_Map * ) obj ;
int n ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj , _elua_evas_map_meta ) ) return 0 ;
2011-11-06 06:59:44 -08:00
n = lua_gettop ( L ) ;
switch ( n )
{
case 2 :
{
Edje_Lua_Obj * obj2 = ( Edje_Lua_Obj * ) lua_touserdata ( L , 2 ) ;
const Edje_Lua_Evas_Object * source = ( Edje_Lua_Evas_Object * ) obj2 ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj2 , _elua_evas_meta ) ) return 0 ;
2011-11-06 06:59:44 -08:00
evas_map_util_points_populate_from_object ( elm - > map , source - > evas_obj ) ;
break ;
}
case 3 :
{
Edje_Lua_Obj * obj2 = ( Edje_Lua_Obj * ) lua_touserdata ( L , 2 ) ;
const Edje_Lua_Evas_Object * source = ( Edje_Lua_Evas_Object * ) obj2 ;
Evas_Coord z = lua_tointeger ( L , 3 ) ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj2 , _elua_evas_meta ) ) return 0 ;
2011-11-06 06:59:44 -08:00
evas_map_util_points_populate_from_object_full ( elm - > map , source - > evas_obj , z ) ;
break ;
}
2011-11-10 08:59:21 -08:00
case 6 :
2011-11-06 06:59:44 -08:00
{
2011-11-10 08:59:21 -08:00
Evas_Coord x , y , w , h ;
2011-11-13 20:47:44 -08:00
if ( ( n = _elua_scan_params ( L , 2 , EINA_FALSE , " %x %y %w %h " , & x , & y , & w , & h ) ) > 0 )
2011-11-10 08:59:21 -08:00
{
evas_map_util_points_populate_from_geometry ( elm - > map , x , y , w , h , lua_tointeger ( L , 2 + n ) ) ;
}
2011-11-06 06:59:44 -08:00
break ;
}
}
2011-11-13 23:35:23 -08:00
return 0 ;
2011-11-06 06:59:44 -08:00
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection map_rotate map_object : rotate ( )
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
2011-11-06 06:59:44 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_map_rotate ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-06 06:59:44 -08:00
{
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Map * elm = ( Edje_Lua_Map * ) obj ;
double degrees ;
Evas_Coord x , y ;
int n ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj , _elua_evas_map_meta ) ) return 0 ;
2011-11-06 06:59:44 -08:00
n = lua_gettop ( L ) ;
if ( 4 ! = n ) return 0 ;
degrees = lua_tonumber ( L , 2 ) ;
2011-11-11 18:23:33 -08:00
if ( _elua_scan_params ( L , 3 , EINA_TRUE , " %x %y " , & x , & y ) > 0 )
2011-11-06 06:59:44 -08:00
{
evas_map_util_rotate ( elm - > map , degrees , x , y ) ;
}
2011-11-13 23:35:23 -08:00
return 0 ;
2011-11-06 06:59:44 -08:00
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection map_rotate3d map_object : rotate3d ( )
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
2011-11-06 23:02:02 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_map_rotate3d ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-06 23:02:02 -08:00
{
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Map * elm = ( Edje_Lua_Map * ) obj ;
double zx , zy , zz ;
Evas_Coord x , y , z ;
int n ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj , _elua_evas_map_meta ) ) return 0 ;
2011-11-06 23:02:02 -08:00
2011-11-13 20:47:44 -08:00
if ( ( n = _elua_scan_params ( L , 2 , EINA_FALSE , " #x #y #z " , & zx , & zy , & zz ) ) > 0 )
2011-11-11 18:23:33 -08:00
if ( _elua_scan_params ( L , 2 + n , EINA_FALSE , " %x %y %z " , & x , & y , & z ) > 0 )
2011-11-06 23:02:02 -08:00
{
evas_map_util_3d_rotate ( elm - > map , zx , zy , zz , x , y , z ) ;
}
return 0 ;
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection map_smooth map_object : smooth ( )
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
2011-11-06 23:02:02 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_map_smooth ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-06 23:02:02 -08:00
{
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Map * elm = ( Edje_Lua_Map * ) obj ;
int n ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj , _elua_evas_map_meta ) ) return 0 ;
2011-11-06 23:02:02 -08:00
n = lua_gettop ( L ) ;
if ( n = = 2 )
{
evas_map_smooth_set ( elm - > map , lua_toboolean ( L , 2 ) ) ;
}
lua_pushboolean ( L , evas_map_smooth_get ( elm - > map ) ) ;
return 1 ;
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection map_uv map_object : uv ( )
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
2011-11-06 23:02:02 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_map_uv ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-06 23:02:02 -08:00
{
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Map * elm = ( Edje_Lua_Map * ) obj ;
double u , v ;
int n ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj , _elua_evas_map_meta ) ) return 0 ;
2011-11-06 23:02:02 -08:00
n = lua_gettop ( L ) ;
if ( 2 > n ) return 0 ;
2011-11-11 18:23:33 -08:00
if ( _elua_scan_params ( L , 3 , EINA_TRUE , " #u #v " , & u , & v ) > 0 )
2011-11-06 23:02:02 -08:00
{
evas_map_point_image_uv_set ( elm - > map , lua_tonumber ( L , 2 ) , u , v ) ;
}
evas_map_point_image_uv_get ( elm - > map , lua_tonumber ( L , 2 ) , & u , & v ) ;
2011-11-11 18:23:33 -08:00
_elua_ret ( L , " #u #v " , u , v ) ;
2011-11-06 23:02:02 -08:00
return 1 ;
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection map_zoom map_object : zoom ( )
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
2011-11-06 23:02:02 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_map_zoom ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-06 23:02:02 -08:00
{
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Map * elm = ( Edje_Lua_Map * ) obj ;
double zx , zy ;
Evas_Coord x , y ;
int n ;
2011-11-11 13:32:15 -08:00
if ( ! _elua_isa ( obj , _elua_evas_map_meta ) ) return 0 ;
2011-11-06 23:02:02 -08:00
2011-11-13 20:47:44 -08:00
if ( ( n = _elua_scan_params ( L , 2 , EINA_FALSE , " #x #y " , & zx , & zy ) ) > 0 )
2011-11-11 18:23:33 -08:00
if ( _elua_scan_params ( L , 2 + n , EINA_FALSE , " %x %y " , & x , & y ) > 0 )
2011-11-06 23:02:02 -08:00
{
evas_map_util_zoom ( elm - > map , zx , zy , x , y ) ;
}
return 0 ;
}
2010-07-09 00:52:53 -07:00
//-------------
2011-11-12 02:42:56 -08:00
//-------------
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsection evas_polygon Evas polygon class .
The lua evas polygon class includes functions for dealing with evas polygon objects .
The evas polygon objects must have been previously created by lua using the lua
polygon object creation function edje : polygon ( ) .
In the following , " polygon_object " is a place holder for any lua variable that
holds a reference to an evas polygon object .
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
2010-07-12 23:17:15 -07:00
2011-11-12 11:39:01 -08:00
static int _elua_polygon_clear ( lua_State * L ) ;
static int _elua_polygon_point ( lua_State * L ) ;
static const char * _elua_evas_polygon_api = " evas_polygon " ;
static const char * _elua_evas_polygon_parent = " evas_polygon_parent " ;
static const struct luaL_reg _elua_evas_polygon_funcs [ ] =
2011-11-11 20:11:25 -08:00
{
2011-11-12 11:39:01 -08:00
// polygon object specific
{ " clear " , _elua_polygon_clear } , // clear all polygon points
{ " point " , _elua_polygon_point } , // add a polygon point
{ NULL , NULL } // end
} ;
2011-11-11 20:11:25 -08:00
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection polygon_clear polygon_object : clear ( )
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
static int
_elua_polygon_clear ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-11 20:11:25 -08:00
{
2011-11-12 02:42:56 -08:00
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Evas_Object * elo = ( Edje_Lua_Evas_Object * ) obj ;
if ( ! _elua_isa ( obj , _elua_evas_polygon_meta ) ) return 0 ;
evas_object_polygon_points_clear ( elo - > evas_obj ) ;
2011-11-13 23:35:23 -08:00
return 0 ;
2010-07-09 00:52:53 -07:00
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection polygon_point polygon_object : point ( )
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
static int
_elua_polygon_point ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-06 01:00:21 -08:00
{
2011-11-12 02:42:56 -08:00
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Evas_Object * elo = ( Edje_Lua_Evas_Object * ) obj ;
Evas_Coord x , y ;
if ( ! _elua_isa ( obj , _elua_evas_polygon_meta ) ) return 0 ;
if ( _elua_scan_params ( L , 2 , EINA_FALSE , " %x %y " , & x , & y ) > 0 )
{
evas_object_polygon_point_add ( elo - > evas_obj , x , y ) ;
}
2011-11-13 23:35:23 -08:00
return 0 ;
2011-11-06 01:00:21 -08:00
}
2011-11-12 02:42:56 -08:00
//-------------
//-------------
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsection evas_text Evas text class .
The lua evas text class includes functions for dealing with evas text objects .
The evas text objects must have been previously created by lua using the lua
text object creation function edje : text ( ) .
In the following , " text_object " is a place holder for any lua variable that
holds a reference to an evas text object .
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
2011-11-12 02:42:56 -08:00
2011-11-12 11:39:01 -08:00
static int _elua_text_font ( lua_State * L ) ;
static int _elua_text_text ( lua_State * L ) ;
static const char * _elua_evas_text_api = " evas_text " ;
static const char * _elua_evas_text_parent = " evas_text_parent " ;
static const struct luaL_reg _elua_evas_text_funcs [ ] =
2011-11-06 01:00:21 -08:00
{
2011-11-12 11:39:01 -08:00
// text object specific
{ " font " , _elua_text_font } , // get or set text font
{ " text " , _elua_text_text } , // get or set text
// {"text_class", _elua_object_text_class}, // get or set object text class
{ NULL , NULL } // end
} ;
2011-11-06 01:00:21 -08:00
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection text_font text_object : font ( )
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
2011-11-06 01:00:21 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_text_font ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-06 01:00:21 -08:00
{
2011-11-12 02:42:56 -08:00
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Evas_Object * elo = ( Edje_Lua_Evas_Object * ) obj ;
char * font , * font2 = NULL ;
Evas_Font_Size size ;
int inlined_font = 0 ;
2011-11-06 01:00:21 -08:00
2011-11-12 02:42:56 -08:00
if ( ! _elua_isa ( obj , _elua_evas_text_meta ) ) return 0 ;
if ( _elua_scan_params ( L , 2 , EINA_TRUE , " $font %size " , & font , & size ) > 0 )
{
/* Check if the font is embedded in the .edj
* This is a simple check .
* There is a much more complicated version in edje_text . c _edje_text_recalc_apply ( ) .
* If we need to get more complicated , we can do that later ,
* and maybe refactor things .
*/
if ( obj - > ed - > file - > fonts )
{
Edje_Font_Directory_Entry * fnt = eina_hash_find ( obj - > ed - > file - > fonts , font ) ;
if ( fnt )
{
size_t len = strlen ( font ) + sizeof ( " edje/fonts/ " ) + 1 ;
font2 = alloca ( len ) ;
sprintf ( font2 , " edje/fonts/%s " , font ) ;
font = font2 ;
inlined_font = 1 ;
font2 = NULL ;
}
}
if ( inlined_font ) evas_object_text_font_source_set ( elo - > evas_obj , obj - > ed - > path ) ;
else evas_object_text_font_source_set ( elo - > evas_obj , NULL ) ;
evas_object_text_font_set ( elo - > evas_obj , font , size ) ;
}
// When one external API says it's gotta be const, and another one says not, then one of them's gotta be cast. :-P
evas_object_text_font_get ( elo - > evas_obj , ( const char * * ) & font , & size ) ;
_elua_ret ( L , " $font %size " , font , size ) ;
2011-11-06 01:00:21 -08:00
return 1 ;
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ subsubsection text_text text_object : text ( )
2011-11-17 09:42:29 -08:00
@ since 1.1 .0
2011-11-17 06:21:53 -08:00
*/
2011-11-06 01:00:21 -08:00
static int
2011-11-17 06:21:53 -08:00
_elua_text_text ( lua_State * L ) // Stack usage [-?, +?, ?]
2011-11-06 01:00:21 -08:00
{
2011-11-12 02:42:56 -08:00
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) lua_touserdata ( L , 1 ) ;
Edje_Lua_Evas_Object * elo = ( Edje_Lua_Evas_Object * ) obj ;
int n ;
if ( ! _elua_isa ( obj , _elua_evas_text_meta ) ) return 0 ;
n = lua_gettop ( L ) ;
if ( n = = 2 )
{
if ( lua_isstring ( L , 2 ) )
{
const char * str ;
2011-11-13 20:47:44 -08:00
if ( ( str = lua_tostring ( L , 2 ) ) ) // Extra parenthesis, coz Mikes compiler has a lisp.
2011-11-12 02:42:56 -08:00
evas_object_text_text_set ( elo - > evas_obj , str ) ;
}
}
lua_pushstring ( L , evas_object_text_text_get ( elo - > evas_obj ) ) ;
2011-11-06 01:00:21 -08:00
return 1 ;
}
2011-11-12 02:42:56 -08:00
2011-11-12 11:39:01 -08:00
//--------------------------------------------------------------------------//
// Brain dead inheritance thingy, built for speed. Kinda. Part 1.
static void
2011-11-17 09:42:29 -08:00
_elua_add_functions ( lua_State * L , const char * api , const luaL_Reg * funcs , const char * meta , const char * parent , const char * base ) // Stack usage [-?, +?, ?]
2011-11-06 01:00:21 -08:00
{
2011-11-12 11:39:01 -08:00
luaL_register ( L , api , funcs ) ;
luaL_newmetatable ( L , meta ) ;
luaL_register ( L , 0 , _elua_edje_gc_funcs ) ;
lua_pushliteral ( L , " __index " ) ;
lua_pushvalue ( L , - 3 ) ;
lua_rawset ( L , - 3 ) ;
if ( base & & parent )
{
// Inherit from base
lua_getglobal ( L , base ) ;
luaL_newmetatable ( L , parent ) ;
lua_pushliteral ( L , " __index " ) ;
lua_pushvalue ( L , - 3 ) ;
lua_rawset ( L , - 3 ) ;
lua_getglobal ( L , api ) ;
luaL_getmetatable ( L , parent ) ;
lua_setmetatable ( L , - 2 ) ;
}
}
// Brain dead inheritance thingy, built for speed. Kinda. Part 2.
static Eina_Bool
_elua_isa ( Edje_Lua_Obj * obj , const char * type )
{
Eina_Bool isa = EINA_FALSE ;
if ( ! obj ) return isa ;
if ( obj - > meta = = type )
isa = EINA_TRUE ;
if ( _elua_evas_meta = = type )
{
if ( obj - > meta = = _elua_evas_image_meta )
isa = EINA_TRUE ;
else if ( obj - > meta = = _elua_evas_text_meta )
isa = EINA_TRUE ;
else if ( obj - > meta = = _elua_evas_edje_meta )
isa = EINA_TRUE ;
else if ( obj - > meta = = _elua_evas_line_meta )
isa = EINA_TRUE ;
else if ( obj - > meta = = _elua_evas_polygon_meta )
isa = EINA_TRUE ;
}
return isa ;
2011-11-06 01:00:21 -08:00
}
2011-11-18 01:52:58 -08:00
# ifndef RASTER_FORGOT_WHY
2011-11-06 06:59:44 -08:00
static void
2011-11-17 09:42:29 -08:00
_elua_init ( void ) // Stack usage [-?, +?, ?]
2011-11-06 06:59:44 -08:00
{
2011-11-12 02:42:56 -08:00
static Edje_Lua_Alloc ela = { MAX_LUA_MEM , 0 } ;
const luaL_Reg * l ;
lua_State * L ;
2011-11-06 06:59:44 -08:00
2011-11-12 02:42:56 -08:00
if ( lstate ) return ;
lstate = L = lua_newstate ( _elua_alloc , & ela ) ;
lua_atpanic ( L , _elua_custom_panic ) ;
// FIXME: figure out optimal gc settings later
// lua_gc(L, LUA_GCSETPAUSE, 200);
// lua_gc(L, LUA_GCSETSTEPMUL, 200);
for ( l = _elua_libs ; l - > func ; l + + )
{
lua_pushcfunction ( L , l - > func ) ;
lua_pushstring ( L , l - > name ) ;
lua_call ( L , 1 , 0 ) ;
}
luaL_register ( L , _elua_edje_api , _elua_edje_funcs ) ;
luaL_newmetatable ( L , _elua_edje_meta ) ;
luaL_register ( L , 0 , _elua_edje_gc_funcs ) ;
2011-11-06 06:59:44 -08:00
2011-11-12 02:42:56 -08:00
_elua_add_functions ( L , _elua_evas_api , _elua_evas_funcs , _elua_evas_meta , NULL , NULL ) ;
2011-11-06 06:59:44 -08:00
2011-11-12 02:42:56 -08:00
// weak table for our objects
lua_pushlightuserdata ( L , & _elua_objs ) ;
lua_newtable ( L ) ;
lua_pushstring ( L , " __mode " ) ;
lua_pushstring ( L , " v " ) ;
lua_rawset ( L , - 3 ) ;
lua_rawset ( L , LUA_REGISTRYINDEX ) ;
2011-11-06 06:59:44 -08:00
}
2011-11-18 01:52:58 -08:00
# endif
2011-11-06 06:59:44 -08:00
2010-04-06 04:26:32 -07:00
void
2011-11-17 09:42:29 -08:00
_edje_lua2_script_init ( Edje * ed ) // Stack usage [-?, +?, ?]
2010-04-06 04:26:32 -07:00
{
2010-07-06 02:35:34 -07:00
static Edje_Lua_Alloc ela = { MAX_LUA_MEM , 0 } ;
const luaL_Reg * l ;
char buf [ 256 ] ;
void * data ;
int size ;
2010-07-13 22:32:48 -07:00
lua_State * L ;
2011-11-06 01:00:21 -08:00
2010-04-06 04:26:32 -07:00
if ( ed - > L ) return ;
2011-11-13 16:13:36 -08:00
if ( 0 > _log_domain )
_log_domain = eina_log_domain_register ( " lua " , NULL ) ;
if ( 0 < = _log_domain )
{
_log_count + + ;
// FIXME: Change this to WARN before release.
eina_log_domain_level_set ( " lua " , EINA_LOG_LEVEL_INFO ) ;
}
2011-11-18 01:52:58 -08:00
# ifndef RASTER_FORGOT_WHY
2010-04-06 04:26:32 -07:00
_elua_init ( ) ;
2011-11-18 01:52:58 -08:00
# endif
2010-07-13 22:32:48 -07:00
L = ed - > L = lua_newstate ( _elua_alloc , & ela ) ;
lua_atpanic ( L , _elua_custom_panic ) ;
2010-07-06 02:35:34 -07:00
2011-11-06 01:00:21 -08:00
// FIXME: figure out optimal gc settings later
2010-07-13 22:32:48 -07:00
// lua_gc(L, LUA_GCSETPAUSE, 200);
// lua_gc(L, LUA_GCSETSTEPMUL, 200);
2010-07-06 02:35:34 -07:00
for ( l = _elua_libs ; l - > func ; l + + )
{
2010-07-13 22:32:48 -07:00
lua_pushcfunction ( L , l - > func ) ;
lua_pushstring ( L , l - > name ) ;
lua_call ( L , 1 , 0 ) ;
2010-07-06 02:35:34 -07:00
}
2011-11-06 01:00:21 -08:00
2011-11-11 13:32:15 -08:00
luaL_register ( L , _elua_edje_api , _elua_edje_funcs ) ;
luaL_newmetatable ( L , _elua_edje_meta ) ;
luaL_register ( L , 0 , _elua_edje_gc_funcs ) ;
2010-07-13 22:32:48 -07:00
lua_pop ( L , 2 ) ;
2011-11-11 20:11:25 -08:00
_elua_add_functions ( L , _elua_evas_api , _elua_evas_funcs , _elua_evas_meta , NULL , NULL ) ;
2011-11-17 18:27:16 -08:00
_elua_add_functions ( L , _elua_ecore_timer_api , _elua_ecore_timer_funcs , _elua_ecore_timer_meta , NULL , NULL ) ;
_elua_add_functions ( L , _elua_ecore_animator_api , _elua_ecore_animator_funcs , _elua_ecore_animator_meta , NULL , NULL ) ;
2011-11-11 20:11:25 -08:00
_elua_add_functions ( L , _elua_evas_edje_api , _elua_evas_edje_funcs , _elua_evas_edje_meta , _elua_evas_edje_parent , _elua_evas_api ) ;
_elua_add_functions ( L , _elua_evas_image_api , _elua_evas_image_funcs , _elua_evas_image_meta , _elua_evas_image_parent , _elua_evas_api ) ;
_elua_add_functions ( L , _elua_evas_line_api , _elua_evas_line_funcs , _elua_evas_line_meta , _elua_evas_line_parent , _elua_evas_api ) ;
_elua_add_functions ( L , _elua_evas_map_api , _elua_evas_map_funcs , _elua_evas_map_meta , NULL , NULL ) ;
_elua_add_functions ( L , _elua_evas_polygon_api , _elua_evas_polygon_funcs , _elua_evas_polygon_meta , _elua_evas_polygon_parent , _elua_evas_api ) ;
_elua_add_functions ( L , _elua_evas_text_api , _elua_evas_text_funcs , _elua_evas_text_meta , _elua_evas_text_parent , _elua_evas_api ) ;
2011-11-06 06:59:44 -08:00
2010-07-13 22:32:48 -07:00
// weak table for our objects
lua_pushlightuserdata ( L , & _elua_objs ) ;
lua_newtable ( L ) ;
lua_pushstring ( L , " __mode " ) ;
lua_pushstring ( L , " v " ) ;
lua_rawset ( L , - 3 ) ;
lua_rawset ( L , LUA_REGISTRYINDEX ) ;
2011-11-06 01:00:21 -08:00
2010-07-13 22:32:48 -07:00
_elua_table_ptr_set ( L , _elua_key , ed ) ;
2011-11-06 01:00:21 -08:00
2010-08-24 18:09:44 -07:00
snprintf ( buf , sizeof ( buf ) , " edje/scripts/lua/%i " , ed - > collection - > id ) ;
2010-07-06 02:35:34 -07:00
data = eet_read ( ed - > file - > ef , buf , & size ) ;
2011-11-06 01:00:21 -08:00
2010-07-06 02:35:34 -07:00
if ( data )
{
int err ;
2011-11-06 01:00:21 -08:00
2010-07-13 22:32:48 -07:00
err = luaL_loadbuffer ( L , data , size , " edje_lua_script " ) ;
2010-07-06 02:35:34 -07:00
if ( err )
{
if ( err = = LUA_ERRSYNTAX )
2011-11-13 16:13:36 -08:00
ERR ( " Lua load syntax error: %s " ,
2010-07-13 22:32:48 -07:00
lua_tostring ( L , - 1 ) ) ;
2010-07-06 02:35:34 -07:00
else if ( err = = LUA_ERRMEM )
2011-11-13 16:13:36 -08:00
ERR ( " Lua load memory allocation error: %s " ,
2010-07-13 22:32:48 -07:00
lua_tostring ( L , - 1 ) ) ;
2010-07-06 02:35:34 -07:00
}
free ( data ) ;
2010-07-06 20:24:05 -07:00
if ( setjmp ( panic_jmp ) = = 1 )
{
2011-11-13 16:13:36 -08:00
ERR ( " Lua script init panic " ) ;
2010-07-06 20:24:05 -07:00
return ;
}
2010-07-13 22:32:48 -07:00
if ( ( err = lua_pcall ( L , 0 , 0 , 0 ) ) )
_edje_lua2_error ( L , err ) ;
2010-07-06 02:35:34 -07:00
}
2010-04-06 04:26:32 -07:00
}
void
_edje_lua2_script_shutdown ( Edje * ed )
{
if ( ! ed - > L ) return ;
2010-07-06 02:35:34 -07:00
lua_close ( ed - > L ) ;
ed - > L = NULL ;
2010-04-06 04:26:32 -07:00
while ( ed - > lua_objs )
{
Edje_Lua_Obj * obj = ( Edje_Lua_Obj * ) ed - > lua_objs ;
if ( obj - > free_func )
{
ERR ( " uncollected Lua object %p " , obj ) ;
2010-07-06 02:35:34 -07:00
ed - > lua_objs = eina_inlist_remove ( ed - > lua_objs , ed - > lua_objs ) ;
2010-04-06 04:26:32 -07:00
}
else
{
ERR ( " dangling Lua object %p " , obj ) ;
ed - > lua_objs = eina_inlist_remove ( ed - > lua_objs , ed - > lua_objs ) ;
}
}
2011-11-13 16:13:36 -08:00
if ( 0 < = _log_domain )
{
_log_count - - ;
if ( 0 > = _log_count )
{
eina_log_domain_unregister ( _log_domain ) ;
_log_domain = - 1 ;
}
}
2010-04-06 04:26:32 -07:00
}
void
2010-08-19 07:57:23 -07:00
_edje_lua2_script_load ( Edje_Part_Collection * edc __UNUSED__ , void * data __UNUSED__ , int size __UNUSED__ )
2010-04-06 04:26:32 -07:00
{
2011-11-18 01:52:58 -08:00
# ifndef RASTER_FORGOT_WHY
2010-04-06 04:26:32 -07:00
_elua_init ( ) ;
2011-11-18 01:52:58 -08:00
# endif
2010-04-06 04:26:32 -07:00
}
void
2011-11-17 09:42:29 -08:00
_edje_lua2_script_unload ( Edje_Part_Collection * edc __UNUSED__ ) // Stack usage [-?, +?, ?]
2010-04-06 04:26:32 -07:00
{
2011-11-18 01:52:58 -08:00
# ifndef RASTER_FORGOT_WHY
2010-07-06 02:35:34 -07:00
lua_State * L ;
2010-08-19 07:57:23 -07:00
2010-07-06 02:35:34 -07:00
if ( ! lstate ) return ;
L = lstate ;
lua_gc ( L , LUA_GCCOLLECT , 0 ) ;
2011-11-18 01:52:58 -08:00
# endif
2010-04-06 04:26:32 -07:00
}
2011-11-12 02:42:56 -08:00
void
_edje_lua2_error_full ( const char * file , const char * fnc , int line ,
lua_State * L , int err_code )
{
const char * err_type ;
switch ( err_code )
{
case LUA_ERRRUN :
err_type = " runtime " ;
break ;
case LUA_ERRSYNTAX :
err_type = " syntax " ;
break ;
case LUA_ERRMEM :
err_type = " memory allocation " ;
break ;
case LUA_ERRERR :
err_type = " error handler " ;
break ;
default :
err_type = " unknown " ;
break ;
}
eina_log_print
( _edje_default_log_dom , EINA_LOG_LEVEL_ERR , file , fnc , line ,
" Lua %s error: %s " , err_type , lua_tostring ( L , - 1 ) ) ;
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
@ section callbacks Lua callbacks
These are lua functions that are called by the lua edje system when certain
events occur . If the functions don ' t exist in the lua group , they don ' t get
called .
*/
/**
@ page luaref
2011-11-17 10:13:58 -08:00
@ subsection edje_shutdown Edje shutdown ( ) callback .
2011-11-17 06:21:53 -08:00
2011-11-17 10:13:58 -08:00
If a function called " shutdown " exists in a lua edje group , then it is called when
that edje gets deleted .
2011-11-17 06:21:53 -08:00
*/
2011-11-12 02:42:56 -08:00
void
2011-11-17 06:21:53 -08:00
_edje_lua2_script_func_shutdown ( Edje * ed ) // Stack usage [-?, +?, ?]
2011-11-12 02:42:56 -08:00
{
int err ;
lua_getglobal ( ed - > L , " shutdown " ) ;
if ( ! lua_isnil ( ed - > L , - 1 ) )
{
if ( ( err = lua_pcall ( ed - > L , 0 , 0 , 0 ) ) )
_edje_lua2_error ( ed - > L , err ) ;
}
else
lua_pop ( ed - > L , 1 ) ;
_edje_lua2_script_shutdown ( ed ) ;
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
2011-11-17 10:13:58 -08:00
@ subsection edje_show Edje show ( ) callback .
2011-11-17 06:21:53 -08:00
2011-11-17 10:13:58 -08:00
If a function called " show " exists in a lua edje group , then it is called when
that edje gets shown .
2011-11-17 06:21:53 -08:00
*/
2011-11-12 02:42:56 -08:00
void
2011-11-17 06:21:53 -08:00
_edje_lua2_script_func_show ( Edje * ed ) // Stack usage [-?, +?, ?]
2011-11-12 02:42:56 -08:00
{
int err ;
lua_getglobal ( ed - > L , " show " ) ;
if ( ! lua_isnil ( ed - > L , - 1 ) )
{
if ( ( err = lua_pcall ( ed - > L , 0 , 0 , 0 ) ) )
_edje_lua2_error ( ed - > L , err ) ;
}
else
lua_pop ( ed - > L , 1 ) ;
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
2011-11-17 10:13:58 -08:00
@ subsection edje_hide Edje hide ( ) callback .
2011-11-17 06:21:53 -08:00
2011-11-17 10:13:58 -08:00
If a function called " hide " exists in a lua edje group , then it is called when
that edje gets hidden .
2011-11-17 06:21:53 -08:00
*/
2011-11-12 02:42:56 -08:00
void
2011-11-17 06:21:53 -08:00
_edje_lua2_script_func_hide ( Edje * ed ) // Stack usage [-?, +?, ?]
2011-11-12 02:42:56 -08:00
{
int err ;
lua_getglobal ( ed - > L , " hide " ) ;
if ( ! lua_isnil ( ed - > L , - 1 ) )
{
if ( ( err = lua_pcall ( ed - > L , 0 , 0 , 0 ) ) )
_edje_lua2_error ( ed - > L , err ) ;
}
else
lua_pop ( ed - > L , 1 ) ;
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
2011-11-17 10:13:58 -08:00
@ subsection edje_move Edje move ( x , y ) callback .
2011-11-17 06:21:53 -08:00
2011-11-17 10:13:58 -08:00
If a function called " move " exists in a lua edje group , then it is called when
that edje gets moved , with the new position passed to it .
2011-11-17 06:21:53 -08:00
*/
2011-11-12 02:42:56 -08:00
void
2011-11-17 06:21:53 -08:00
_edje_lua2_script_func_move ( Edje * ed ) // Stack usage [-?, +?, ?]
2011-11-12 02:42:56 -08:00
{
int err ;
// FIXME: move all objects created by script
lua_getglobal ( ed - > L , " move " ) ;
if ( ! lua_isnil ( ed - > L , - 1 ) )
{
lua_pushinteger ( ed - > L , ed - > x ) ;
lua_pushinteger ( ed - > L , ed - > y ) ;
if ( ( err = lua_pcall ( ed - > L , 2 , 0 , 0 ) ) )
_edje_lua2_error ( ed - > L , err ) ;
}
else
lua_pop ( ed - > L , 1 ) ;
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
2011-11-17 10:13:58 -08:00
@ subsection edje_resize Edje resize ( w , h ) callback .
2011-11-17 06:21:53 -08:00
2011-11-17 10:13:58 -08:00
If a function called " resize " exists in a lua edje group , then it is called when
that edje gets resized , with the new size passed to it .
2011-11-17 06:21:53 -08:00
*/
2011-11-12 02:42:56 -08:00
void
2011-11-17 06:21:53 -08:00
_edje_lua2_script_func_resize ( Edje * ed ) // Stack usage [-?, +?, ?]
2011-11-12 02:42:56 -08:00
{
int err ;
lua_getglobal ( ed - > L , " resize " ) ;
if ( ! lua_isnil ( ed - > L , - 1 ) )
{
lua_pushinteger ( ed - > L , ed - > w ) ;
lua_pushinteger ( ed - > L , ed - > h ) ;
if ( ( err = lua_pcall ( ed - > L , 2 , 0 , 0 ) ) )
_edje_lua2_error ( ed - > L , err ) ;
}
else
lua_pop ( ed - > L , 1 ) ;
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
2011-11-17 10:13:58 -08:00
@ subsection edje_message Edje message ( id , type , . . . ) callback .
2011-11-17 06:21:53 -08:00
2011-11-17 10:13:58 -08:00
If a function called " message " exists in a lua edje group , then it is called when
that edje gets gets a message sent to it , with the message details passed to it .
See edje : messagesend ( ) for details of what each type means . The arrays are
passed as a table .
2011-11-17 06:21:53 -08:00
*/
2011-11-12 02:42:56 -08:00
void
2011-11-17 06:21:53 -08:00
_edje_lua2_script_func_message ( Edje * ed , Edje_Message * em ) // Stack usage [-?, +?, ?]
2011-11-12 02:42:56 -08:00
{
int err , n , c , i ;
lua_getglobal ( ed - > L , " message " ) ;
if ( ! lua_isnil ( ed - > L , - 1 ) )
{
n = 2 ;
lua_pushinteger ( ed - > L , em - > id ) ;
switch ( em - > type )
{
case EDJE_MESSAGE_NONE :
lua_pushstring ( ed - > L , " none " ) ;
break ;
case EDJE_MESSAGE_SIGNAL :
break ;
case EDJE_MESSAGE_STRING :
lua_pushstring ( ed - > L , " str " ) ;
lua_pushstring ( ed - > L , ( ( Edje_Message_String * ) em - > msg ) - > str ) ;
n + = 1 ;
break ;
case EDJE_MESSAGE_INT :
lua_pushstring ( ed - > L , " int " ) ;
lua_pushinteger ( ed - > L , ( ( Edje_Message_Int * ) em - > msg ) - > val ) ;
n + = 1 ;
break ;
case EDJE_MESSAGE_FLOAT :
lua_pushstring ( ed - > L , " float " ) ;
lua_pushnumber ( ed - > L , ( ( Edje_Message_Float * ) em - > msg ) - > val ) ;
n + = 1 ;
break ;
case EDJE_MESSAGE_STRING_SET :
lua_pushstring ( ed - > L , " strset " ) ;
c = ( ( Edje_Message_String_Set * ) em - > msg ) - > count ;
lua_createtable ( ed - > L , c , 0 ) ;
for ( i = 0 ; i < c ; i + + )
{
lua_pushstring ( ed - > L , ( ( Edje_Message_String_Set * ) em - > msg ) - > str [ i ] ) ;
lua_rawseti ( ed - > L , - 2 , i + 1 ) ;
}
n + = 1 ;
break ;
case EDJE_MESSAGE_INT_SET :
lua_pushstring ( ed - > L , " intset " ) ;
c = ( ( Edje_Message_Int_Set * ) em - > msg ) - > count ;
lua_createtable ( ed - > L , c , 0 ) ;
for ( i = 0 ; i < c ; i + + )
{
lua_pushinteger ( ed - > L , ( ( Edje_Message_Int_Set * ) em - > msg ) - > val [ i ] ) ;
lua_rawseti ( ed - > L , - 2 , i + 1 ) ;
}
n + = 1 ;
break ;
case EDJE_MESSAGE_FLOAT_SET :
lua_pushstring ( ed - > L , " floatset " ) ;
c = ( ( Edje_Message_Float_Set * ) em - > msg ) - > count ;
lua_createtable ( ed - > L , c , 0 ) ;
for ( i = 0 ; i < c ; i + + )
{
lua_pushnumber ( ed - > L , ( ( Edje_Message_Float_Set * ) em - > msg ) - > val [ i ] ) ;
lua_rawseti ( ed - > L , - 2 , i + 1 ) ;
}
n + = 1 ;
break ;
case EDJE_MESSAGE_STRING_INT :
lua_pushstring ( ed - > L , " strint " ) ;
lua_pushstring ( ed - > L , ( ( Edje_Message_String_Int * ) em - > msg ) - > str ) ;
lua_pushinteger ( ed - > L , ( ( Edje_Message_String_Int * ) em - > msg ) - > val ) ;
n + = 2 ;
break ;
case EDJE_MESSAGE_STRING_FLOAT :
lua_pushstring ( ed - > L , " strfloat " ) ;
lua_pushstring ( ed - > L , ( ( Edje_Message_String_Float * ) em - > msg ) - > str ) ;
lua_pushnumber ( ed - > L , ( ( Edje_Message_String_Float * ) em - > msg ) - > val ) ;
n + = 2 ;
break ;
case EDJE_MESSAGE_STRING_INT_SET :
lua_pushstring ( ed - > L , " strintset " ) ;
lua_pushstring ( ed - > L , ( ( Edje_Message_String_Int_Set * ) em - > msg ) - > str ) ;
c = ( ( Edje_Message_String_Int_Set * ) em - > msg ) - > count ;
lua_createtable ( ed - > L , c , 0 ) ;
for ( i = 0 ; i < c ; i + + )
{
lua_pushinteger ( ed - > L , ( ( Edje_Message_String_Int_Set * ) em - > msg ) - > val [ i ] ) ;
lua_rawseti ( ed - > L , - 2 , i + 1 ) ;
}
n + = 2 ;
break ;
case EDJE_MESSAGE_STRING_FLOAT_SET :
lua_pushstring ( ed - > L , " strfloatset " ) ;
lua_pushstring ( ed - > L , ( ( Edje_Message_String_Float_Set * ) em - > msg ) - > str ) ;
c = ( ( Edje_Message_String_Float_Set * ) em - > msg ) - > count ;
lua_createtable ( ed - > L , c , 0 ) ;
for ( i = 0 ; i < c ; i + + )
{
lua_pushnumber ( ed - > L , ( ( Edje_Message_String_Float_Set * ) em - > msg ) - > val [ i ] ) ;
lua_rawseti ( ed - > L , - 2 , i + 1 ) ;
}
n + = 2 ;
break ;
default :
break ;
}
if ( ( err = lua_pcall ( ed - > L , n , 0 , 0 ) ) )
_edje_lua2_error ( ed - > L , err ) ;
}
else
lua_pop ( ed - > L , 1 ) ;
}
2011-11-17 06:21:53 -08:00
/**
@ page luaref
2011-11-17 10:13:58 -08:00
@ subsection edje_signal Edje signal ( signal , source ) callback .
If a function called " signal " exists in a lua edje group , then it is called when
ever a signal arrives , with the signal details passed to it .
2011-11-17 06:21:53 -08:00
*/
2011-11-12 02:42:56 -08:00
void
2011-11-17 06:21:53 -08:00
_edje_lua2_script_func_signal ( Edje * ed , const char * sig , const char * src ) // Stack usage [-?, +?, ?]
2011-11-12 02:42:56 -08:00
{
int err ;
lua_getglobal ( ed - > L , " signal " ) ;
if ( ! lua_isnil ( ed - > L , - 1 ) )
{
lua_pushstring ( ed - > L , sig ) ;
lua_pushstring ( ed - > L , src ) ;
if ( ( err = lua_pcall ( ed - > L , 2 , 0 , 0 ) ) )
_edje_lua2_error ( ed - > L , err ) ;
}
else
lua_pop ( ed - > L , 1 ) ;
}