2002-11-08 00:02:15 -08:00
# include "evas_common.h"
# include "evas_private.h"
2011-10-10 23:06:11 -07:00
# include <math.h>
2012-05-07 10:22:06 -07:00
# ifdef EVAS_CSERVE2
# include "evas_cs2_private.h"
# endif
2002-11-08 00:02:15 -08:00
2012-09-12 12:00:16 -07:00
/* debug rendering
2012-09-12 12:00:23 -07:00
* NOTE : Define REND_DBG 1 in evas_private . h to enable debugging . Don ' t define
2012-09-12 12:00:16 -07:00
* it here since the flag is used on other places too . */
2011-03-15 09:20:57 -07:00
/* #define STDOUT_DBG 1 */
2009-11-15 05:46:20 -08:00
2012-09-12 12:00:23 -07:00
# ifdef REND_DBG
2009-11-15 05:46:20 -08:00
static FILE * dbf = NULL ;
static void
rend_dbg ( const char * txt )
{
if ( ! dbf )
{
2010-09-03 01:23:38 -07:00
# ifdef STDOUT_DBG
dbf = stdout ;
2011-05-20 23:23:33 -07:00
# else
2009-11-15 05:46:20 -08:00
dbf = fopen ( " EVAS-RENDER-DEBUG.log " , " w " ) ;
2011-05-20 23:23:33 -07:00
# endif
2009-11-15 05:46:20 -08:00
if ( ! dbf ) return ;
}
fputs ( txt , dbf ) ;
fflush ( dbf ) ;
}
# define RD(args...) \
{ \
char __tmpbuf [ 4096 ] ; \
\
snprintf ( __tmpbuf , sizeof ( __tmpbuf ) , # # args ) ; \
rend_dbg ( __tmpbuf ) ; \
}
# define RDI(xxxx) \
{ \
char __tmpbuf [ 4096 ] ; int __tmpi ; \
for ( __tmpi = 0 ; __tmpi < xxxx ; __tmpi + + ) \
__tmpbuf [ __tmpi ] = ' ' ; \
__tmpbuf [ __tmpi ] = 0 ; \
rend_dbg ( __tmpbuf ) ; \
}
# else
# define RD(args...)
# define RDI(x)
# endif
2012-12-18 08:28:55 -08:00
typedef struct _Render_Updates Render_Updates ;
struct _Render_Updates
{
void * surface ;
Eina_Rectangle * area ;
} ;
static Eina_Bool
2012-12-18 12:20:45 -08:00
evas_render_updates_internal ( Evas * eo_e , unsigned char make_updates , unsigned char do_draw , Evas_Render_Done_Cb done_func , void * done_data , Evas_Event_Cb updates_func , void * updates_data , Eina_Bool do_async ) ;
2005-12-03 01:27:53 -08:00
2006-01-06 15:05:17 -08:00
EAPI void
2012-10-08 18:58:41 -07:00
evas_damage_rectangle_add ( Evas * eo_e , int x , int y , int w , int h )
2002-11-08 00:02:15 -08:00
{
2012-10-08 18:58:41 -07:00
MAGIC_CHECK ( eo_e , Evas , MAGIC_EVAS ) ;
2002-11-08 00:02:15 -08:00
return ;
MAGIC_CHECK_END ( ) ;
2012-10-08 18:58:41 -07:00
eo_do ( eo_e , evas_canvas_damage_rectangle_add ( x , y , w , h ) ) ;
}
void
_canvas_damage_rectangle_add ( Eo * eo_e EINA_UNUSED , void * _pd , va_list * list )
{
int x = va_arg ( * list , int ) ;
int y = va_arg ( * list , int ) ;
int w = va_arg ( * list , int ) ;
int h = va_arg ( * list , int ) ;
Eina_Rectangle * r ;
Evas_Public_Data * e = _pd ;
2009-04-14 02:27:27 -07:00
NEW_RECT ( r , x , y , w , h ) ;
2002-11-08 00:02:15 -08:00
if ( ! r ) return ;
2008-10-21 09:31:05 -07:00
e - > damages = eina_list_append ( e - > damages , r ) ;
2012-05-16 06:21:37 -07:00
e - > changed = EINA_TRUE ;
2002-11-08 00:02:15 -08:00
}
2006-01-06 15:05:17 -08:00
EAPI void
2012-10-08 18:58:41 -07:00
evas_obscured_rectangle_add ( Evas * eo_e , int x , int y , int w , int h )
2002-11-08 00:02:15 -08:00
{
2012-10-08 18:58:41 -07:00
MAGIC_CHECK ( eo_e , Evas , MAGIC_EVAS ) ;
2002-11-08 00:02:15 -08:00
return ;
MAGIC_CHECK_END ( ) ;
2012-10-08 18:58:41 -07:00
eo_do ( eo_e , evas_canvas_obscured_rectangle_add ( x , y , w , h ) ) ;
}
void
_canvas_obscured_rectangle_add ( Eo * eo_e EINA_UNUSED , void * _pd , va_list * list )
{
int x = va_arg ( * list , int ) ;
int y = va_arg ( * list , int ) ;
int w = va_arg ( * list , int ) ;
int h = va_arg ( * list , int ) ;
Eina_Rectangle * r ;
Evas_Public_Data * e = _pd ;
2009-04-14 02:27:27 -07:00
NEW_RECT ( r , x , y , w , h ) ;
2002-11-08 00:02:15 -08:00
if ( ! r ) return ;
2008-10-21 09:31:05 -07:00
e - > obscures = eina_list_append ( e - > obscures , r ) ;
2002-11-08 00:02:15 -08:00
}
2006-01-06 15:05:17 -08:00
EAPI void
2012-10-08 18:58:41 -07:00
evas_obscured_clear ( Evas * eo_e )
2002-11-08 00:02:15 -08:00
{
2012-10-08 18:58:41 -07:00
MAGIC_CHECK ( eo_e , Evas , MAGIC_EVAS ) ;
2002-11-08 00:02:15 -08:00
return ;
2005-05-21 19:49:50 -07:00
MAGIC_CHECK_END ( ) ;
2012-10-08 18:58:41 -07:00
eo_do ( eo_e , evas_canvas_obscured_clear ( ) ) ;
}
void
_canvas_obscured_clear ( Eo * eo_e EINA_UNUSED , void * _pd , va_list * list EINA_UNUSED )
{
Eina_Rectangle * r ;
Evas_Public_Data * e = _pd ;
2009-04-14 02:27:27 -07:00
EINA_LIST_FREE ( e - > obscures , r )
2009-10-30 03:11:15 -07:00
{
eina_rectangle_free ( r ) ;
}
2002-11-08 00:02:15 -08:00
}
2012-11-20 03:52:16 -08:00
static Eina_Bool
_evas_clip_changes_free ( const void * container EINA_UNUSED , void * data , void * fdata EINA_UNUSED )
{
eina_rectangle_free ( data ) ;
return EINA_TRUE ;
}
2009-11-10 00:50:11 -08:00
static Eina_Bool
2012-10-10 00:23:00 -07:00
_evas_render_had_map ( Evas_Object_Protected_Data * obj )
2009-11-10 00:50:11 -08:00
{
2010-09-24 23:19:30 -07:00
return ( ( obj - > prev . map ) & & ( obj - > prev . usemap ) ) ;
2011-05-20 23:23:33 -07:00
// return ((!obj->cur.map) && (obj->prev.usemap));
2009-11-10 00:50:11 -08:00
}
static Eina_Bool
2012-10-08 18:58:41 -07:00
_evas_render_is_relevant ( Evas_Object * eo_obj )
2009-11-10 00:50:11 -08:00
{
2012-10-08 18:58:41 -07:00
Evas_Object_Protected_Data * obj = eo_data_get ( eo_obj , EVAS_OBJ_CLASS ) ;
return ( ( evas_object_is_visible ( eo_obj , obj ) & & ( ! obj - > cur . have_clipees ) ) | |
( evas_object_was_visible ( eo_obj , obj ) & & ( ! obj - > prev . have_clipees ) ) ) ;
2009-11-10 00:50:11 -08:00
}
static Eina_Bool
2012-10-10 00:23:00 -07:00
_evas_render_can_render ( Evas_Object * eo_obj , Evas_Object_Protected_Data * obj )
2009-11-10 00:50:11 -08:00
{
2012-10-08 18:58:41 -07:00
return ( evas_object_is_visible ( eo_obj , obj ) & & ( ! obj - > cur . have_clipees ) ) ;
2009-11-10 00:50:11 -08:00
}
static void
2012-10-10 00:23:00 -07:00
_evas_render_prev_cur_clip_cache_add ( Evas_Public_Data * e , Evas_Object_Protected_Data * obj )
2009-11-10 00:50:11 -08:00
{
e - > engine . func - > output_redraws_rect_add ( e - > engine . data . output ,
obj - > prev . cache . clip . x ,
obj - > prev . cache . clip . y ,
obj - > prev . cache . clip . w ,
obj - > prev . cache . clip . h ) ;
e - > engine . func - > output_redraws_rect_add ( e - > engine . data . output ,
obj - > cur . cache . clip . x ,
obj - > cur . cache . clip . y ,
obj - > cur . cache . clip . w ,
obj - > cur . cache . clip . h ) ;
}
static void
2012-10-10 00:23:00 -07:00
_evas_render_cur_clip_cache_del ( Evas_Public_Data * e , Evas_Object_Protected_Data * obj )
2009-11-10 00:50:11 -08:00
{
2011-11-10 21:56:40 -08:00
Evas_Coord x , y , w , h ;
2012-05-16 06:21:37 -07:00
2011-11-10 21:56:40 -08:00
x = obj - > cur . cache . clip . x ;
y = obj - > cur . cache . clip . y ;
w = obj - > cur . cache . clip . w ;
h = obj - > cur . cache . clip . h ;
if ( obj - > cur . clipper )
{
RECTS_CLIP_TO_RECT ( x , y , w , h ,
2012-10-10 00:23:00 -07:00
obj - > cur . clipper - > cur . cache . clip . x ,
obj - > cur . clipper - > cur . cache . clip . y ,
obj - > cur . clipper - > cur . cache . clip . w ,
obj - > cur . clipper - > cur . cache . clip . h ) ;
2011-11-10 21:56:40 -08:00
}
2009-11-10 00:50:11 -08:00
e - > engine . func - > output_redraws_rect_del ( e - > engine . data . output ,
2011-11-10 21:56:40 -08:00
x , y , w , h ) ;
2009-11-10 00:50:11 -08:00
}
2009-11-06 21:01:43 -08:00
static void
2012-10-10 00:23:00 -07:00
_evas_render_phase1_direct ( Evas_Public_Data * e ,
2011-06-30 19:02:02 -07:00
Eina_Array * active_objects ,
2012-10-08 18:58:41 -07:00
Eina_Array * restack_objects EINA_UNUSED ,
Eina_Array * delete_objects EINA_UNUSED ,
2009-11-10 00:50:11 -08:00
Eina_Array * render_objects )
2009-11-06 21:01:43 -08:00
{
unsigned int i ;
2011-02-06 15:51:48 -08:00
Eina_List * l ;
2012-10-08 18:58:41 -07:00
Evas_Object * eo_proxy ;
2009-11-06 21:01:43 -08:00
2009-11-15 05:46:20 -08:00
RD ( " [--- PHASE 1 DIRECT \n " ) ;
2011-05-19 06:01:44 -07:00
for ( i = 0 ; i < active_objects - > count ; i + + )
{
2012-10-08 18:58:41 -07:00
Evas_Object * eo_obj ;
2011-05-19 06:01:44 -07:00
2012-10-08 18:58:41 -07:00
Evas_Object_Protected_Data * obj = eina_array_data_get ( active_objects , i ) ;
eo_obj = obj - > object ;
2011-05-20 23:23:33 -07:00
if ( obj - > changed )
2011-05-19 06:01:44 -07:00
{
/* Flag need redraw on proxy too */
2012-10-08 18:58:41 -07:00
evas_object_clip_recalc ( eo_obj , obj ) ;
EINA_LIST_FOREACH ( obj - > proxy . proxies , l , eo_proxy )
{
Evas_Object_Protected_Data * proxy = eo_data_get ( eo_proxy , EVAS_OBJ_CLASS ) ;
proxy - > proxy . redraw = EINA_TRUE ;
}
2011-05-19 06:01:44 -07:00
}
}
2009-11-09 07:18:37 -08:00
for ( i = 0 ; i < render_objects - > count ; i + + )
2009-11-06 21:01:43 -08:00
{
2012-10-08 18:58:41 -07:00
Evas_Object * eo_obj ;
2009-11-06 21:01:43 -08:00
2012-10-08 18:58:41 -07:00
Evas_Object_Protected_Data * obj = eina_array_data_get ( render_objects , i ) ;
eo_obj = obj - > object ;
2009-11-15 05:46:20 -08:00
RD ( " OBJ [%p] changed %i \n " , obj , obj - > changed ) ;
2011-05-20 23:23:33 -07:00
if ( obj - > changed )
2009-11-06 21:01:43 -08:00
{
2011-02-06 15:51:48 -08:00
/* Flag need redraw on proxy too */
2012-10-08 18:58:41 -07:00
evas_object_clip_recalc ( eo_obj , obj ) ;
obj - > func - > render_pre ( eo_obj , obj ) ;
2012-07-23 21:27:17 -07:00
if ( obj - > proxy . redraw )
2012-10-10 00:23:00 -07:00
_evas_render_prev_cur_clip_cache_add ( e , obj ) ;
2011-02-06 15:51:48 -08:00
if ( obj - > proxy . proxies )
{
2012-05-16 06:21:37 -07:00
obj - > proxy . redraw = EINA_TRUE ;
2012-10-08 18:58:41 -07:00
EINA_LIST_FOREACH ( obj - > proxy . proxies , l , eo_proxy )
2011-05-19 06:01:44 -07:00
{
2012-10-08 18:58:41 -07:00
Evas_Object_Protected_Data * proxy = eo_data_get ( eo_proxy , EVAS_OBJ_CLASS ) ;
proxy - > func - > render_pre ( eo_proxy , proxy ) ;
2012-10-10 00:23:00 -07:00
_evas_render_prev_cur_clip_cache_add ( e , proxy ) ;
2011-05-19 06:01:44 -07:00
}
}
2012-05-30 00:32:27 -07:00
RD ( " pre-render-done smart:%p|%p [%p, %i] | [%p, %i] has_map:%i had_map:%i \n " ,
obj - > smart . smart ,
2012-10-08 18:58:41 -07:00
evas_object_smart_members_get_direct ( eo_obj ) ,
2012-05-30 00:32:27 -07:00
obj - > cur . map , obj - > cur . usemap ,
obj - > prev . map , obj - > prev . usemap ,
2012-10-10 00:23:00 -07:00
_evas_render_has_map ( eo_obj , obj ) ,
_evas_render_had_map ( obj ) ) ;
2012-10-08 18:58:41 -07:00
if ( ( obj - > is_smart ) & &
2012-10-22 01:59:32 -07:00
( ( _evas_render_has_map ( eo_obj , obj ) | |
2012-10-25 08:24:27 -07:00
( obj - > changed_src_visible ) ) ) )
2011-05-19 06:01:44 -07:00
{
2012-05-30 00:32:27 -07:00
RD ( " has map + smart \n " ) ;
2012-10-10 00:23:00 -07:00
_evas_render_prev_cur_clip_cache_add ( e , obj ) ;
2009-11-15 05:46:20 -08:00
}
2009-11-06 21:01:43 -08:00
}
2011-05-20 23:23:33 -07:00
else
{
2012-10-08 18:58:41 -07:00
if ( obj - > is_smart )
2009-11-06 21:01:43 -08:00
{
2012-10-08 18:58:41 -07:00
// obj->func->render_pre(eo_obj);
2009-11-06 21:01:43 -08:00
}
2011-10-21 03:25:35 -07:00
else if ( ( obj - > rect_del ) | |
2012-10-08 18:58:41 -07:00
( evas_object_is_opaque ( eo_obj , obj ) & & evas_object_is_visible ( eo_obj , obj ) ) )
2009-11-15 05:46:20 -08:00
{
RD ( " rect del \n " ) ;
2012-10-10 00:23:00 -07:00
_evas_render_cur_clip_cache_del ( e , obj ) ;
2009-11-15 05:46:20 -08:00
}
2011-05-20 23:23:33 -07:00
}
2009-11-06 21:01:43 -08:00
}
2009-11-15 05:46:20 -08:00
RD ( " ---] \n " ) ;
2009-10-30 03:11:15 -07:00
}
2009-06-17 03:01:52 -07:00
static Eina_Bool
2012-10-10 00:23:00 -07:00
_evas_render_phase1_object_process ( Evas_Public_Data * e , Evas_Object * eo_obj ,
2010-04-27 06:43:10 -07:00
Eina_Array * active_objects ,
Eina_Array * restack_objects ,
Eina_Array * delete_objects ,
Eina_Array * render_objects ,
2012-05-15 04:29:28 -07:00
int restack ,
2012-07-16 04:33:12 -07:00
int * redraw_all ,
Eina_Bool mapped_parent
2012-09-12 12:00:23 -07:00
# ifdef REND_DBG
2009-11-15 05:46:20 -08:00
, int level
# endif
2011-05-20 23:23:33 -07:00
)
2008-05-26 06:24:24 -07:00
{
2009-06-17 03:01:52 -07:00
Eina_Bool clean_them = EINA_FALSE ;
2005-10-26 21:36:58 -07:00
int is_active ;
2012-05-15 04:29:28 -07:00
Eina_Bool map , hmap ;
2011-05-20 23:23:33 -07:00
2012-10-08 18:58:41 -07:00
Evas_Object_Protected_Data * obj = eo_data_get ( eo_obj , EVAS_OBJ_CLASS ) ;
2012-07-16 04:33:12 -07:00
//Need pre render for the children of mapped object.
//But only when they have changed.
if ( mapped_parent & & ( ! obj - > changed ) ) return EINA_FALSE ;
2012-05-15 04:43:23 -07:00
obj - > rect_del = EINA_FALSE ;
obj - > render_pre = EINA_FALSE ;
2008-05-26 06:24:24 -07:00
2010-05-21 00:10:45 -07:00
if ( obj - > delete_me = = 2 )
2012-10-08 18:58:41 -07:00
eina_array_push ( delete_objects , obj ) ;
2012-04-26 02:53:03 -07:00
else if ( obj - > delete_me ! = 0 ) obj - > delete_me + + ;
2008-05-26 06:24:24 -07:00
/* If the object will be removed, we should not cache anything during this run. */
2009-11-10 00:50:11 -08:00
if ( obj - > delete_me ! = 0 ) clean_them = EINA_TRUE ;
2008-05-26 06:24:24 -07:00
2005-10-26 19:44:36 -07:00
/* build active object list */
2012-10-08 18:58:41 -07:00
evas_object_clip_recalc ( eo_obj , obj ) ;
is_active = evas_object_is_active ( eo_obj , obj ) ;
2008-05-26 06:24:24 -07:00
obj - > is_active = is_active ;
2010-04-27 06:43:10 -07:00
2009-11-15 05:46:20 -08:00
RDI ( level ) ;
RD ( " [--- PROCESS [%p] '%s' active = %i, del = %i | %i %i %ix%i \n " , obj , obj - > type , is_active , obj - > delete_me , obj - > cur . geometry . x , obj - > cur . geometry . y , obj - > cur . geometry . w , obj - > cur . geometry . h ) ;
2012-07-15 20:12:39 -07:00
2012-07-16 04:33:12 -07:00
if ( ( ! mapped_parent ) & & ( ( is_active ) | | ( obj - > delete_me ! = 0 ) ) )
2009-11-10 01:10:59 -08:00
eina_array_push ( active_objects , obj ) ;
2009-11-19 00:37:22 -08:00
2012-09-12 12:00:23 -07:00
# ifdef REND_DBG
2009-11-19 00:37:22 -08:00
if ( ! is_active )
{
RDI ( level ) ;
RD ( " [%p] vis: %i, cache.clip.vis: %i cache.clip.a: %i [%p] \n " , obj , obj - > cur . visible , obj - > cur . cache . clip . visible , obj - > cur . cache . clip . a , obj - > func - > is_visible ) ;
}
2010-04-27 06:43:10 -07:00
# endif
2012-10-10 00:23:00 -07:00
map = _evas_render_has_map ( eo_obj , obj ) ;
hmap = _evas_render_had_map ( obj ) ;
2010-04-27 06:43:10 -07:00
2009-11-10 00:50:11 -08:00
if ( ( restack ) & & ( ! map ) )
2005-10-26 23:40:28 -07:00
{
2011-05-20 23:23:33 -07:00
if ( ! obj - > changed )
2009-11-09 07:18:37 -08:00
{
eina_array_push ( & e - > pending_objects , obj ) ;
2012-05-15 04:43:23 -07:00
obj - > changed = EINA_TRUE ;
2009-11-09 07:18:37 -08:00
}
2012-05-15 04:43:23 -07:00
obj - > restack = EINA_TRUE ;
2011-05-20 23:23:33 -07:00
clean_them = EINA_TRUE ;
2005-10-26 23:40:28 -07:00
}
2009-11-06 21:01:43 -08:00
2009-11-10 00:50:11 -08:00
if ( map )
2009-10-28 01:59:01 -07:00
{
2009-11-15 05:46:20 -08:00
RDI ( level ) ;
RD ( " obj mapped \n " ) ;
2009-10-28 01:59:01 -07:00
if ( obj - > changed )
{
2012-05-15 04:43:23 -07:00
if ( map ! = hmap ) * redraw_all = 1 ;
if ( ( is_active ) & & ( ! obj - > clip . clipees ) & &
2012-10-08 18:58:41 -07:00
( ( evas_object_is_visible ( eo_obj , obj ) & & ( ! obj - > cur . have_clipees ) ) | |
( evas_object_was_visible ( eo_obj , obj ) & & ( ! obj - > prev . have_clipees ) ) ) )
2009-11-06 21:01:43 -08:00
{
eina_array_push ( render_objects , obj ) ;
2012-10-10 00:23:00 -07:00
_evas_render_prev_cur_clip_cache_add ( e , obj ) ;
2012-05-15 04:43:23 -07:00
obj - > render_pre = EINA_TRUE ;
2012-07-16 04:33:12 -07:00
2012-10-08 18:58:41 -07:00
if ( obj - > is_smart )
2012-07-16 04:33:12 -07:00
{
2012-10-08 18:58:41 -07:00
Evas_Object_Protected_Data * obj2 ;
EINA_INLIST_FOREACH ( evas_object_smart_members_get_direct ( eo_obj ) , obj2 )
2012-07-16 04:33:12 -07:00
{
2012-10-10 00:23:00 -07:00
_evas_render_phase1_object_process ( e , obj2 - > object ,
2012-07-16 04:33:12 -07:00
active_objects ,
restack_objects ,
delete_objects ,
render_objects ,
obj - > restack ,
redraw_all ,
EINA_TRUE
2012-09-12 12:00:23 -07:00
# ifdef REND_DBG
2012-07-16 04:33:12 -07:00
, level + 1
# endif
) ;
}
}
2009-10-28 01:59:01 -07:00
}
}
2009-11-06 02:26:54 -08:00
return clean_them ;
2009-10-28 01:59:01 -07:00
}
2012-05-30 03:12:10 -07:00
else if ( hmap )
2009-11-09 07:18:37 -08:00
{
2009-11-15 05:46:20 -08:00
RDI ( level ) ;
RD ( " had map - restack objs \n " ) ;
2011-05-20 23:23:33 -07:00
// eina_array_push(restack_objects, obj);
2012-10-10 00:23:00 -07:00
_evas_render_prev_cur_clip_cache_add ( e , obj ) ;
2010-08-23 23:58:07 -07:00
if ( obj - > changed )
2010-09-24 23:19:30 -07:00
{
2012-07-15 20:12:39 -07:00
if ( ! map )
2010-09-24 23:19:30 -07:00
{
2012-07-15 20:12:39 -07:00
if ( ( obj - > cur . map ) & & ( obj - > cur . usemap ) ) map = EINA_TRUE ;
2010-09-24 23:19:30 -07:00
}
if ( map ! = hmap )
{
* redraw_all = 1 ;
}
2010-08-23 23:58:07 -07:00
}
2009-11-09 07:18:37 -08:00
}
2010-04-27 06:43:10 -07:00
2009-10-28 01:59:01 -07:00
/* handle normal rendering. this object knows how to handle maps */
2005-10-26 23:40:28 -07:00
if ( obj - > changed )
2005-10-26 19:44:36 -07:00
{
2012-10-08 18:58:41 -07:00
if ( obj - > is_smart )
2011-05-20 23:23:33 -07:00
{
2009-11-15 05:46:20 -08:00
RDI ( level ) ;
RD ( " changed + smart - render ok \n " ) ;
2011-05-20 23:23:33 -07:00
eina_array_push ( render_objects , obj ) ;
2012-05-15 04:43:23 -07:00
obj - > render_pre = EINA_TRUE ;
2012-10-08 18:58:41 -07:00
Evas_Object_Protected_Data * obj2 ;
EINA_INLIST_FOREACH ( evas_object_smart_members_get_direct ( eo_obj ) ,
2012-07-16 04:33:12 -07:00
obj2 )
2011-05-20 23:23:33 -07:00
{
2012-10-10 00:23:00 -07:00
_evas_render_phase1_object_process ( e , obj2 - > object ,
2011-05-20 23:23:33 -07:00
active_objects ,
restack_objects ,
delete_objects ,
render_objects ,
obj - > restack ,
2012-07-16 04:33:12 -07:00
redraw_all ,
mapped_parent
2012-09-12 12:00:23 -07:00
# ifdef REND_DBG
2009-11-15 05:46:20 -08:00
, level + 1
2010-04-27 06:43:10 -07:00
# endif
2011-05-20 23:23:33 -07:00
) ;
}
}
else
{
if ( ( is_active ) & & ( ! obj - > clip . clipees ) & &
2012-10-08 18:58:41 -07:00
_evas_render_is_relevant ( eo_obj ) )
2009-11-10 00:50:11 -08:00
{
2009-11-15 05:46:20 -08:00
RDI ( level ) ;
RD ( " relevant + active \n " ) ;
2009-11-10 00:50:11 -08:00
if ( obj - > restack )
eina_array_push ( restack_objects , obj ) ;
else
{
eina_array_push ( render_objects , obj ) ;
2012-05-15 04:43:23 -07:00
obj - > render_pre = EINA_TRUE ;
2009-11-10 00:50:11 -08:00
}
}
2009-11-15 05:46:20 -08:00
else
{
RDI ( level ) ;
RD ( " skip - not smart, not active or clippees or not relevant \n " ) ;
}
2011-05-20 23:23:33 -07:00
}
2005-10-26 19:44:36 -07:00
}
else
{
2010-04-27 06:43:10 -07:00
RD ( " not changed... [%i] -> (%i %i %p %i) [%i] \n " ,
2012-10-08 18:58:41 -07:00
evas_object_is_visible ( eo_obj , obj ) ,
2012-07-16 04:33:12 -07:00
obj - > cur . visible , obj - > cur . cache . clip . visible , obj - > smart . smart ,
2012-10-08 18:58:41 -07:00
obj - > cur . cache . clip . a , evas_object_was_visible ( eo_obj , obj ) ) ;
2012-07-16 04:33:12 -07:00
2011-05-20 23:23:33 -07:00
if ( ( ! obj - > clip . clipees ) & & ( obj - > delete_me = = 0 ) & &
2012-10-10 00:23:00 -07:00
( _evas_render_can_render ( eo_obj , obj ) | |
2012-10-08 18:58:41 -07:00
( evas_object_was_visible ( eo_obj , obj ) & & ( ! obj - > prev . have_clipees ) ) ) )
2011-05-20 23:23:33 -07:00
{
2012-10-08 18:58:41 -07:00
if ( obj - > is_smart )
2011-05-20 23:23:33 -07:00
{
2009-11-15 05:46:20 -08:00
RDI ( level ) ;
RD ( " smart + visible/was visible + not clip \n " ) ;
2011-05-20 23:23:33 -07:00
eina_array_push ( render_objects , obj ) ;
2012-05-16 06:21:37 -07:00
obj - > render_pre = EINA_TRUE ;
2012-10-08 18:58:41 -07:00
Evas_Object_Protected_Data * obj2 ;
2011-05-20 23:23:33 -07:00
EINA_INLIST_FOREACH
2012-10-08 18:58:41 -07:00
( evas_object_smart_members_get_direct ( eo_obj ) , obj2 )
2011-05-20 23:23:33 -07:00
{
2012-10-10 00:23:00 -07:00
_evas_render_phase1_object_process ( e , obj2 - > object ,
2011-05-20 23:23:33 -07:00
active_objects ,
restack_objects ,
delete_objects ,
render_objects ,
2012-05-15 04:29:28 -07:00
restack ,
2012-07-16 04:33:12 -07:00
redraw_all ,
mapped_parent
2012-09-12 12:00:23 -07:00
# ifdef REND_DBG
2011-05-20 23:23:33 -07:00
, level + 1
2009-11-15 05:46:20 -08:00
# endif
2011-05-20 23:23:33 -07:00
) ;
}
}
else
{
2012-10-08 18:58:41 -07:00
if ( evas_object_is_opaque ( eo_obj , obj ) & &
evas_object_is_visible ( eo_obj , obj ) )
2011-05-20 23:23:33 -07:00
{
2009-11-15 05:46:20 -08:00
RDI ( level ) ;
RD ( " opaque + visible \n " ) ;
2011-05-20 23:23:33 -07:00
eina_array_push ( render_objects , obj ) ;
2012-05-15 04:43:23 -07:00
obj - > rect_del = EINA_TRUE ;
2011-05-20 23:23:33 -07:00
}
2012-10-08 18:58:41 -07:00
else if ( evas_object_is_visible ( eo_obj , obj ) )
2009-11-10 01:10:59 -08:00
{
2009-11-15 05:46:20 -08:00
RDI ( level ) ;
RD ( " visible \n " ) ;
2009-11-10 01:10:59 -08:00
eina_array_push ( render_objects , obj ) ;
2012-05-15 04:43:23 -07:00
obj - > render_pre = EINA_TRUE ;
2009-11-10 01:10:59 -08:00
}
2009-11-15 05:46:20 -08:00
else
{
RDI ( level ) ;
RD ( " skip \n " ) ;
}
}
}
2012-07-16 04:33:12 -07:00
/* else if (obj->smart.smart)
2012-07-15 20:12:39 -07:00
{
RDI ( level ) ;
RD ( " smart + mot visible/was visible \n " ) ;
eina_array_push ( render_objects , obj ) ;
obj - > render_pre = 1 ;
2012-10-08 18:58:41 -07:00
EINA_INLIST_FOREACH ( evas_object_smart_members_get_direct ( eo_obj ) ,
2012-07-16 04:33:12 -07:00
obj2 )
2012-07-15 20:12:39 -07:00
{
2012-10-10 00:23:00 -07:00
_evas_render_phase1_object_process ( e , obj2 ,
2012-07-15 20:12:39 -07:00
active_objects ,
restack_objects ,
delete_objects ,
render_objects ,
restack ,
redraw_all
2012-09-12 12:00:23 -07:00
# ifdef REND_DBG
2012-07-15 20:12:39 -07:00
, level + 1
2011-05-20 23:23:33 -07:00
# endif
2012-07-15 20:12:39 -07:00
) ;
}
}
*/
}
if ( ! is_active ) obj - > restack = EINA_FALSE ;
RDI ( level ) ;
RD ( " ---] \n " ) ;
return clean_them ;
2005-10-26 19:44:36 -07:00
}
2009-06-17 03:01:52 -07:00
static Eina_Bool
2012-10-10 00:23:00 -07:00
_evas_render_phase1_process ( Evas_Public_Data * e ,
2010-04-27 06:43:10 -07:00
Eina_Array * active_objects ,
Eina_Array * restack_objects ,
Eina_Array * delete_objects ,
2010-08-23 23:58:07 -07:00
Eina_Array * render_objects ,
int * redraw_all )
2005-10-26 19:44:36 -07:00
{
2008-10-17 04:23:18 -07:00
Evas_Layer * lay ;
2009-06-17 03:01:52 -07:00
Eina_Bool clean_them = EINA_FALSE ;
2005-10-26 19:44:36 -07:00
2009-11-15 05:46:20 -08:00
RD ( " [--- PHASE 1 \n " ) ;
2008-10-21 05:19:57 -07:00
EINA_INLIST_FOREACH ( e - > layers , lay )
2005-10-26 19:44:36 -07:00
{
2012-10-08 18:58:41 -07:00
Evas_Object_Protected_Data * obj ;
2010-04-27 06:43:10 -07:00
2011-05-20 23:23:33 -07:00
EINA_INLIST_FOREACH ( lay - > objects , obj )
{
clean_them | = _evas_render_phase1_object_process
2012-10-10 00:23:00 -07:00
( e , obj - > object , active_objects , restack_objects , delete_objects ,
2012-07-16 04:33:12 -07:00
render_objects , 0 , redraw_all , EINA_FALSE
2012-09-12 12:00:23 -07:00
# ifdef REND_DBG
2011-05-20 23:23:33 -07:00
, 1
2010-04-27 06:43:10 -07:00
# endif
2009-11-15 05:46:20 -08:00
) ;
2011-05-20 23:23:33 -07:00
}
2008-05-26 06:24:24 -07:00
}
2009-11-15 05:46:20 -08:00
RD ( " ---] \n " ) ;
2008-05-26 06:24:24 -07:00
return clean_them ;
}
static void
2012-10-08 18:58:41 -07:00
_evas_render_check_pending_objects ( Eina_Array * pending_objects , Evas * eo_e EINA_UNUSED , Evas_Public_Data * e )
2008-05-26 06:24:24 -07:00
{
2010-05-05 04:36:21 -07:00
unsigned int i ;
2008-05-26 06:24:24 -07:00
for ( i = 0 ; i < pending_objects - > count ; + + i )
{
2012-10-08 18:58:41 -07:00
Evas_Object * eo_obj ;
2012-05-16 06:21:37 -07:00
int is_active ;
Eina_Bool ok = EINA_FALSE ;
2012-10-08 18:58:41 -07:00
Evas_Object_Protected_Data * obj = eina_array_data_get ( pending_objects , i ) ;
eo_obj = obj - > object ;
2011-05-20 23:23:33 -07:00
if ( ! obj - > layer ) goto clean_stuff ;
2010-04-27 06:43:10 -07:00
2012-06-15 06:29:24 -07:00
//If the children are in active objects, They should be cleaned up.
2012-10-10 00:23:00 -07:00
if ( obj - > changed_map & & _evas_render_has_map ( eo_obj , obj ) )
2012-06-15 06:29:24 -07:00
goto clean_stuff ;
2012-05-29 17:51:11 -07:00
2012-10-08 18:58:41 -07:00
evas_object_clip_recalc ( eo_obj , obj ) ;
is_active = evas_object_is_active ( eo_obj , obj ) ;
2010-04-27 06:43:10 -07:00
2011-05-20 23:23:33 -07:00
if ( ( ! is_active ) & & ( ! obj - > is_active ) & & ( ! obj - > render_pre ) & &
2009-10-30 03:11:15 -07:00
( ! obj - > rect_del ) )
2011-05-20 23:23:33 -07:00
{
2012-05-16 06:21:37 -07:00
ok = EINA_TRUE ;
2011-05-20 23:23:33 -07:00
goto clean_stuff ;
}
if ( obj - > is_active = = is_active )
{
if ( obj - > changed )
{
2012-10-08 18:58:41 -07:00
if ( obj - > is_smart )
2011-05-20 23:23:33 -07:00
{
2012-05-16 06:21:37 -07:00
if ( obj - > render_pre | | obj - > rect_del ) ok = EINA_TRUE ;
2011-05-20 23:23:33 -07:00
}
2009-10-28 01:59:01 -07:00
else
2011-05-20 23:23:33 -07:00
if ( ( is_active ) & & ( obj - > restack ) & & ( ! obj - > clip . clipees ) & &
2012-10-10 00:23:00 -07:00
( _evas_render_can_render ( eo_obj , obj ) | |
2012-10-08 18:58:41 -07:00
( evas_object_was_visible ( eo_obj , obj ) & & ( ! obj - > prev . have_clipees ) ) ) )
2009-10-28 01:59:01 -07:00
{
2012-05-16 06:21:37 -07:00
if ( ! ( obj - > render_pre | | obj - > rect_del ) )
ok = EINA_TRUE ;
2009-10-28 01:59:01 -07:00
}
2011-05-20 23:23:33 -07:00
else
if ( is_active & & ( ! obj - > clip . clipees ) & &
2012-10-10 00:23:00 -07:00
( _evas_render_can_render ( eo_obj , obj ) | |
2012-10-08 18:58:41 -07:00
( evas_object_was_visible ( eo_obj , obj ) & & ( ! obj - > prev . have_clipees ) ) ) )
2011-05-20 23:23:33 -07:00
{
2012-05-16 06:21:37 -07:00
if ( obj - > render_pre | | obj - > rect_del ) ok = EINA_TRUE ;
2011-05-20 23:23:33 -07:00
}
}
else
{
if ( ( ! obj - > clip . clipees ) & & ( obj - > delete_me = = 0 ) & &
2012-10-08 18:58:41 -07:00
( ! obj - > cur . have_clipees | | ( evas_object_was_visible ( eo_obj , obj ) & & ( ! obj - > prev . have_clipees ) ) )
& & evas_object_is_opaque ( eo_obj , obj ) & & evas_object_is_visible ( eo_obj , obj ) )
2009-10-30 03:11:15 -07:00
{
2012-10-08 18:58:41 -07:00
if ( obj - > rect_del | | obj - > is_smart ) ok = EINA_TRUE ;
2009-10-30 03:11:15 -07:00
}
2011-05-20 23:23:33 -07:00
}
}
clean_stuff :
if ( ! ok )
{
eina_array_clean ( & e - > active_objects ) ;
eina_array_clean ( & e - > render_objects ) ;
eina_array_clean ( & e - > restack_objects ) ;
eina_array_clean ( & e - > delete_objects ) ;
2012-05-16 06:21:37 -07:00
e - > invalidate = EINA_TRUE ;
2011-05-20 23:23:33 -07:00
return ;
}
2005-10-26 19:44:36 -07:00
}
}
2009-09-03 22:13:19 -07:00
Eina_Bool
2012-10-08 18:58:41 -07:00
pending_change ( void * data , void * gdata EINA_UNUSED )
2008-06-04 09:42:39 -07:00
{
2012-10-08 18:58:41 -07:00
Evas_Object * eo_obj ;
2008-06-04 09:42:39 -07:00
2012-10-08 18:58:41 -07:00
Evas_Object_Protected_Data * obj = data ;
eo_obj = obj - > object ;
2008-10-16 05:27:07 -07:00
if ( obj - > delete_me ) return EINA_FALSE ;
2009-11-23 02:07:07 -08:00
if ( obj - > pre_render_done )
{
2010-09-02 17:06:56 -07:00
RD ( " OBJ [%p] pending change %i -> 0, pre %i \n " , obj , obj - > changed , obj - > pre_render_done ) ;
2012-10-08 18:58:41 -07:00
obj - > func - > render_post ( eo_obj , obj ) ;
2012-05-16 06:21:37 -07:00
obj - > pre_render_done = EINA_FALSE ;
2012-10-08 18:58:41 -07:00
evas_object_change_reset ( eo_obj ) ;
2009-11-23 02:07:07 -08:00
}
2008-10-16 05:27:07 -07:00
return obj - > changed ? EINA_TRUE : EINA_FALSE ;
2008-06-04 09:42:39 -07:00
}
2011-01-19 03:59:53 -08:00
2011-10-02 20:28:52 -07:00
static Eina_Bool
2012-10-10 00:23:00 -07:00
_evas_render_can_use_overlay ( Evas_Public_Data * e , Evas_Object * eo_obj )
2011-10-02 20:28:52 -07:00
{
Eina_Rectangle * r ;
2012-10-08 18:58:41 -07:00
Evas_Object * eo_tmp ;
2011-10-02 20:28:52 -07:00
Eina_List * alphas = NULL ;
Eina_List * opaques = NULL ;
Evas_Object * video_parent = NULL ;
Eina_Rectangle zone ;
Evas_Coord xc1 , yc1 , xc2 , yc2 ;
unsigned int i ;
Eina_Bool nooverlay ;
2012-10-10 00:23:00 -07:00
Evas_Object_Protected_Data * obj = eo_data_get ( eo_obj , EVAS_OBJ_CLASS ) ;
Evas_Object_Protected_Data * tmp = NULL ;
2011-10-02 20:28:52 -07:00
2012-10-08 18:58:41 -07:00
video_parent = _evas_object_image_video_parent_get ( eo_obj ) ;
2011-10-02 20:28:52 -07:00
/* Check if any one is the stack make this object mapped */
2012-10-08 18:58:41 -07:00
eo_tmp = eo_obj ;
2012-10-10 00:23:00 -07:00
while ( tmp & & ! _evas_render_has_map ( eo_tmp , tmp ) )
2012-10-08 18:58:41 -07:00
{
2012-10-10 00:23:00 -07:00
tmp = eo_data_get ( eo_tmp , EVAS_OBJ_CLASS ) ;
2012-10-08 18:58:41 -07:00
eo_tmp = tmp - > smart . parent ;
}
2011-10-02 20:28:52 -07:00
2012-10-10 00:23:00 -07:00
if ( tmp & & _evas_render_has_map ( eo_tmp , tmp ) ) return EINA_FALSE ; /* we are mapped, we can't be an overlay */
2011-10-02 20:28:52 -07:00
2012-10-08 18:58:41 -07:00
if ( ! evas_object_is_visible ( eo_obj , obj ) ) return EINA_FALSE ; /* no need to update the overlay if it's not visible */
2011-10-02 20:28:52 -07:00
/* If any recoloring of the surface is needed, n overlay to */
if ( ( obj - > cur . cache . clip . r ! = 255 ) | |
( obj - > cur . cache . clip . g ! = 255 ) | |
( obj - > cur . cache . clip . b ! = 255 ) | |
( obj - > cur . cache . clip . a ! = 255 ) )
return EINA_FALSE ;
/* Check presence of transparent object on top of the video object */
EINA_RECTANGLE_SET ( & zone ,
obj - > cur . cache . clip . x ,
obj - > cur . cache . clip . y ,
obj - > cur . cache . clip . w ,
obj - > cur . cache . clip . h ) ;
for ( i = e - > active_objects . count - 1 ; i > 0 ; i - - )
{
Eina_Rectangle self ;
Eina_Rectangle * match ;
2012-10-08 18:58:41 -07:00
Evas_Object * eo_current ;
2011-10-02 20:28:52 -07:00
Eina_List * l ;
int xm1 , ym1 , xm2 , ym2 ;
2012-10-08 18:58:41 -07:00
Evas_Object_Protected_Data * current = eina_array_data_get ( & e - > active_objects , i ) ;
eo_current = current - > object ;
2011-10-02 20:28:52 -07:00
/* Did we find the video object in the stack ? */
2012-10-08 18:58:41 -07:00
if ( eo_current = = video_parent | | eo_current = = eo_obj )
2011-10-02 20:28:52 -07:00
break ;
EINA_RECTANGLE_SET ( & self ,
current - > cur . cache . clip . x ,
current - > cur . cache . clip . y ,
current - > cur . cache . clip . w ,
current - > cur . cache . clip . h ) ;
/* This doesn't cover the area of the video object, so don't bother with that object */
if ( ! eina_rectangles_intersect ( & zone , & self ) )
2012-05-25 05:55:45 -07:00
continue ;
2011-10-02 20:28:52 -07:00
xc1 = current - > cur . cache . clip . x ;
yc1 = current - > cur . cache . clip . y ;
xc2 = current - > cur . cache . clip . x + current - > cur . cache . clip . w ;
yc2 = current - > cur . cache . clip . y + current - > cur . cache . clip . h ;
2012-10-08 18:58:41 -07:00
if ( evas_object_is_visible ( eo_current , current ) & &
2011-10-02 20:28:52 -07:00
( ! current - > clip . clipees ) & &
( current - > cur . visible ) & &
( ! current - > delete_me ) & &
( current - > cur . cache . clip . visible ) & &
2012-10-08 18:58:41 -07:00
( ! eo_isa ( eo_current , EVAS_OBJ_SMART_CLASS ) ) )
2011-10-02 20:28:52 -07:00
{
Eina_Bool included = EINA_FALSE ;
2012-10-08 18:58:41 -07:00
if ( evas_object_is_opaque ( eo_current , current ) | |
2011-10-02 20:28:52 -07:00
( ( current - > func - > has_opaque_rect ) & &
2012-10-08 18:58:41 -07:00
( current - > func - > has_opaque_rect ( eo_current , current ) ) ) )
2011-10-02 20:28:52 -07:00
{
/* The object is opaque */
/* Check if the opaque object is inside another opaque object */
EINA_LIST_FOREACH ( opaques , l , match )
{
xm1 = match - > x ;
ym1 = match - > y ;
xm2 = match - > x + match - > w ;
ym2 = match - > y + match - > h ;
/* Both object are included */
if ( xc1 > = xm1 & & yc1 > = ym1 & & xc2 < = xm2 & & yc2 < = ym2 )
{
included = EINA_TRUE ;
break ;
}
}
/* Not included yet */
if ( ! included )
{
Eina_List * ln ;
Evas_Coord xn2 , yn2 ;
r = eina_rectangle_new ( current - > cur . cache . clip . x , current - > cur . cache . clip . y ,
current - > cur . cache . clip . w , current - > cur . cache . clip . h ) ;
opaques = eina_list_append ( opaques , r ) ;
xn2 = r - > x + r - > w ;
yn2 = r - > y + r - > h ;
/* Remove all the transparent object that are covered by the new opaque object */
EINA_LIST_FOREACH_SAFE ( alphas , l , ln , match )
{
xm1 = match - > x ;
ym1 = match - > y ;
xm2 = match - > x + match - > w ;
ym2 = match - > y + match - > h ;
if ( xm1 > = r - > x & & ym1 > = r - > y & & xm2 < = xn2 & & ym2 < = yn2 )
{
/* The new rectangle is over some transparent object,
so remove the transparent object */
alphas = eina_list_remove_list ( alphas , l ) ;
}
}
}
}
else
{
/* The object has some transparency */
/* Check if the transparent object is inside any other transparent object */
EINA_LIST_FOREACH ( alphas , l , match )
{
xm1 = match - > x ;
ym1 = match - > y ;
xm2 = match - > x + match - > w ;
ym2 = match - > y + match - > h ;
/* Both object are included */
if ( xc1 > = xm1 & & yc1 > = ym1 & & xc2 < = xm2 & & yc2 < = ym2 )
{
included = EINA_TRUE ;
break ;
}
}
/* If not check if it is inside any opaque one */
if ( ! included )
{
EINA_LIST_FOREACH ( opaques , l , match )
{
xm1 = match - > x ;
ym1 = match - > y ;
xm2 = match - > x + match - > w ;
ym2 = match - > y + match - > h ;
/* Both object are included */
if ( xc1 > = xm1 & & yc1 > = ym1 & & xc2 < = xm2 & & yc2 < = ym2 )
{
included = EINA_TRUE ;
break ;
}
}
}
/* No inclusion at all, so add it */
if ( ! included )
{
r = eina_rectangle_new ( current - > cur . cache . clip . x , current - > cur . cache . clip . y ,
current - > cur . cache . clip . w , current - > cur . cache . clip . h ) ;
alphas = eina_list_append ( alphas , r ) ;
}
}
}
}
/* If there is any pending transparent object, then no overlay */
nooverlay = ! ! eina_list_count ( alphas ) ;
EINA_LIST_FREE ( alphas , r )
eina_rectangle_free ( r ) ;
EINA_LIST_FREE ( opaques , r )
eina_rectangle_free ( r ) ;
if ( nooverlay )
return EINA_FALSE ;
return EINA_TRUE ;
}
2008-06-04 09:42:39 -07:00
2011-08-20 07:40:28 -07:00
Eina_Bool
2012-10-18 04:30:04 -07:00
evas_render_mapped ( Evas_Public_Data * e , Evas_Object * eo_obj ,
Evas_Object_Protected_Data * obj , void * context ,
void * surface , int off_x , int off_y , int mapped , int ecx ,
int ecy , int ecw , int ech , Eina_Bool proxy_render
2012-09-12 12:00:23 -07:00
# ifdef REND_DBG
2009-11-15 05:46:20 -08:00
, int level
2010-04-27 06:43:10 -07:00
# endif
2012-12-18 08:28:55 -08:00
, Eina_Bool do_async )
2009-10-30 03:11:15 -07:00
{
2009-11-06 21:01:43 -08:00
void * ctx ;
2012-10-08 18:58:41 -07:00
Evas_Object_Protected_Data * obj2 ;
2010-05-05 04:36:21 -07:00
Eina_Bool clean_them = EINA_FALSE ;
2009-11-15 05:46:20 -08:00
2012-10-18 04:30:04 -07:00
if ( ( evas_object_is_source_invisible ( eo_obj , obj ) & & ( ! proxy_render ) ) )
return clean_them ;
2012-10-08 18:58:41 -07:00
evas_object_clip_recalc ( eo_obj , obj ) ;
2012-08-16 23:02:49 -07:00
2010-04-27 06:43:10 -07:00
RDI ( level ) ;
2012-06-15 04:42:56 -07:00
RD ( " { evas_render_mapped(%p, %p, %p, %p, %i, %i, %i, %i) \n " , e , obj , context , surface , off_x , off_y , mapped , level ) ;
2009-11-09 07:18:37 -08:00
if ( mapped )
{
2012-10-08 18:58:41 -07:00
if ( ( ! evas_object_is_visible ( eo_obj , obj ) ) | | ( obj - > clip . clipees ) | |
2009-11-09 07:18:37 -08:00
( obj - > cur . have_clipees ) )
2009-11-15 05:46:20 -08:00
{
2010-04-27 06:43:10 -07:00
RDI ( level ) ;
2009-11-15 05:46:20 -08:00
RD ( " } \n " ) ;
2010-05-05 04:36:21 -07:00
return clean_them ;
2009-11-15 05:46:20 -08:00
}
2009-11-09 07:18:37 -08:00
}
2012-10-08 18:58:41 -07:00
else if ( ! ( ( ( evas_object_is_active ( eo_obj , obj ) & & ( ! obj - > clip . clipees ) & &
2012-10-10 00:23:00 -07:00
( _evas_render_can_render ( eo_obj , obj ) ) ) )
2011-05-20 23:23:33 -07:00
) )
2009-11-15 05:46:20 -08:00
{
2010-04-27 06:43:10 -07:00
RDI ( level ) ;
2009-11-15 05:46:20 -08:00
RD ( " } \n " ) ;
2010-05-05 04:36:21 -07:00
return clean_them ;
2009-11-15 05:46:20 -08:00
}
2010-04-27 06:43:10 -07:00
2009-11-23 02:07:07 -08:00
// set render_pre - for child objs that may not have gotten it.
2012-05-16 06:21:37 -07:00
obj - > pre_render_done = EINA_TRUE ;
2011-02-06 15:52:17 -08:00
RD ( " Hasmap: %p (%d) %p %d -> %d \n " , obj - > func - > can_map ,
2012-10-08 18:58:41 -07:00
obj - > func - > can_map ? obj - > func - > can_map ( eo_obj ) : - 1 ,
2011-05-20 23:23:33 -07:00
obj - > cur . map , obj - > cur . usemap ,
2012-10-10 00:23:00 -07:00
_evas_render_has_map ( eo_obj , obj ) ) ;
if ( _evas_render_has_map ( eo_obj , obj ) )
2009-10-30 03:11:15 -07:00
{
2009-10-31 02:08:01 -07:00
int sw , sh ;
2012-05-16 06:21:37 -07:00
Eina_Bool changed = EINA_FALSE , rendered = EINA_FALSE ;
2010-04-27 06:43:10 -07:00
2011-05-20 23:23:33 -07:00
clean_them = EINA_TRUE ;
2010-05-05 04:36:21 -07:00
2009-11-03 07:41:36 -08:00
sw = obj - > cur . geometry . w ;
sh = obj - > cur . geometry . h ;
2010-04-27 06:43:10 -07:00
RDI ( level ) ;
2009-11-15 05:46:20 -08:00
RD ( " mapped obj: %ix%i \n " , sw , sh ) ;
if ( ( sw < = 0 ) | | ( sh < = 0 ) )
{
2010-04-27 06:43:10 -07:00
RDI ( level ) ;
2009-11-15 05:46:20 -08:00
RD ( " } \n " ) ;
2010-05-05 04:36:21 -07:00
return clean_them ;
2009-11-15 05:46:20 -08:00
}
2012-10-08 18:58:41 -07:00
evas_object_map_update ( eo_obj , off_x , off_y , sw , sh , sw , sh ) ;
2010-04-27 06:43:10 -07:00
2012-09-07 01:02:32 -07:00
if ( obj - > map . surface )
2009-10-31 02:08:01 -07:00
{
2012-09-07 01:02:32 -07:00
if ( ( obj - > map . surface_w ! = sw ) | |
( obj - > map . surface_h ! = sh ) )
2009-10-31 02:08:01 -07:00
{
2010-04-27 06:43:10 -07:00
RDI ( level ) ;
2009-11-15 05:46:20 -08:00
RD ( " new surf: %ix%i \n " , sw , sh ) ;
2009-10-31 02:08:01 -07:00
obj - > layer - > evas - > engine . func - > image_map_surface_free
2012-09-07 01:02:32 -07:00
( e - > engine . data . output , obj - > map . surface ) ;
obj - > map . surface = NULL ;
2009-10-31 02:08:01 -07:00
}
}
2012-09-07 01:02:32 -07:00
if ( ! obj - > map . surface )
2009-10-31 02:08:01 -07:00
{
2012-09-07 01:02:32 -07:00
obj - > map . surface_w = sw ;
obj - > map . surface_h = sh ;
2010-04-27 06:43:10 -07:00
2012-09-07 01:02:32 -07:00
obj - > map . surface =
2011-05-20 23:23:33 -07:00
obj - > layer - > evas - > engine . func - > image_map_surface_new
2012-09-07 01:02:32 -07:00
( e - > engine . data . output , obj - > map . surface_w ,
obj - > map . surface_h ,
2011-05-20 23:23:33 -07:00
obj - > cur . map - > alpha ) ;
2010-04-27 06:43:10 -07:00
RDI ( level ) ;
2009-11-15 05:46:20 -08:00
RD ( " fisrt surf: %ix%i \n " , sw , sh ) ;
2012-05-16 06:21:37 -07:00
changed = EINA_TRUE ;
2009-10-31 02:08:01 -07:00
}
2012-10-08 18:58:41 -07:00
if ( obj - > is_smart )
2009-10-30 03:11:15 -07:00
{
2012-10-08 18:58:41 -07:00
Evas_Object * eo_o2 ;
Evas_Object_Protected_Data * o2 ;
2011-05-20 23:23:33 -07:00
2012-10-08 18:58:41 -07:00
EINA_INLIST_FOREACH ( evas_object_smart_members_get_direct ( eo_obj ) , o2 )
2009-10-30 03:11:15 -07:00
{
2012-10-08 18:58:41 -07:00
eo_o2 = o2 - > object ;
if ( ! evas_object_is_visible ( eo_o2 , o2 ) & &
! evas_object_was_visible ( eo_o2 , o2 ) )
2010-09-02 17:06:56 -07:00
{
continue ;
}
2011-05-18 07:12:10 -07:00
if ( o2 - > changed )
2009-10-31 02:08:01 -07:00
{
2012-05-16 06:21:37 -07:00
changed = EINA_TRUE ;
2009-11-06 21:01:43 -08:00
break ;
2009-10-31 02:08:01 -07:00
}
2009-10-30 03:11:15 -07:00
}
2012-05-18 00:17:34 -07:00
if ( obj - > changed_color ) changed = EINA_TRUE ;
2009-10-30 03:11:15 -07:00
}
2012-05-18 00:17:34 -07:00
else if ( obj - > changed )
2009-11-09 07:18:37 -08:00
{
2012-05-18 00:17:34 -07:00
if ( ( ( obj - > changed_pchange ) & & ( obj - > changed_map ) ) | |
( obj - > changed_color ) )
changed = EINA_TRUE ;
2009-11-09 07:18:37 -08:00
}
2010-04-27 06:43:10 -07:00
2012-08-23 12:58:02 -07:00
/* mark the old map as invalid, so later we don't reuse it as a
* cache . */
if ( changed & & obj - > prev . map )
obj - > prev . valid_map = EINA_FALSE ;
2009-10-31 02:08:01 -07:00
// clear surface before re-render
2012-09-07 01:02:32 -07:00
if ( ( changed ) & & ( obj - > map . surface ) )
2009-10-30 03:11:15 -07:00
{
2010-09-01 15:45:30 -07:00
int off_x2 , off_y2 ;
2011-05-20 23:23:33 -07:00
2010-04-27 06:43:10 -07:00
RDI ( level ) ;
2009-11-15 05:46:20 -08:00
RD ( " children redraw \n " ) ;
2009-11-09 07:18:37 -08:00
// FIXME: calculate "changes" within map surface and only clear
// and re-render those
2009-10-31 18:32:23 -07:00
if ( obj - > cur . map - > alpha )
{
ctx = e - > engine . func - > context_new ( e - > engine . data . output ) ;
e - > engine . func - > context_color_set
2011-05-20 23:23:33 -07:00
( e - > engine . data . output , ctx , 0 , 0 , 0 , 0 ) ;
2009-10-31 18:32:23 -07:00
e - > engine . func - > context_render_op_set
2011-05-20 23:23:33 -07:00
( e - > engine . data . output , ctx , EVAS_RENDER_COPY ) ;
2009-10-31 18:32:23 -07:00
e - > engine . func - > rectangle_draw ( e - > engine . data . output ,
ctx ,
2012-09-07 01:02:32 -07:00
obj - > map . surface ,
2010-04-27 06:43:10 -07:00
0 , 0 ,
2012-09-07 01:02:32 -07:00
obj - > map . surface_w ,
2012-12-18 08:28:55 -08:00
obj - > map . surface_h ,
EINA_FALSE ) ;
2009-10-31 18:32:23 -07:00
e - > engine . func - > context_free ( e - > engine . data . output , ctx ) ;
}
2009-10-31 02:08:01 -07:00
ctx = e - > engine . func - > context_new ( e - > engine . data . output ) ;
2010-09-01 15:45:30 -07:00
off_x2 = - obj - > cur . geometry . x ;
off_y2 = - obj - > cur . geometry . y ;
2012-10-08 18:58:41 -07:00
if ( obj - > is_smart )
2009-10-31 02:08:01 -07:00
{
EINA_INLIST_FOREACH
2012-10-08 18:58:41 -07:00
( evas_object_smart_members_get_direct ( eo_obj ) , obj2 )
2011-05-20 23:23:33 -07:00
{
2012-10-18 04:30:04 -07:00
clean_them | = evas_render_mapped ( e , obj2 - > object ,
obj2 , ctx ,
2012-09-07 01:02:32 -07:00
obj - > map . surface ,
2011-05-20 23:23:33 -07:00
off_x2 , off_y2 , 1 ,
2012-10-18 04:30:04 -07:00
ecx , ecy , ecw , ech ,
proxy_render
2012-09-12 12:00:23 -07:00
# ifdef REND_DBG
2011-05-20 23:23:33 -07:00
, level + 1
2009-11-15 05:46:20 -08:00
# endif
2012-12-18 08:28:55 -08:00
, do_async ) ;
2011-05-20 23:23:33 -07:00
}
2009-10-31 02:08:01 -07:00
}
else
2010-04-28 07:38:46 -07:00
{
int x = 0 , y = 0 , w = 0 , h = 0 ;
2010-05-01 06:27:05 -07:00
2012-09-07 01:02:32 -07:00
w = obj - > map . surface_w ;
h = obj - > map . surface_h ;
2010-04-28 07:38:46 -07:00
RECTS_CLIP_TO_RECT ( x , y , w , h ,
2010-09-01 15:45:30 -07:00
obj - > cur . geometry . x + off_x2 ,
obj - > cur . geometry . y + off_y2 ,
2010-05-01 06:27:05 -07:00
obj - > cur . geometry . w ,
obj - > cur . geometry . h ) ;
2011-03-15 09:20:57 -07:00
2010-04-28 07:38:46 -07:00
e - > engine . func - > context_clip_set ( e - > engine . data . output ,
ctx , x , y , w , h ) ;
2012-10-08 18:58:41 -07:00
obj - > func - > render ( eo_obj , obj , e - > engine . data . output , ctx ,
2012-12-18 08:28:55 -08:00
obj - > map . surface , off_x2 , off_y2 ,
EINA_FALSE ) ;
2010-04-28 07:38:46 -07:00
}
2009-10-31 02:08:01 -07:00
e - > engine . func - > context_free ( e - > engine . data . output , ctx ) ;
2012-05-16 06:21:37 -07:00
rendered = EINA_TRUE ;
2009-10-31 02:08:01 -07:00
}
2010-01-26 00:16:36 -08:00
RDI ( level ) ;
2011-02-09 22:52:53 -08:00
RD ( " draw map \n " ) ;
2010-04-27 06:43:10 -07:00
2010-04-30 01:24:55 -07:00
if ( rendered )
{
2012-09-07 01:02:32 -07:00
obj - > map . surface = e - > engine . func - > image_dirty_region
( e - > engine . data . output , obj - > map . surface ,
0 , 0 , obj - > map . surface_w , obj - > map . surface_h ) ;
2012-08-23 12:58:02 -07:00
obj - > cur . valid_map = EINA_TRUE ;
2010-04-30 01:24:55 -07:00
}
2010-09-18 19:28:09 -07:00
e - > engine . func - > context_clip_unset ( e - > engine . data . output ,
2012-07-23 21:27:17 -07:00
context ) ;
2012-09-07 01:02:32 -07:00
if ( obj - > map . surface )
2010-09-01 15:45:30 -07:00
{
2012-08-16 23:16:04 -07:00
if ( obj - > cur . clipper )
2010-09-01 15:45:30 -07:00
{
2012-08-16 23:16:04 -07:00
int x , y , w , h ;
2012-10-10 00:23:00 -07:00
2012-10-08 18:58:41 -07:00
evas_object_clip_recalc ( eo_obj , obj ) ;
2012-08-16 23:16:04 -07:00
x = obj - > cur . cache . clip . x ;
y = obj - > cur . cache . clip . y ;
w = obj - > cur . cache . clip . w ;
h = obj - > cur . cache . clip . h ;
2012-10-08 18:58:41 -07:00
if ( obj - > is_smart )
2010-10-11 02:53:52 -07:00
{
Evas_Object * tobj ;
2011-05-20 23:23:33 -07:00
2012-05-16 06:21:37 -07:00
obj - > cur . cache . clip . dirty = EINA_TRUE ;
2010-10-11 02:53:52 -07:00
tobj = obj - > cur . map_parent ;
2012-10-10 00:23:00 -07:00
obj - > cur . map_parent = obj - > cur . clipper - > cur . map_parent ;
2010-10-11 02:53:52 -07:00
obj - > cur . map_parent = tobj ;
}
2012-08-16 23:16:04 -07:00
RECTS_CLIP_TO_RECT ( x , y , w , h ,
2012-10-10 00:23:00 -07:00
obj - > cur . clipper - > cur . cache . clip . x ,
obj - > cur . clipper - > cur . cache . clip . y ,
obj - > cur . clipper - > cur . cache . clip . w ,
obj - > cur . clipper - > cur . cache . clip . h ) ;
2012-08-16 23:16:04 -07:00
e - > engine . func - > context_clip_set ( e - > engine . data . output ,
context ,
x + off_x , y + off_y , w , h ) ;
2010-09-01 15:45:30 -07:00
}
}
2011-12-15 23:04:00 -08:00
// if (surface == e->engine.data.output)
2011-05-20 23:23:33 -07:00
e - > engine . func - > context_clip_clip ( e - > engine . data . output ,
2012-07-23 21:27:17 -07:00
context ,
2011-05-20 23:23:33 -07:00
ecx , ecy , ecw , ech ) ;
2010-09-01 15:45:30 -07:00
if ( obj - > cur . cache . clip . visible )
2012-03-20 21:04:03 -07:00
{
2012-04-14 20:55:36 -07:00
obj - > layer - > evas - > engine . func - > context_multiplier_unset
2012-07-23 21:27:17 -07:00
( e - > engine . data . output , context ) ;
2013-01-11 11:56:17 -08:00
evas_draw_image_map_async_check
( obj , e - > engine . data . output , context , surface ,
obj - > map . surface , obj - > spans ,
obj - > cur . map - > smooth , 0 , do_async ) ;
2012-03-20 21:04:03 -07:00
}
2009-10-30 03:11:15 -07:00
// FIXME: needs to cache these maps and
// keep them only rendering updates
2011-05-20 23:23:33 -07:00
// obj->layer->evas->engine.func->image_map_surface_free
2012-09-07 01:02:32 -07:00
// (e->engine.data.output, obj->map.surface);
// obj->map.surface = NULL;
2009-10-30 03:11:15 -07:00
}
else
2009-11-06 21:01:43 -08:00
{
2012-06-14 02:58:16 -07:00
if ( 0 & & obj - > cur . cached_surface )
fprintf ( stderr , " We should cache '%s' [%i, %i, %i, %i] \n " ,
2012-10-08 18:58:41 -07:00
evas_object_type_get ( eo_obj ) ,
2012-06-14 02:58:16 -07:00
obj - > cur . bounding_box . x , obj - > cur . bounding_box . x ,
obj - > cur . bounding_box . w , obj - > cur . bounding_box . h ) ;
2009-11-06 21:01:43 -08:00
if ( mapped )
{
2010-04-27 06:43:10 -07:00
RDI ( level ) ;
2009-11-15 05:46:20 -08:00
RD ( " draw child of mapped obj \n " ) ;
2009-11-06 21:01:43 -08:00
ctx = e - > engine . func - > context_new ( e - > engine . data . output ) ;
2012-10-08 18:58:41 -07:00
if ( obj - > is_smart )
2009-11-06 21:01:43 -08:00
{
EINA_INLIST_FOREACH
2012-10-08 18:58:41 -07:00
( evas_object_smart_members_get_direct ( eo_obj ) , obj2 )
2011-05-20 23:23:33 -07:00
{
2012-10-18 04:30:04 -07:00
clean_them | = evas_render_mapped ( e , obj2 - > object ,
obj2 , ctx , surface ,
2011-05-20 23:23:33 -07:00
off_x , off_y , 1 ,
2012-10-18 04:30:04 -07:00
ecx , ecy , ecw , ech ,
proxy_render
2012-09-12 12:00:23 -07:00
# ifdef REND_DBG
2011-05-20 23:23:33 -07:00
, level + 1
2009-11-15 05:46:20 -08:00
# endif
2012-12-18 08:28:55 -08:00
, do_async ) ;
2011-05-20 23:23:33 -07:00
}
2009-11-06 21:01:43 -08:00
}
else
2010-08-24 01:14:46 -07:00
{
2012-08-16 23:02:49 -07:00
RDI ( level ) ;
2011-03-15 09:20:57 -07:00
2012-08-16 23:02:49 -07:00
if ( obj - > cur . clipper )
{
2010-09-25 07:30:02 -07:00
RD ( " clip: %i %i %ix%i [%i %i %ix%i] \n " ,
obj - > cur . cache . clip . x + off_x ,
2011-05-20 23:23:33 -07:00
obj - > cur . cache . clip . y + off_y ,
2010-09-25 07:30:02 -07:00
obj - > cur . cache . clip . w ,
obj - > cur . cache . clip . h ,
obj - > cur . geometry . x + off_x ,
obj - > cur . geometry . y + off_y ,
obj - > cur . geometry . w ,
obj - > cur . geometry . h ) ;
2012-08-16 23:02:49 -07:00
RD ( " clipper: %i %i %ix%i \n " ,
2012-10-10 00:23:00 -07:00
obj - > cur . clipper - > cur . cache . clip . x + off_x ,
obj - > cur . clipper - > cur . cache . clip . y + off_y ,
obj - > cur . clipper - > cur . cache . clip . w ,
obj - > cur . clipper - > cur . cache . clip . h ) ;
2012-08-16 23:02:49 -07:00
int x , y , w , h ;
2012-10-10 00:23:00 -07:00
if ( _evas_render_has_map ( eo_obj , obj ) )
2012-10-08 18:58:41 -07:00
evas_object_clip_recalc ( eo_obj , obj ) ;
2012-08-16 23:02:49 -07:00
x = obj - > cur . cache . clip . x + off_x ;
y = obj - > cur . cache . clip . y + off_y ;
w = obj - > cur . cache . clip . w ;
h = obj - > cur . cache . clip . h ;
RECTS_CLIP_TO_RECT ( x , y , w , h ,
2012-10-10 00:23:00 -07:00
obj - > cur . clipper - > cur . cache . clip . x + off_x ,
obj - > cur . clipper - > cur . cache . clip . y + off_y ,
obj - > cur . clipper - > cur . cache . clip . w ,
obj - > cur . clipper - > cur . cache . clip . h ) ;
2012-08-16 23:02:49 -07:00
2010-09-25 07:30:02 -07:00
e - > engine . func - > context_clip_set ( e - > engine . data . output ,
2011-03-15 09:20:57 -07:00
ctx , x , y , w , h ) ;
2010-09-25 07:30:02 -07:00
}
2012-10-08 18:58:41 -07:00
obj - > func - > render ( eo_obj , obj , e - > engine . data . output , ctx ,
2012-12-18 08:28:55 -08:00
surface , off_x , off_y , EINA_FALSE ) ;
2010-08-24 01:14:46 -07:00
}
2009-11-06 21:01:43 -08:00
e - > engine . func - > context_free ( e - > engine . data . output , ctx ) ;
}
else
2009-11-09 07:18:37 -08:00
{
2011-03-15 09:20:57 -07:00
if ( obj - > cur . clipper )
{
int x , y , w , h ;
2012-10-10 00:23:00 -07:00
if ( _evas_render_has_map ( eo_obj , obj ) )
2012-10-08 18:58:41 -07:00
evas_object_clip_recalc ( eo_obj , obj ) ;
2011-03-15 09:20:57 -07:00
x = obj - > cur . cache . clip . x ;
y = obj - > cur . cache . clip . y ;
w = obj - > cur . cache . clip . w ;
h = obj - > cur . cache . clip . h ;
RECTS_CLIP_TO_RECT ( x , y , w , h ,
2012-10-10 00:23:00 -07:00
obj - > cur . clipper - > cur . cache . clip . x ,
obj - > cur . clipper - > cur . cache . clip . y ,
obj - > cur . clipper - > cur . cache . clip . w ,
obj - > cur . clipper - > cur . cache . clip . h ) ;
2011-03-15 09:20:57 -07:00
e - > engine . func - > context_clip_set ( e - > engine . data . output ,
2012-07-23 21:27:17 -07:00
context ,
2011-03-15 09:20:57 -07:00
x + off_x , y + off_y , w , h ) ;
2011-03-31 03:26:42 -07:00
e - > engine . func - > context_clip_clip ( e - > engine . data . output ,
2012-07-23 21:27:17 -07:00
context ,
2011-03-31 03:26:42 -07:00
ecx , ecy , ecw , ech ) ;
2011-03-15 09:20:57 -07:00
}
2010-04-27 06:43:10 -07:00
RDI ( level ) ;
2009-11-15 05:46:20 -08:00
RD ( " draw normal obj \n " ) ;
2012-10-08 18:58:41 -07:00
obj - > func - > render ( eo_obj , obj , e - > engine . data . output , context , surface ,
2012-12-18 08:28:55 -08:00
off_x , off_y , do_async ) ;
2009-11-09 07:18:37 -08:00
}
2012-05-28 22:13:03 -07:00
if ( obj - > changed_map ) clean_them = EINA_TRUE ;
2009-11-06 21:01:43 -08:00
}
2010-04-27 06:43:10 -07:00
RDI ( level ) ;
2009-11-15 05:46:20 -08:00
RD ( " } \n " ) ;
2010-05-05 04:36:21 -07:00
return clean_them ;
2009-10-30 03:11:15 -07:00
}
2011-10-27 02:39:18 -07:00
static void
2012-10-08 18:58:41 -07:00
_evas_render_cutout_add ( Evas * eo_e , Evas_Object * eo_obj , int off_x , int off_y )
2011-10-27 02:39:18 -07:00
{
2012-10-08 18:58:41 -07:00
Evas_Public_Data * e = eo_data_get ( eo_e , EVAS_CLASS ) ;
Evas_Object_Protected_Data * obj = eo_data_get ( eo_obj , EVAS_OBJ_CLASS ) ;
2012-10-18 04:30:04 -07:00
if ( evas_object_is_source_invisible ( eo_obj , obj ) ) return ;
2012-10-08 18:58:41 -07:00
if ( evas_object_is_opaque ( eo_obj , obj ) )
2011-10-27 02:39:18 -07:00
{
Evas_Coord cox , coy , cow , coh ;
cox = obj - > cur . cache . clip . x ;
coy = obj - > cur . cache . clip . y ;
cow = obj - > cur . cache . clip . w ;
coh = obj - > cur . cache . clip . h ;
if ( ( obj - > cur . map ) & & ( obj - > cur . usemap ) )
{
2012-10-08 18:58:41 -07:00
Evas_Object * eo_oo ;
2012-10-16 05:41:48 -07:00
Evas_Object_Protected_Data * oo ;
2012-05-16 06:21:37 -07:00
2012-10-16 05:41:48 -07:00
eo_oo = eo_obj ;
oo = eo_data_get ( eo_oo , EVAS_OBJ_CLASS ) ;
2011-10-27 02:39:18 -07:00
while ( oo - > cur . clipper )
{
2012-10-10 00:23:00 -07:00
if ( ( oo - > cur . clipper - > cur . map_parent
2011-10-27 02:39:18 -07:00
! = oo - > cur . map_parent ) & &
( ! ( ( oo - > cur . map ) & & ( oo - > cur . usemap ) ) ) )
break ;
RECTS_CLIP_TO_RECT ( cox , coy , cow , coh ,
oo - > cur . geometry . x ,
oo - > cur . geometry . y ,
oo - > cur . geometry . w ,
oo - > cur . geometry . h ) ;
2012-10-10 00:23:00 -07:00
eo_oo = oo - > cur . eo_clipper ;
oo = oo - > cur . clipper ;
2011-10-27 02:39:18 -07:00
}
}
e - > engine . func - > context_cutout_add
( e - > engine . data . output , e - > engine . data . context ,
cox + off_x , coy + off_y , cow , coh ) ;
}
else
{
if ( obj - > func - > get_opaque_rect )
{
Evas_Coord obx , oby , obw , obh ;
2012-05-16 06:21:37 -07:00
2012-10-08 18:58:41 -07:00
obj - > func - > get_opaque_rect ( eo_obj , obj , & obx , & oby , & obw , & obh ) ;
2011-10-27 02:39:18 -07:00
if ( ( obw > 0 ) & & ( obh > 0 ) )
{
obx + = off_x ;
oby + = off_y ;
RECTS_CLIP_TO_RECT ( obx , oby , obw , obh ,
obj - > cur . cache . clip . x + off_x ,
obj - > cur . cache . clip . y + off_y ,
obj - > cur . cache . clip . w ,
obj - > cur . cache . clip . h ) ;
e - > engine . func - > context_cutout_add
( e - > engine . data . output , e - > engine . data . context ,
obx , oby , obw , obh ) ;
}
}
}
}
2012-12-18 08:26:44 -08:00
void
evas_render_rendering_wait ( Evas_Public_Data * evas )
{
while ( evas - > rendering ) evas_async_events_process_blocking ( ) ;
}
2013-01-11 11:54:12 -08:00
static Eina_Bool
_drop_image_cache_ref ( const void * container EINA_UNUSED , void * data , void * fdata EINA_UNUSED )
{
# ifdef EVAS_CSERVE2
if ( evas_cserve2_use_get ( ) )
evas_cache2_image_close ( ( Image_Entry * ) data ) ;
else
# endif
evas_cache_image_drop ( ( Image_Entry * ) data ) ;
return EINA_TRUE ;
}
2012-12-18 08:26:44 -08:00
static Eina_Bool
2012-10-08 18:58:41 -07:00
evas_render_updates_internal ( Evas * eo_e ,
2009-10-28 01:59:01 -07:00
unsigned char make_updates ,
2012-12-18 08:26:44 -08:00
unsigned char do_draw ,
Evas_Render_Done_Cb done_func ,
void * done_data ,
2012-12-18 12:20:45 -08:00
Evas_Event_Cb updates_func , void * updates_data ,
2012-12-18 08:26:44 -08:00
Eina_Bool do_async )
2002-11-08 00:02:15 -08:00
{
2012-10-08 18:58:41 -07:00
Evas_Object * eo_obj ;
Evas_Object_Protected_Data * obj ;
2012-10-10 00:23:00 -07:00
Evas_Public_Data * e ;
2008-10-21 09:31:05 -07:00
Eina_List * ll ;
2002-11-08 00:02:15 -08:00
void * surface ;
2009-06-17 03:01:52 -07:00
Eina_Bool clean_them = EINA_FALSE ;
2009-06-26 06:26:52 -07:00
Eina_Bool alpha ;
2009-06-23 06:57:27 -07:00
Eina_Rectangle * r ;
2002-11-08 00:02:15 -08:00
int ux , uy , uw , uh ;
int cx , cy , cw , ch ;
2008-06-04 09:42:39 -07:00
unsigned int i , j ;
2010-08-23 23:58:07 -07:00
int redraw_all = 0 ;
2012-05-16 06:21:37 -07:00
Eina_Bool haveup = 0 ;
2012-12-19 08:15:58 -08:00
Evas_Render_Mode render_mode = EVAS_RENDER_MODE_UNDEF ;
2005-05-21 19:49:50 -07:00
2012-10-08 18:58:41 -07:00
MAGIC_CHECK ( eo_e , Evas , MAGIC_EVAS ) ;
2012-12-18 08:26:44 -08:00
return EINA_FALSE ;
2002-11-08 00:02:15 -08:00
MAGIC_CHECK_END ( ) ;
2012-10-10 00:23:00 -07:00
e = eo_data_get ( eo_e , EVAS_CLASS ) ;
2012-12-18 08:26:44 -08:00
if ( ! e - > changed ) return EINA_FALSE ;
2013-01-11 10:20:11 -08:00
if ( e - > rendering )
{
2013-01-14 12:02:43 -08:00
if ( do_async )
return EINA_FALSE ;
else
{
WRN ( " Mixing render sync as already doing async "
" render! Syncing! e=%p [%s] " , e ,
e - > engine . module - > definition - > name ) ;
evas_render_rendering_wait ( e ) ;
}
2013-01-11 10:20:11 -08:00
}
2005-05-21 19:49:50 -07:00
2012-05-03 14:01:31 -07:00
# ifdef EVAS_CSERVE2
if ( evas_cserve2_use_get ( ) )
evas_cserve2_dispatch ( ) ;
# endif
2012-10-08 18:58:41 -07:00
evas_call_smarts_calculate ( eo_e ) ;
2010-04-27 06:43:10 -07:00
2009-11-15 05:46:20 -08:00
RD ( " [--- RENDER EVAS (size: %ix%i) \n " , e - > viewport . w , e - > viewport . h ) ;
2010-04-27 06:43:10 -07:00
2012-10-08 18:58:41 -07:00
evas_event_callback_call ( eo_e , EVAS_CALLBACK_RENDER_PRE , NULL ) ;
2012-05-16 06:21:37 -07:00
2008-05-26 06:24:24 -07:00
/* Check if the modified object mean recalculating every thing */
2008-06-04 09:42:39 -07:00
if ( ! e - > invalidate )
2012-10-08 18:58:41 -07:00
_evas_render_check_pending_objects ( & e - > pending_objects , eo_e , e ) ;
2008-05-26 06:24:24 -07:00
2002-11-08 00:02:15 -08:00
/* phase 1. add extra updates for changed objects */
2011-10-21 03:25:35 -07:00
if ( e - > invalidate | | e - > render_objects . count < = 0 )
2012-10-10 00:23:00 -07:00
clean_them = _evas_render_phase1_process ( e ,
2011-03-21 08:18:26 -07:00
& e - > active_objects ,
& e - > restack_objects ,
& e - > delete_objects ,
2010-08-23 23:58:07 -07:00
& e - > render_objects ,
& redraw_all ) ;
2010-04-27 06:43:10 -07:00
2011-10-02 20:28:52 -07:00
/* phase 1.5. check if the video should be inlined or stay in their overlay */
alpha = e - > engine . func - > canvas_alpha_get ( e - > engine . data . output ,
2012-10-16 05:41:48 -07:00
e - > engine . data . context ) ;
2011-10-02 20:28:52 -07:00
2012-10-08 18:58:41 -07:00
EINA_LIST_FOREACH ( e - > video_objects , ll , eo_obj )
2011-10-02 20:28:52 -07:00
{
/* we need the surface to be transparent to display the underlying overlay */
2012-10-10 00:23:00 -07:00
if ( alpha & & _evas_render_can_use_overlay ( e , eo_obj ) )
2012-10-08 18:58:41 -07:00
_evas_object_image_video_overlay_show ( eo_obj ) ;
2011-10-02 20:28:52 -07:00
else
2012-10-08 18:58:41 -07:00
_evas_object_image_video_overlay_hide ( eo_obj ) ;
2011-10-02 20:28:52 -07:00
}
2011-10-13 02:23:42 -07:00
/* phase 1.8. pre render for proxy */
2012-10-10 00:23:00 -07:00
_evas_render_phase1_direct ( e , & e - > active_objects , & e - > restack_objects ,
2011-10-13 02:23:42 -07:00
& e - > delete_objects , & e - > render_objects ) ;
2002-11-08 00:02:15 -08:00
/* phase 2. force updates for restacks */
2008-05-26 06:24:24 -07:00
for ( i = 0 ; i < e - > restack_objects . count ; + + i )
2002-11-08 00:02:15 -08:00
{
2011-05-20 23:23:33 -07:00
obj = eina_array_data_get ( & e - > restack_objects , i ) ;
2012-10-08 18:58:41 -07:00
eo_obj = obj - > object ;
obj - > func - > render_pre ( eo_obj , obj ) ;
2012-10-10 00:23:00 -07:00
_evas_render_prev_cur_clip_cache_add ( e , obj ) ;
2002-11-08 00:02:15 -08:00
}
2008-10-16 05:27:07 -07:00
eina_array_clean ( & e - > restack_objects ) ;
2011-12-26 15:10:27 -08:00
2002-11-08 00:02:15 -08:00
/* phase 3. add exposes */
2009-04-14 02:27:27 -07:00
EINA_LIST_FREE ( e - > damages , r )
2002-11-08 00:02:15 -08:00
{
2010-09-24 23:19:30 -07:00
e - > engine . func - > output_redraws_rect_add ( e - > engine . data . output ,
r - > x , r - > y , r - > w , r - > h ) ;
eina_rectangle_free ( r ) ;
2002-11-08 00:02:15 -08:00
}
2011-12-26 15:10:27 -08:00
2011-12-17 10:45:09 -08:00
/* phase 4. framespace, output & viewport changes */
2003-04-17 05:05:00 -07:00
if ( e - > viewport . changed )
{
2010-09-24 23:19:30 -07:00
e - > engine . func - > output_redraws_rect_add ( e - > engine . data . output ,
0 , 0 ,
e - > output . w , e - > output . h ) ;
2003-04-17 05:05:00 -07:00
}
if ( e - > output . changed )
{
2010-09-24 23:19:30 -07:00
e - > engine . func - > output_resize ( e - > engine . data . output ,
e - > output . w , e - > output . h ) ;
e - > engine . func - > output_redraws_rect_add ( e - > engine . data . output ,
0 , 0 ,
e - > output . w , e - > output . h ) ;
2003-04-17 05:05:00 -07:00
}
2006-11-15 19:20:24 -08:00
if ( ( e - > output . w ! = e - > viewport . w ) | | ( e - > output . h ! = e - > viewport . h ) )
{
2011-05-20 23:23:33 -07:00
ERR ( " viewport size != output size! " ) ;
2006-11-15 19:20:24 -08:00
}
2012-05-25 05:55:45 -07:00
if ( e - > framespace . changed )
2010-08-23 23:58:07 -07:00
{
2012-05-25 05:55:45 -07:00
int fx , fy , fw , fh ;
fx = e - > viewport . x - e - > framespace . x ;
fy = e - > viewport . y - e - > framespace . y ;
fw = e - > viewport . w + e - > framespace . w ;
fh = e - > viewport . h + e - > framespace . h ;
2012-07-30 02:52:33 -07:00
if ( fx < 0 ) fx = 0 ;
if ( fy < 0 ) fy = 0 ;
2010-08-23 23:58:07 -07:00
e - > engine . func - > output_redraws_rect_add ( e - > engine . data . output ,
2012-05-25 05:55:45 -07:00
fx , fy , fw , fh ) ;
}
/* phase 4.5: check if object is not in framespace. if not, we need to clip
* it to the ' master ' clip .
*
* NB : This is for the wayland engine ( s ) . If we do not do this , then
* objects will draw outside the viewport and potentially onto the frame
* itself */
2012-05-25 16:51:21 -07:00
if ( ! strncmp ( e - > engine . module - > definition - > name , " wayland " , 7 ) )
2012-05-25 05:55:45 -07:00
{
Eina_Rectangle clip_rect ;
/* see if the master clip has been added yet, if not, then create */
if ( ! e - > framespace . clip )
{
2012-10-08 18:58:41 -07:00
e - > framespace . clip = evas_object_rectangle_add ( eo_e ) ;
2012-05-25 05:55:45 -07:00
evas_object_color_set ( e - > framespace . clip , 255 , 255 , 255 , 255 ) ;
2012-06-15 04:16:11 -07:00
evas_object_move ( e - > framespace . clip ,
2012-07-30 02:52:33 -07:00
e - > framespace . x , e - > framespace . y ) ;
2012-06-15 04:16:11 -07:00
evas_object_resize ( e - > framespace . clip ,
2012-10-18 04:30:04 -07:00
e - > viewport . w - e - > framespace . w ,
2012-07-30 02:52:33 -07:00
e - > viewport . h - e - > framespace . h ) ;
2012-05-25 05:55:45 -07:00
evas_object_show ( e - > framespace . clip ) ;
}
else
{
/* master clip is already present. check for size changes in the
* viewport , and update master clip size if needed */
2012-10-18 04:30:04 -07:00
if ( ( e - > viewport . changed ) | | ( e - > output . changed ) | |
2012-08-15 03:00:09 -07:00
( e - > framespace . changed ) )
2012-07-30 02:52:33 -07:00
{
2012-10-18 04:30:04 -07:00
evas_object_move ( e - > framespace . clip ,
2012-08-15 03:00:09 -07:00
e - > framespace . x , e - > framespace . y ) ;
2012-07-30 02:52:33 -07:00
evas_object_resize ( e - > framespace . clip ,
e - > viewport . w - e - > framespace . w ,
e - > viewport . h - e - > framespace . h ) ;
}
2012-05-25 05:55:45 -07:00
}
2012-10-18 04:30:04 -07:00
Evas_Object_Protected_Data * framespace_clip =
2012-10-15 03:53:46 -07:00
eo_data_get ( e - > framespace . clip , EVAS_OBJ_CLASS ) ;
2012-06-15 04:16:11 -07:00
EINA_RECTANGLE_SET ( & clip_rect ,
2012-10-08 18:58:41 -07:00
framespace_clip - > cur . geometry . x ,
framespace_clip - > cur . geometry . y ,
framespace_clip - > cur . geometry . w ,
framespace_clip - > cur . geometry . h )
2012-05-25 05:55:45 -07:00
/* With the master clip all setup, we need to loop the objects on this
* canvas and determine if the object is in the viewport space . If it
* is in the viewport space ( and not in framespace ) , then we need to
* clip the object to the master clip so that it does not draw on top
* of the frame ( eg : elm 3 d test ) */
for ( i = 0 ; i < e - > render_objects . count ; + + i )
{
Eina_Rectangle obj_rect ;
Evas_Object * pclip ;
obj = eina_array_data_get ( & e - > render_objects , i ) ;
2012-09-03 01:50:40 -07:00
if ( obj - > is_frame ) continue ;
2012-05-25 05:55:45 -07:00
2012-08-01 07:32:26 -07:00
if ( obj - > delete_me ) continue ;
2012-10-15 03:53:46 -07:00
eo_obj = obj - > object ;
/* skip clipping if the object is itself the
* framespace clip */
if ( eo_obj = = framespace_clip - > object ) continue ;
2012-06-15 04:16:11 -07:00
EINA_RECTANGLE_SET ( & obj_rect ,
2012-05-25 05:55:45 -07:00
obj - > cur . geometry . x , obj - > cur . geometry . y ,
obj - > cur . geometry . w , obj - > cur . geometry . h ) ;
/* if the object does not intersect our clip rect, ignore it */
if ( ! eina_rectangles_intersect ( & clip_rect , & obj_rect ) )
continue ;
2012-10-08 18:58:41 -07:00
if ( ! ( pclip = evas_object_clip_get ( eo_obj ) ) )
2012-05-25 05:55:45 -07:00
{
/* clip this object so it does not draw on the window frame */
2012-10-15 03:53:46 -07:00
evas_object_clip_set ( eo_obj , framespace_clip - > object ) ;
2012-05-25 05:55:45 -07:00
}
}
}
if ( redraw_all )
{
e - > engine . func - > output_redraws_rect_add ( e - > engine . data . output , 0 , 0 ,
2010-08-23 23:58:07 -07:00
e - > output . w , e - > output . h ) ;
}
2011-12-26 15:10:27 -08:00
2003-04-17 05:05:00 -07:00
/* phase 5. add obscures */
2008-10-21 09:31:05 -07:00
EINA_LIST_FOREACH ( e - > obscures , ll , r )
2009-11-06 21:01:43 -08:00
{
2008-10-21 09:31:05 -07:00
e - > engine . func - > output_redraws_rect_del ( e - > engine . data . output ,
2011-05-20 23:23:33 -07:00
r - > x , r - > y , r - > w , r - > h ) ;
2009-11-06 21:01:43 -08:00
}
2002-11-08 00:02:15 -08:00
/* build obscure objects list of active objects that obscure */
2008-05-26 06:24:24 -07:00
for ( i = 0 ; i < e - > active_objects . count ; + + i )
2002-11-08 00:02:15 -08:00
{
2011-05-20 23:23:33 -07:00
obj = eina_array_data_get ( & e - > active_objects , i ) ;
2012-10-08 18:58:41 -07:00
eo_obj = obj - > object ;
if ( UNLIKELY ( ( evas_object_is_opaque ( eo_obj , obj ) | |
2009-02-16 20:53:03 -08:00
( ( obj - > func - > has_opaque_rect ) & &
2012-10-08 18:58:41 -07:00
( obj - > func - > has_opaque_rect ( eo_obj , obj ) ) ) ) & &
evas_object_is_visible ( eo_obj , obj ) & &
2007-06-04 11:31:30 -07:00
( ! obj - > clip . clipees ) & &
( obj - > cur . visible ) & &
( ! obj - > delete_me ) & &
( obj - > cur . cache . clip . visible ) & &
2012-10-08 18:58:41 -07:00
( ! obj - > is_smart ) ) )
2011-05-20 23:23:33 -07:00
/* obscuring_objects = eina_list_append(obscuring_objects, obj); */
eina_array_push ( & e - > obscuring_objects , obj ) ;
2002-11-08 00:02:15 -08:00
}
2011-10-02 20:28:52 -07:00
2002-11-08 00:02:15 -08:00
/* save this list */
2011-05-20 23:23:33 -07:00
/* obscuring_objects_orig = obscuring_objects; */
/* obscuring_objects = NULL; */
2004-02-16 11:22:48 -08:00
/* phase 6. go thru each update rect and render objects in it*/
2007-01-22 04:44:57 -08:00
if ( do_draw )
2002-11-08 00:02:15 -08:00
{
2011-05-20 23:23:33 -07:00
unsigned int offset = 0 ;
2008-06-04 09:42:39 -07:00
2011-05-20 23:23:33 -07:00
while ( ( surface =
e - > engine . func - > output_redraws_next_update_get
2010-09-24 23:19:30 -07:00
( e - > engine . data . output ,
2011-05-20 23:23:33 -07:00
& ux , & uy , & uw , & uh ,
& cx , & cy , & cw , & ch ) ) )
{
int off_x , off_y ;
2012-12-18 08:26:44 -08:00
Render_Updates * ru ;
2008-04-14 02:31:31 -07:00
2009-11-15 05:46:20 -08:00
RD ( " [--- UPDATE %i %i %ix%i \n " , ux , uy , uw , uh ) ;
2012-12-18 08:26:44 -08:00
if ( do_async )
{
ru = malloc ( sizeof ( * ru ) ) ;
ru - > surface = surface ;
NEW_RECT ( ru - > area , ux , uy , uw , uh ) ;
e - > render . updates = eina_list_append ( e - > render . updates , ru ) ;
evas_cache_image_ref ( surface ) ;
}
else if ( make_updates )
2011-05-20 23:23:33 -07:00
{
Eina_Rectangle * rect ;
NEW_RECT ( rect , ux , uy , uw , uh ) ;
if ( rect )
2012-12-18 08:26:44 -08:00
e - > render . updates = eina_list_append ( e - > render . updates ,
rect ) ;
2011-05-20 23:23:33 -07:00
}
2012-05-16 06:21:37 -07:00
haveup = EINA_TRUE ;
2011-05-20 23:23:33 -07:00
off_x = cx - ux ;
off_y = cy - uy ;
/* build obscuring objects list (in order from bottom to top) */
2012-02-20 23:01:39 -08:00
if ( alpha )
{
e - > engine . func - > context_clip_set ( e - > engine . data . output ,
e - > engine . data . context ,
ux + off_x , uy + off_y , uw , uh ) ;
}
2011-05-20 23:23:33 -07:00
for ( i = 0 ; i < e - > obscuring_objects . count ; + + i )
{
2012-10-08 18:58:41 -07:00
obj = ( Evas_Object_Protected_Data * ) eina_array_data_get
2010-09-24 23:19:30 -07:00
( & e - > obscuring_objects , i ) ;
2012-10-08 18:58:41 -07:00
eo_obj = obj - > object ;
if ( evas_object_is_in_output_rect ( eo_obj , obj , ux , uy , uw , uh ) )
2011-05-20 23:23:33 -07:00
{
eina_array_push ( & e - > temporary_objects , obj ) ;
/* reset the background of the area if needed (using cutout and engine alpha flag to help) */
2010-09-24 23:19:30 -07:00
if ( alpha )
2012-10-08 18:58:41 -07:00
_evas_render_cutout_add ( eo_e , eo_obj , off_x , off_y ) ;
2011-05-20 23:23:33 -07:00
}
}
if ( alpha )
{
e - > engine . func - > context_color_set ( e - > engine . data . output ,
e - > engine . data . context ,
2010-09-24 23:19:30 -07:00
0 , 0 , 0 , 0 ) ;
2011-05-20 23:23:33 -07:00
e - > engine . func - > context_multiplier_unset
2010-09-24 23:19:30 -07:00
( e - > engine . data . output , e - > engine . data . context ) ;
2011-05-20 23:23:33 -07:00
e - > engine . func - > context_render_op_set ( e - > engine . data . output ,
2010-09-24 23:19:30 -07:00
e - > engine . data . context ,
EVAS_RENDER_COPY ) ;
2011-05-20 23:23:33 -07:00
e - > engine . func - > rectangle_draw ( e - > engine . data . output ,
e - > engine . data . context ,
surface ,
2012-12-18 08:28:55 -08:00
cx , cy , cw , ch , do_async ) ;
2011-05-20 23:23:33 -07:00
e - > engine . func - > context_cutout_clear ( e - > engine . data . output ,
e - > engine . data . context ) ;
e - > engine . func - > context_clip_unset ( e - > engine . data . output ,
2009-12-30 03:35:40 -08:00
e - > engine . data . context ) ;
2011-05-20 23:23:33 -07:00
}
2012-07-16 04:33:12 -07:00
2011-05-20 23:23:33 -07:00
/* render all object that intersect with rect */
2008-05-26 06:24:24 -07:00
for ( i = 0 ; i < e - > active_objects . count ; + + i )
2011-05-20 23:23:33 -07:00
{
obj = eina_array_data_get ( & e - > active_objects , i ) ;
2012-10-08 18:58:41 -07:00
eo_obj = obj - > object ;
2008-04-14 02:31:31 -07:00
2011-05-20 23:23:33 -07:00
/* if it's in our outpout rect and it doesn't clip anything */
2009-11-15 05:46:20 -08:00
RD ( " OBJ: [%p] '%s' %i %i %ix%i \n " , obj , obj - > type , obj - > cur . geometry . x , obj - > cur . geometry . y , obj - > cur . geometry . w , obj - > cur . geometry . h ) ;
2012-10-08 18:58:41 -07:00
if ( ( evas_object_is_in_output_rect ( eo_obj , obj , ux , uy , uw , uh ) | |
( obj - > is_smart ) ) & &
2011-05-20 23:23:33 -07:00
( ! obj - > clip . clipees ) & &
( obj - > cur . visible ) & &
( ! obj - > delete_me ) & &
( obj - > cur . cache . clip . visible ) & &
2012-10-08 18:58:41 -07:00
// (!obj->is_smart) &&
2011-05-20 23:23:33 -07:00
( ( obj - > cur . color . a > 0 | | obj - > cur . render_op ! = EVAS_RENDER_BLEND ) ) )
{
int x , y , w , h ;
2008-04-14 02:31:31 -07:00
2009-11-15 05:46:20 -08:00
RD ( " DRAW (vis: %i, a: %i, clipees: %p \n " , obj - > cur . visible , obj - > cur . color . a , obj - > clip . clipees ) ;
2011-05-20 23:23:33 -07:00
if ( ( e - > temporary_objects . count > offset ) & &
( eina_array_data_get ( & e - > temporary_objects , offset ) = = obj ) )
offset + + ;
x = cx ; y = cy ; w = cw ; h = ch ;
2012-10-08 18:58:41 -07:00
if ( ( ( w > 0 ) & & ( h > 0 ) ) | | ( obj - > is_smart ) )
2011-05-20 23:23:33 -07:00
{
2012-10-08 18:58:41 -07:00
if ( ! obj - > is_smart )
2010-04-28 07:38:46 -07:00
{
RECTS_CLIP_TO_RECT ( x , y , w , h ,
obj - > cur . cache . clip . x + off_x ,
obj - > cur . cache . clip . y + off_y ,
obj - > cur . cache . clip . w ,
obj - > cur . cache . clip . h ) ;
}
2012-12-05 05:52:59 -08:00
2012-02-20 23:01:39 -08:00
e - > engine . func - > context_clip_set ( e - > engine . data . output ,
e - > engine . data . context ,
x , y , w , h ) ;
2007-01-22 04:44:57 -08:00
# if 1 /* FIXME: this can slow things down... figure out optimum... coverage */
2011-05-20 23:23:33 -07:00
for ( j = offset ; j < e - > temporary_objects . count ; + + j )
{
2012-10-08 18:58:41 -07:00
Evas_Object_Protected_Data * obj2 ;
2008-04-14 02:31:31 -07:00
2012-10-08 18:58:41 -07:00
obj2 = ( Evas_Object_Protected_Data * ) eina_array_data_get
2011-10-27 02:39:18 -07:00
( & e - > temporary_objects , j ) ;
2012-10-08 18:58:41 -07:00
_evas_render_cutout_add ( eo_e , obj2 - > object , off_x , off_y ) ;
2011-05-20 23:23:33 -07:00
}
2005-05-21 19:49:50 -07:00
# endif
2012-10-10 00:23:00 -07:00
clean_them | = evas_render_mapped ( e , eo_obj , obj , e - > engine . data . context ,
2012-10-18 04:30:04 -07:00
surface , off_x ,
off_y , 0 ,
cx , cy , cw , ch ,
EINA_FALSE
2012-09-12 12:00:23 -07:00
# ifdef REND_DBG
2011-05-20 23:23:33 -07:00
, 1
2009-11-15 05:46:20 -08:00
# endif
2012-12-18 08:26:44 -08:00
, do_async ) ;
2011-05-20 23:23:33 -07:00
e - > engine . func - > context_cutout_clear ( e - > engine . data . output ,
e - > engine . data . context ) ;
}
}
}
2012-12-18 08:26:44 -08:00
2012-12-19 08:15:58 -08:00
if ( ! do_async ) render_mode = EVAS_RENDER_MODE_SYNC ;
else render_mode = EVAS_RENDER_MODE_ASYNC_INIT ;
e - > engine . func - > output_redraws_next_update_push ( e - > engine . data . output ,
surface ,
ux , uy , uw , uh ,
render_mode ) ;
2012-12-18 08:26:44 -08:00
2011-05-20 23:23:33 -07:00
/* free obscuring objects list */
eina_array_clean ( & e - > temporary_objects ) ;
2009-11-15 05:46:20 -08:00
RD ( " ---] \n " ) ;
2011-05-20 23:23:33 -07:00
}
2012-12-18 08:26:44 -08:00
if ( do_async )
{
2012-12-28 05:00:37 -08:00
eo_ref ( eo_e ) ;
e - > rendering = EINA_TRUE ;
e - > render . data = updates_data ;
e - > render . updates_cb = updates_func ;
2012-12-30 15:39:11 -08:00
evas_thread_queue_flush ( ( Evas_Thread_Command_Cb ) done_func , done_data ) ;
2012-12-18 08:26:44 -08:00
}
else if ( haveup )
2010-03-16 05:30:55 -07:00
{
2012-10-08 18:58:41 -07:00
evas_event_callback_call ( eo_e , EVAS_CALLBACK_RENDER_FLUSH_PRE , NULL ) ;
2012-12-19 08:15:58 -08:00
e - > engine . func - > output_flush ( e - > engine . data . output ,
EVAS_RENDER_MODE_SYNC ) ;
2012-10-08 18:58:41 -07:00
evas_event_callback_call ( eo_e , EVAS_CALLBACK_RENDER_FLUSH_POST , NULL ) ;
2010-03-16 05:30:55 -07:00
}
2002-11-08 00:02:15 -08:00
}
2012-12-18 08:26:44 -08:00
if ( ! do_async )
{
/* clear redraws */
e - > engine . func - > output_redraws_clear ( e - > engine . data . output ) ;
}
2002-11-08 00:02:15 -08:00
/* and do a post render pass */
2008-05-26 06:24:24 -07:00
for ( i = 0 ; i < e - > active_objects . count ; + + i )
2002-11-08 00:02:15 -08:00
{
2011-05-20 23:23:33 -07:00
obj = eina_array_data_get ( & e - > active_objects , i ) ;
2012-10-08 18:58:41 -07:00
eo_obj = obj - > object ;
2012-05-16 06:21:37 -07:00
obj - > pre_render_done = EINA_FALSE ;
2009-11-23 02:07:07 -08:00
RD ( " OBJ [%p] post... %i %i \n " , obj , obj - > changed , do_draw ) ;
2012-10-19 05:00:57 -07:00
if ( ( clean_them ) | | ( obj - > changed & & do_draw ) )
2009-11-06 00:44:49 -08:00
{
2012-10-19 05:00:57 -07:00
RD ( " OBJ [%p] post... func \n " , obj ) ;
2012-10-08 18:58:41 -07:00
obj - > func - > render_post ( eo_obj , obj ) ;
2012-05-16 06:21:37 -07:00
obj - > restack = EINA_FALSE ;
2012-10-08 18:58:41 -07:00
evas_object_change_reset ( eo_obj ) ;
2009-11-06 00:44:49 -08:00
}
2011-05-20 23:23:33 -07:00
/* moved to other pre-process phase 1
if ( obj - > delete_me = = 2 )
{
delete_objects = eina_list_append ( delete_objects , obj ) ;
}
else if ( obj - > delete_me ! = 0 ) obj - > delete_me + + ;
*/
2002-11-08 00:02:15 -08:00
}
2005-10-26 21:25:30 -07:00
/* free our obscuring object list */
2008-10-16 05:27:07 -07:00
eina_array_clean ( & e - > obscuring_objects ) ;
2008-06-04 09:42:39 -07:00
/* If some object are still marked as changed, do not remove
them from the pending list . */
2008-10-16 05:27:07 -07:00
eina_array_remove ( & e - > pending_objects , pending_change , NULL ) ;
2008-06-04 09:42:39 -07:00
2011-06-13 00:34:44 -07:00
for ( i = 0 ; i < e - > render_objects . count ; + + i )
{
obj = eina_array_data_get ( & e - > render_objects , i ) ;
2012-10-08 18:58:41 -07:00
eo_obj = obj - > object ;
2012-05-16 06:21:37 -07:00
obj - > pre_render_done = EINA_FALSE ;
2012-09-12 11:36:08 -07:00
if ( ( obj - > changed ) & & ( do_draw ) )
{
2012-10-08 18:58:41 -07:00
obj - > func - > render_post ( eo_obj , obj ) ;
2012-09-12 11:36:08 -07:00
obj - > restack = EINA_FALSE ;
2012-10-08 18:58:41 -07:00
evas_object_change_reset ( eo_obj ) ;
2012-09-12 11:36:08 -07:00
}
2011-06-13 00:34:44 -07:00
}
2002-11-08 00:02:15 -08:00
/* delete all objects flagged for deletion now */
2008-05-26 06:24:24 -07:00
for ( i = 0 ; i < e - > delete_objects . count ; + + i )
2002-11-08 00:02:15 -08:00
{
2011-05-20 23:23:33 -07:00
obj = eina_array_data_get ( & e - > delete_objects , i ) ;
2012-10-08 18:58:41 -07:00
eo_obj = obj - > object ;
evas_object_free ( eo_obj , 1 ) ;
2002-11-08 00:02:15 -08:00
}
2008-10-16 05:27:07 -07:00
eina_array_clean ( & e - > delete_objects ) ;
2008-05-26 06:24:24 -07:00
2012-05-16 06:21:37 -07:00
e - > changed = EINA_FALSE ;
e - > viewport . changed = EINA_FALSE ;
e - > output . changed = EINA_FALSE ;
e - > framespace . changed = EINA_FALSE ;
e - > invalidate = EINA_FALSE ;
2008-06-04 09:42:39 -07:00
2012-03-20 01:08:42 -07:00
// always clean... lots of mem waste!
2010-04-27 06:43:10 -07:00
/* If their are some object to restack or some object to delete,
2009-11-09 07:18:37 -08:00
* it ' s useless to keep the render object list around . */
2010-05-05 04:36:21 -07:00
if ( clean_them )
2008-06-04 09:42:39 -07:00
{
2011-05-20 23:23:33 -07:00
eina_array_clean ( & e - > active_objects ) ;
eina_array_clean ( & e - > render_objects ) ;
eina_array_clean ( & e - > restack_objects ) ;
2012-03-20 01:08:42 -07:00
eina_array_clean ( & e - > temporary_objects ) ;
2012-11-20 03:52:16 -08:00
eina_array_foreach ( & e - > clip_changes , _evas_clip_changes_free , NULL ) ;
2012-03-20 01:08:42 -07:00
eina_array_clean ( & e - > clip_changes ) ;
/* we should flush here and have a mempool system for this
eina_array_flush ( & e - > active_objects ) ;
eina_array_flush ( & e - > render_objects ) ;
eina_array_flush ( & e - > restack_objects ) ;
eina_array_flush ( & e - > delete_objects ) ;
eina_array_flush ( & e - > obscuring_objects ) ;
eina_array_flush ( & e - > temporary_objects ) ;
eina_array_flush ( & e - > clip_changes ) ;
*/
2012-05-16 06:21:37 -07:00
e - > invalidate = EINA_TRUE ;
2008-06-04 09:42:39 -07:00
}
2008-04-14 02:31:31 -07:00
2006-09-18 02:40:29 -07:00
evas_module_clean ( ) ;
2012-05-16 06:21:37 -07:00
2012-12-18 08:26:44 -08:00
if ( ! do_async )
evas_event_callback_call ( eo_e , EVAS_CALLBACK_RENDER_POST , NULL ) ;
2008-04-14 02:31:31 -07:00
2009-11-15 05:46:20 -08:00
RD ( " ---] \n " ) ;
2010-04-27 06:43:10 -07:00
2012-12-18 08:26:44 -08:00
return EINA_TRUE ;
}
2013-01-11 11:55:40 -08:00
static Eina_Bool
_drop_glyph_ref ( const void * container EINA_UNUSED , void * data , void * fdata EINA_UNUSED )
{
evas_common_font_glyphs_unref ( data ) ;
return EINA_TRUE ;
}
2013-01-15 09:35:11 -08:00
static Eina_Bool
_drop_texts_ref ( const void * container EINA_UNUSED , void * data , void * fdata EINA_UNUSED )
{
evas_common_font_fonts_unref ( data ) ;
return EINA_TRUE ;
}
2012-12-18 08:26:44 -08:00
static void
evas_render_wakeup ( Evas * eo_e )
{
Render_Updates * ru ;
Eina_Bool haveup = EINA_FALSE ;
Eina_List * ret_updates = NULL ;
Evas_Public_Data * e = eo_data_get ( eo_e , EVAS_CLASS ) ;
2013-01-14 12:02:43 -08:00
Evas_Event_Cb up_cb ;
void * up_data ;
2012-12-18 08:26:44 -08:00
EINA_LIST_FREE ( e - > render . updates , ru )
{
/* punch rect out */
2012-12-19 08:15:58 -08:00
e - > engine . func - > output_redraws_next_update_push
( e - > engine . data . output , ru - > surface ,
ru - > area - > x , ru - > area - > y , ru - > area - > w , ru - > area - > h ,
EVAS_RENDER_MODE_ASYNC_END ) ;
2012-12-18 08:26:44 -08:00
if ( e - > render . updates_cb )
ret_updates = eina_list_append ( ret_updates , ru - > area ) ;
else
eina_rectangle_free ( ru - > area ) ;
evas_cache_image_drop ( ru - > surface ) ;
free ( ru ) ;
haveup = EINA_TRUE ;
}
/* flush redraws */
if ( haveup )
{
evas_event_callback_call ( eo_e , EVAS_CALLBACK_RENDER_FLUSH_PRE , NULL ) ;
2012-12-19 08:15:58 -08:00
e - > engine . func - > output_flush ( e - > engine . data . output ,
EVAS_RENDER_MODE_ASYNC_END ) ;
2012-12-18 08:26:44 -08:00
evas_event_callback_call ( eo_e , EVAS_CALLBACK_RENDER_FLUSH_POST , NULL ) ;
}
/* clear redraws */
e - > engine . func - > output_redraws_clear ( e - > engine . data . output ) ;
2013-01-11 11:55:40 -08:00
/* unref queues */
2013-01-11 11:54:12 -08:00
eina_array_foreach ( & e - > image_unref_queue , _drop_image_cache_ref , NULL ) ;
eina_array_clean ( & e - > image_unref_queue ) ;
2013-01-11 11:55:40 -08:00
eina_array_foreach ( & e - > glyph_unref_queue , _drop_glyph_ref , NULL ) ;
eina_array_clean ( & e - > glyph_unref_queue ) ;
2013-01-15 09:35:11 -08:00
eina_array_foreach ( & e - > texts_unref_queue , _drop_texts_ref , NULL ) ;
eina_array_clean ( & e - > texts_unref_queue ) ;
2013-01-11 11:54:12 -08:00
2013-01-14 12:02:43 -08:00
up_cb = e - > render . updates_cb ;
up_data = e - > render . data ;
2012-12-18 08:26:44 -08:00
e - > render . updates_cb = NULL ;
e - > render . data = NULL ;
2013-01-14 12:02:43 -08:00
e - > rendering = EINA_FALSE ;
evas_event_callback_call ( eo_e , EVAS_CALLBACK_RENDER_POST , NULL ) ;
if ( up_cb ) up_cb ( up_data , eo_e , ret_updates ) ;
2012-12-18 08:26:44 -08:00
eo_unref ( eo_e ) ;
}
static void
evas_render_async_wakeup ( void * target , Evas_Callback_Type type EINA_UNUSED , void * event_info EINA_UNUSED )
{
Evas_Public_Data * e = target ;
evas_render_wakeup ( e - > evas ) ;
}
static void
evas_render_pipe_wakeup ( void * data )
{
evas_async_events_put ( data , 0 , NULL , evas_render_async_wakeup ) ;
2002-11-08 00:02:15 -08:00
}
2006-01-06 15:05:17 -08:00
EAPI void
2008-10-21 09:31:05 -07:00
evas_render_updates_free ( Eina_List * updates )
2002-11-08 00:02:15 -08:00
{
2009-06-23 06:57:27 -07:00
Eina_Rectangle * r ;
2009-04-14 05:15:07 -07:00
EINA_LIST_FREE ( updates , r )
2011-05-20 23:23:33 -07:00
eina_rectangle_free ( r ) ;
2002-11-08 00:02:15 -08:00
}
2012-12-18 08:26:44 -08:00
EAPI Eina_Bool
evas_render_async ( Evas * eo_e , Evas_Event_Cb func , void * data )
{
MAGIC_CHECK ( eo_e , Evas , MAGIC_EVAS ) ;
return EINA_FALSE ;
MAGIC_CHECK_END ( ) ;
Eina_Bool ret = EINA_FALSE ;
eo_do ( eo_e , evas_canvas_render_async ( func , data , & ret ) ) ;
return ret ;
}
void
_canvas_render_async ( Eo * eo_e , void * _pd , va_list * list )
{
Evas_Event_Cb func = va_arg ( * list , Evas_Event_Cb ) ;
void * data = va_arg ( * list , void * ) ;
Eina_Bool * ret = va_arg ( * list , Eina_Bool * ) ;
Evas_Public_Data * e = _pd ;
2012-12-18 12:20:45 -08:00
* ret = evas_render_updates_internal ( eo_e , 1 , 1 , evas_render_pipe_wakeup ,
e , func , data , EINA_TRUE ) ;
2012-12-18 08:26:44 -08:00
}
2008-10-21 09:31:05 -07:00
EAPI Eina_List *
2012-10-08 18:58:41 -07:00
evas_render_updates ( Evas * eo_e )
2005-12-03 01:27:53 -08:00
{
2012-10-08 18:58:41 -07:00
MAGIC_CHECK ( eo_e , Evas , MAGIC_EVAS ) ;
2005-12-03 01:27:53 -08:00
return NULL ;
MAGIC_CHECK_END ( ) ;
2012-10-08 18:58:41 -07:00
Eina_List * ret = NULL ;
eo_do ( eo_e , evas_canvas_render_updates ( & ret ) ) ;
return ret ;
}
2008-04-14 02:31:31 -07:00
2012-12-18 08:26:44 -08:00
static Eina_List *
evas_render_updates_internal_wait ( Evas * eo_e ,
unsigned char make_updates ,
unsigned char do_draw )
{
Eina_List * ret = NULL ;
Evas_Public_Data * e = eo_data_get ( eo_e , EVAS_CLASS ) ;
2012-12-18 12:20:45 -08:00
if ( ! evas_render_updates_internal ( eo_e , make_updates , do_draw , NULL ,
NULL , NULL , NULL , EINA_FALSE ) )
2012-12-18 08:26:44 -08:00
return NULL ;
ret = e - > render . updates ;
e - > render . updates = NULL ;
return ret ;
}
2012-10-08 18:58:41 -07:00
void
_canvas_render_updates ( Eo * eo_e , void * _pd , va_list * list )
{
Eina_List * * ret = va_arg ( * list , Eina_List * * ) ;
Evas_Public_Data * e = _pd ;
if ( ! e - > changed )
{
* ret = NULL ;
return ;
}
2012-12-18 08:26:44 -08:00
* ret = evas_render_updates_internal_wait ( eo_e , 1 , 1 ) ;
2005-12-03 01:27:53 -08:00
}
2006-01-06 15:05:17 -08:00
EAPI void
2012-10-08 18:58:41 -07:00
evas_render ( Evas * eo_e )
2002-11-08 00:02:15 -08:00
{
2012-10-08 18:58:41 -07:00
MAGIC_CHECK ( eo_e , Evas , MAGIC_EVAS ) ;
2002-11-08 00:02:15 -08:00
return ;
MAGIC_CHECK_END ( ) ;
2012-10-08 18:58:41 -07:00
eo_do ( eo_e , evas_canvas_render ( ) ) ;
}
void
_canvas_render ( Eo * eo_e , void * _pd , va_list * list EINA_UNUSED )
{
Evas_Public_Data * e = _pd ;
2002-11-08 00:02:15 -08:00
2006-09-18 02:40:29 -07:00
if ( ! e - > changed ) return ;
2012-12-18 08:26:44 -08:00
evas_render_updates_internal_wait ( eo_e , 0 , 1 ) ;
2007-01-16 02:17:10 -08:00
}
EAPI void
2012-10-08 18:58:41 -07:00
evas_norender ( Evas * eo_e )
2007-01-16 02:17:10 -08:00
{
2012-10-08 18:58:41 -07:00
MAGIC_CHECK ( eo_e , Evas , MAGIC_EVAS ) ;
2007-01-16 02:17:10 -08:00
return ;
MAGIC_CHECK_END ( ) ;
2012-10-08 18:58:41 -07:00
eo_do ( eo_e , evas_canvas_norender ( ) ) ;
}
2008-04-14 02:31:31 -07:00
2012-10-08 18:58:41 -07:00
void
_canvas_norender ( Eo * eo_e , void * _pd EINA_UNUSED , va_list * list EINA_UNUSED )
{
2011-05-20 23:23:33 -07:00
// if (!e->changed) return;
2012-12-18 08:26:44 -08:00
evas_render_updates_internal_wait ( eo_e , 0 , 0 ) ;
2002-11-08 00:02:15 -08:00
}
2007-01-16 02:17:10 -08:00
2007-06-16 19:56:59 -07:00
EAPI void
2012-10-08 18:58:41 -07:00
evas_render_idle_flush ( Evas * eo_e )
2007-06-16 19:56:59 -07:00
{
2012-10-08 18:58:41 -07:00
MAGIC_CHECK ( eo_e , Evas , MAGIC_EVAS ) ;
2007-06-16 19:56:59 -07:00
return ;
MAGIC_CHECK_END ( ) ;
2012-10-08 18:58:41 -07:00
eo_do ( eo_e , evas_canvas_render_idle_flush ( ) ) ;
}
2007-06-16 19:56:59 -07:00
2012-10-08 18:58:41 -07:00
void
_canvas_render_idle_flush ( Eo * eo_e , void * _pd , va_list * list EINA_UNUSED )
{
Evas_Public_Data * e = _pd ;
evas_fonts_zero_presure ( eo_e ) ;
2009-06-15 07:37:14 -07:00
2007-06-16 19:56:59 -07:00
if ( ( e - > engine . func ) & & ( e - > engine . func - > output_idle_flush ) & &
( e - > engine . data . output ) )
e - > engine . func - > output_idle_flush ( e - > engine . data . output ) ;
2008-05-26 06:24:24 -07:00
2008-10-16 05:27:07 -07:00
eina_array_flush ( & e - > active_objects ) ;
eina_array_flush ( & e - > render_objects ) ;
2012-03-20 01:08:42 -07:00
eina_array_flush ( & e - > restack_objects ) ;
eina_array_flush ( & e - > delete_objects ) ;
eina_array_flush ( & e - > obscuring_objects ) ;
eina_array_flush ( & e - > temporary_objects ) ;
2012-11-20 03:52:16 -08:00
eina_array_foreach ( & e - > clip_changes , _evas_clip_changes_free , NULL ) ;
2009-04-15 06:40:37 -07:00
eina_array_flush ( & e - > clip_changes ) ;
2008-06-04 09:42:39 -07:00
2012-05-16 06:21:37 -07:00
e - > invalidate = EINA_TRUE ;
2007-06-16 19:56:59 -07:00
}
2008-05-26 06:24:24 -07:00
2010-05-21 00:10:45 -07:00
EAPI void
2012-10-08 18:58:41 -07:00
evas_sync ( Evas * eo_e )
2010-05-21 00:10:45 -07:00
{
2012-10-08 18:58:41 -07:00
eo_do ( eo_e , evas_canvas_sync ( ) ) ;
2010-05-21 00:10:45 -07:00
}
2012-10-08 18:58:41 -07:00
void
2012-12-19 10:03:38 -08:00
_canvas_sync ( Eo * eo_e , void * _pd EINA_UNUSED , va_list * list EINA_UNUSED )
2012-10-08 18:58:41 -07:00
{
2012-12-19 10:03:38 -08:00
Evas_Public_Data * e = eo_data_get ( eo_e , EVAS_CLASS ) ;
evas_render_rendering_wait ( e ) ;
2012-10-08 18:58:41 -07:00
}
void
_evas_render_dump_map_surfaces ( Evas_Object * eo_obj )
2010-04-12 01:23:53 -07:00
{
2012-10-08 18:58:41 -07:00
Evas_Object_Protected_Data * obj = eo_data_get ( eo_obj , EVAS_OBJ_CLASS ) ;
2012-09-07 01:02:32 -07:00
if ( ( obj - > cur . map ) & & obj - > map . surface )
2010-04-12 01:23:53 -07:00
{
obj - > layer - > evas - > engine . func - > image_map_surface_free
2012-09-07 01:02:32 -07:00
( obj - > layer - > evas - > engine . data . output , obj - > map . surface ) ;
obj - > map . surface = NULL ;
2010-04-12 01:23:53 -07:00
}
2010-04-27 06:43:10 -07:00
2012-10-08 18:58:41 -07:00
if ( obj - > is_smart )
2010-04-12 01:23:53 -07:00
{
2012-10-08 18:58:41 -07:00
Evas_Object_Protected_Data * obj2 ;
2010-04-27 06:43:10 -07:00
2012-10-08 18:58:41 -07:00
EINA_INLIST_FOREACH ( evas_object_smart_members_get_direct ( eo_obj ) , obj2 )
_evas_render_dump_map_surfaces ( obj2 - > object ) ;
2010-04-12 01:23:53 -07:00
}
}
EAPI void
2012-10-08 18:58:41 -07:00
evas_render_dump ( Evas * eo_e )
2010-04-12 01:23:53 -07:00
{
2012-10-08 18:58:41 -07:00
MAGIC_CHECK ( eo_e , Evas , MAGIC_EVAS ) ;
2010-04-12 01:23:53 -07:00
return ;
MAGIC_CHECK_END ( ) ;
2012-10-08 18:58:41 -07:00
eo_do ( eo_e , evas_canvas_render_dump ( ) ) ;
}
void
_canvas_render_dump ( Eo * eo_e EINA_UNUSED , void * _pd , va_list * list EINA_UNUSED )
{
Evas_Layer * lay ;
2010-04-12 01:23:53 -07:00
2012-10-08 18:58:41 -07:00
Evas_Public_Data * e = _pd ;
2010-04-12 01:23:53 -07:00
EINA_INLIST_FOREACH ( e - > layers , lay )
{
2012-10-08 18:58:41 -07:00
Evas_Object_Protected_Data * obj ;
2010-04-12 01:23:53 -07:00
EINA_INLIST_FOREACH ( lay - > objects , obj )
2010-12-24 08:04:27 -08:00
{
if ( ( obj - > type ) & & ( ! strcmp ( obj - > type , " image " ) ) )
2012-10-08 18:58:41 -07:00
evas_object_inform_call_image_unloaded ( obj - > object ) ;
_evas_render_dump_map_surfaces ( obj - > object ) ;
2010-12-24 08:04:27 -08:00
}
2010-04-12 01:23:53 -07:00
}
if ( ( e - > engine . func ) & & ( e - > engine . func - > output_dump ) & &
( e - > engine . data . output ) )
e - > engine . func - > output_dump ( e - > engine . data . output ) ;
}
2008-05-26 06:24:24 -07:00
void
2012-10-08 18:58:41 -07:00
evas_render_invalidate ( Evas * eo_e )
2008-05-26 06:24:24 -07:00
{
2012-10-10 00:23:00 -07:00
Evas_Public_Data * e ;
2012-10-08 18:58:41 -07:00
MAGIC_CHECK ( eo_e , Evas , MAGIC_EVAS ) ;
2008-05-26 06:24:24 -07:00
return ;
MAGIC_CHECK_END ( ) ;
2012-10-10 00:23:00 -07:00
e = eo_data_get ( eo_e , EVAS_CLASS ) ;
2008-05-26 06:24:24 -07:00
2008-10-16 05:27:07 -07:00
eina_array_clean ( & e - > active_objects ) ;
eina_array_clean ( & e - > render_objects ) ;
2008-06-04 09:42:39 -07:00
2008-10-16 05:27:07 -07:00
eina_array_flush ( & e - > restack_objects ) ;
eina_array_flush ( & e - > delete_objects ) ;
2008-06-04 09:42:39 -07:00
2012-05-16 06:21:37 -07:00
e - > invalidate = EINA_TRUE ;
2008-05-26 06:24:24 -07:00
}
void
2012-10-08 18:58:41 -07:00
evas_render_object_recalc ( Evas_Object * eo_obj )
2008-05-26 06:24:24 -07:00
{
2012-10-10 00:23:00 -07:00
Evas_Object_Protected_Data * obj ;
2012-10-08 18:58:41 -07:00
MAGIC_CHECK ( eo_obj , Evas_Object , MAGIC_OBJ ) ;
2008-05-26 06:24:24 -07:00
return ;
MAGIC_CHECK_END ( ) ;
2012-10-10 00:23:00 -07:00
obj = eo_data_get ( eo_obj , EVAS_OBJ_CLASS ) ;
2008-06-12 06:22:26 -07:00
if ( ( ! obj - > changed ) & & ( obj - > delete_me < 2 ) )
2012-04-26 02:53:03 -07:00
{
2012-10-08 18:58:41 -07:00
Evas_Public_Data * e ;
2012-05-16 06:21:37 -07:00
2012-04-26 02:53:03 -07:00
e = obj - > layer - > evas ;
if ( ( ! e ) | | ( e - > cleanup ) ) return ;
eina_array_push ( & e - > pending_objects , obj ) ;
2012-05-16 06:21:37 -07:00
obj - > changed = EINA_TRUE ;
2012-04-26 02:53:03 -07:00
}
2008-05-26 06:24:24 -07:00
}
2011-02-06 15:50:19 -08:00
2013-01-11 11:54:12 -08:00
void
evas_unref_queue_image_put ( Evas_Public_Data * pd , void * image )
{
eina_array_push ( & pd - > image_unref_queue , image ) ;
}
2013-01-11 11:55:40 -08:00
void
evas_unref_queue_glyph_put ( Evas_Public_Data * pd , void * glyph )
{
eina_array_push ( & pd - > glyph_unref_queue , glyph ) ;
}
2013-01-15 09:35:11 -08:00
void
evas_unref_queue_texts_put ( Evas_Public_Data * pd , void * texts )
{
eina_array_push ( & pd - > texts_unref_queue , texts ) ;
}
2011-02-06 15:50:19 -08:00
/* vim:set ts=8 sw=3 sts=3 expandtab cino=>5n-2f0^-2{2(0W1st0 :*/