kimcinoo
/
efl
forked from enlightenment/efl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

* edje: Add a cache for _edje_part_recalc_single. 

WARNING: THIS CAN CAUSE RENDERING GLITCH AND OTHER WEIRD BEHAVIOUR WITH
	YOUR EDJE FILE. PLEASE REPORT ANY ALIEN STUFF.

	Note: This patch cache the result of _edje_part_recalc_single, until
	any relative part are moved, the object is resized or some property
	are changed (like during text set or color class set).

	Note: Be carefull when you call edje_object_size_min_restricted_calc,
	it's really an inderect heavy user of _edje_part_recalc_single and
	I wasn't able to bring it down.

	Note: This patch use more RAM, around 480 bytes per Edje state, so I
	don't recommand using it on a Desktop with a lot of CPU power.


SVN revision: 41663
This commit is contained in:
Cedric BAIL 2009-08-10 15:16:51 +00:00
parent ee729dd97f
commit 7f9a41a824
8 changed files with 406 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
legacy/edje/configure.ac
View File

@ -99,6 +99,22 @@ if test "x${want_edje_program_cache}" = "xyes" ; then
AC_DEFINE(EDJE_PROGRAM_CACHE, 1, [Cache result of program glob matches - this uses up extra ram with the gain of faster program matching])
fi
# Optional EDJE_CALC_CACHE (use more ram, but increase speed by reducing the need to recalculate static stuff)
want_edje_calc_cache="no"
AC_ARG_ENABLE([edje-calc-cache],
[AC_HELP_STRING(
[--enable-edje-calc-cache],
[enable EDJE_CALC_CACHE support. [[default=disabled]]]
)],
[want_edje_calc_cache=$enableval]
)
AM_CONDITIONAL(EDJE_CALC_CACHE, test "x${want_edje_calc_cache}" = "xyes")
if test "x${want_edje_calc_cache}" = "xyes" ; then
AC_DEFINE(EDJE_CALC_CACHE, 1, [Cache result of edje_part_recalc - this uses up extra ram with the gain of reducing CPU usage when edje object are not resized])
fi
install_vim="yes"
AC_ARG_WITH([vim],
[AC_HELP_STRING([--with-vim=DIR], [Location of Vim data files [[autodetect]]])],
@ -284,6 +300,8 @@ echo " Ecore IMF............: $have_ecore_imf"
echo
echo " EDJE_PROGRAM_CACHE...: $want_edje_program_cache"
echo
echo " EDJE_CALC_CACHE......: $want_edje_calc_cache"
echo
echo " Build binaries.......: $have_edje_cc"
echo
echo " Documentation........: ${build_doc}"

318
legacy/edje/src/lib/edje_calc.c
View File

@ -46,6 +46,9 @@ _edje_part_pos_set(Edje *ed, Edje_Real_Part *ep, int mode, double pos)
ep->description_pos = npos;
ed->dirty = 1;
#ifdef EDJE_CALC_CACHE
ep->invalidate = 1;
#endif
}
Edje_Part_Description *
@ -132,6 +135,9 @@ _edje_part_description_apply(Edje *ed, Edje_Real_Part *ep, const char *d1, doubl
ep->chosen_description = ep->param2.description;
ed->dirty = 1;
#ifdef EDJE_CALC_CACHE
ep->invalidate = 1;
#endif
}
void
@ -163,6 +169,7 @@ _edje_recalc_do(Edje *ed)
return;
}
ed->dirty = 0;
ed->state++;
for (i = 0; i < ed->table_parts_size; i++)
{
Edje_Real_Part *ep;
@ -180,6 +187,10 @@ _edje_recalc_do(Edje *ed)
_edje_part_recalc(ed, ep, (~ep->calculated) & FLAG_XY);
}
if (!ed->calc_only) ed->recalc = 0;
#ifdef EDJE_CALC_CACHE
ed->all_part_change = 0;
ed->text_part_change = 0;
#endif
}
int
@ -252,6 +263,9 @@ _edje_dragable_pos_set(Edje *ed, Edje_Real_Part *ep, double x, double y)
ed->dirty = 1;
}
#ifdef EDJE_CALC_CACHE
ep->invalidate = 1;
#endif
_edje_recalc(ed); /* won't do anything if dirty flag isn't set */
}
@ -1381,7 +1395,14 @@ _edje_image_recalc_apply(Edje *ed, Edje_Real_Part *ep, Edje_Calc_Params *p3, Edj
static void
_edje_part_recalc(Edje *ed, Edje_Real_Part *ep, int flags)
{
Edje_Calc_Params p1, p3, *pf;
#ifdef EDJE_CALC_CACHE
int state1 = -1;
int state2 = -1;
int statec = -1;
#else
Edje_Calc_Params lp1, lp2;
#endif
Edje_Calc_Params *p1, *pf;
Edje_Part_Description *chosen_desc;
double pos = 0.0;
@ -1421,20 +1442,80 @@ _edje_part_recalc(Edje *ed, Edje_Real_Part *ep, int flags)
if (flags & FLAG_X)
{
ep->calculating |= flags & FLAG_X;
if (ep->param1.rel1_to_x) _edje_part_recalc(ed, ep->param1.rel1_to_x, FLAG_X);
if (ep->param1.rel2_to_x) _edje_part_recalc(ed, ep->param1.rel2_to_x, FLAG_X);
if (ep->param2.rel1_to_x) _edje_part_recalc(ed, ep->param2.rel1_to_x, FLAG_X);
if (ep->param2.rel2_to_x) _edje_part_recalc(ed, ep->param2.rel2_to_x, FLAG_X);
if (ep->param1.rel1_to_x)
{
_edje_part_recalc(ed, ep->param1.rel1_to_x, FLAG_X);
#ifdef EDJE_CALC_CACHE
state1 = ep->param1.rel1_to_x->state;
#endif
}
if (ep->param1.rel2_to_x)
{
_edje_part_recalc(ed, ep->param1.rel2_to_x, FLAG_X);
#ifdef EDJE_CALC_CACHE
if (state1 < ep->param1.rel2_to_x->state)
state1 = ep->param1.rel2_to_x->state;
#endif
}
if (ep->param2.rel1_to_x)
{
_edje_part_recalc(ed, ep->param2.rel1_to_x, FLAG_X);
#ifdef EDJE_CALC_CACHE
state2 = ep->param2.rel1_to_x->state;
#endif
}
if (ep->param2.rel2_to_x)
{
_edje_part_recalc(ed, ep->param2.rel2_to_x, FLAG_X);
#ifdef EDJE_CALC_CACHE
if (state2 < ep->param2.rel2_to_x->state)
state2 = ep->param2.rel2_to_x->state;
#endif
}
}
if (flags & FLAG_Y)
{
ep->calculating |= flags & FLAG_Y;
if (ep->param1.rel1_to_y) _edje_part_recalc(ed, ep->param1.rel1_to_y, FLAG_Y);
if (ep->param1.rel2_to_y) _edje_part_recalc(ed, ep->param1.rel2_to_y, FLAG_Y);
if (ep->param2.rel1_to_y) _edje_part_recalc(ed, ep->param2.rel1_to_y, FLAG_Y);
if (ep->param2.rel2_to_y) _edje_part_recalc(ed, ep->param2.rel2_to_y, FLAG_Y);
if (ep->param1.rel1_to_y)
{
_edje_part_recalc(ed, ep->param1.rel1_to_y, FLAG_Y);
#ifdef EDJE_CALC_CACHE
if (state1 < ep->param1.rel1_to_y->state)
state1 = ep->param1.rel1_to_y->state;
#endif
}
if (ep->param1.rel2_to_y)
{
_edje_part_recalc(ed, ep->param1.rel2_to_y, FLAG_Y);
#ifdef EDJE_CALC_CACHE
if (state1 < ep->param1.rel2_to_y->state)
state1 = ep->param1.rel2_to_y->state;
#endif
}
if (ep->param2.rel1_to_y)
{
_edje_part_recalc(ed, ep->param2.rel1_to_y, FLAG_Y);
#ifdef EDJE_CALC_CACHE
if (state2 < ep->param2.rel1_to_y->state)
state2 = ep->param2.rel1_to_y->state;
#endif
}
if (ep->param2.rel2_to_y)
{
_edje_part_recalc(ed, ep->param2.rel2_to_y, FLAG_Y);
#ifdef EDJE_CALC_CACHE
if (state2 < ep->param2.rel2_to_y->state)
state2 = ep->param2.rel2_to_y->state;
#endif
}
}
if (ep->confine_to)
{
_edje_part_recalc(ed, ep->confine_to, flags);
#ifdef EDJE_CALC_CACHE
statec = ep->confine_to->state;
#endif
}
if (ep->confine_to) _edje_part_recalc(ed, ep->confine_to, flags);
// if (ep->text.source) _edje_part_recalc(ed, ep->text.source, flags);
// if (ep->text.text_source) _edje_part_recalc(ed, ep->text.text_source, flags);
@ -1446,113 +1527,162 @@ _edje_part_recalc(Edje *ed, Edje_Real_Part *ep, int flags)
ep->calculated |= flags;
return;
}
#ifndef EDJE_CALC_CACHE
p1 = &lp1;
#else
p1 = ep->param2.description ? &ep->param1.p : &ep->p;
#endif
if (ep->param1.description)
_edje_part_recalc_single(ed, ep, ep->param1.description, chosen_desc,
ep->param1.rel1_to_x, ep->param1.rel1_to_y, ep->param1.rel2_to_x, ep->param1.rel2_to_y,
ep->confine_to,
&p1,
flags);
{
#ifdef EDJE_CALC_CACHE
if (ed->all_part_change ||
ep->invalidate ||
state1 >= ep->param1.state ||
statec >= ep->param1.state ||
((ep->part->type == EDJE_PART_TYPE_TEXT || ep->part->type == EDJE_PART_TYPE_TEXTBLOCK) && ed->text_part_change))
#endif
{
_edje_part_recalc_single(ed, ep, ep->param1.description, chosen_desc,
ep->param1.rel1_to_x, ep->param1.rel1_to_y, ep->param1.rel2_to_x, ep->param1.rel2_to_y,
ep->confine_to,
p1,
flags);
#ifdef EDJE_CALC_CACHE
ep->param1.state = ed->state;
#endif
}
}
if (ep->param2.description)
{
int beginning_pos, part_type;
Edje_Calc_Params p2;
Edje_Calc_Params *p2, *p3;
#ifndef EDJE_CALC_CACHE
Edje_Calc_Params lp3;
_edje_part_recalc_single(ed, ep, ep->param2.description, chosen_desc,
ep->param2.rel1_to_x, ep->param2.rel1_to_y, ep->param2.rel2_to_x, ep->param2.rel2_to_y,
ep->confine_to,
&p2,
flags);
p2 = &lp2;
p3 = &lp3;
#else
p2 = &ep->param2.p;
p3 = &ep->p;
pos = ep->description_pos;
beginning_pos = (pos < 0.5);
part_type = ep->part->type;
if (ed->all_part_change ||
ep->invalidate ||
state2 >= ep->param2.state ||
statec >= ep->param2.state ||
((ep->part->type == EDJE_PART_TYPE_TEXT || ep->part->type == EDJE_PART_TYPE_TEXTBLOCK) && ed->text_part_change))
#endif
{
_edje_part_recalc_single(ed, ep, ep->param2.description, chosen_desc,
ep->param2.rel1_to_x, ep->param2.rel1_to_y, ep->param2.rel2_to_x, ep->param2.rel2_to_y,
ep->confine_to,
p2,
flags);
#ifdef EDJE_CALC_CACHE
ep->param2.state = ed->state;
#endif
}
/* visible is special */
if ((p1.visible) && (!p2.visible))
p3.visible = (pos != 1.0);
else if ((!p1.visible) && (p2.visible))
p3.visible = (pos != 0.0);
else
p3.visible = p1.visible;
pos = ep->description_pos;
beginning_pos = (pos < 0.5);
part_type = ep->part->type;
p3.smooth = (beginning_pos) ? p1.smooth : p2.smooth;
/* visible is special */
if ((p1->visible) && (!p2->visible))
p3->visible = (pos != 1.0);
else if ((!p1->visible) && (p2->visible))
p3->visible = (pos != 0.0);
else
p3->visible = p1->visible;
/* FIXME: do x and y separately base on flag */
p3->smooth = (beginning_pos) ? p1->smooth : p2->smooth;
/* FIXME: do x and y separately base on flag */
#define INTP(_x1, _x2, _p) (((_x1) == (_x2)) ? (_x1) : ((_x1) + (((_x2) - (_x1)) * (_p))))
p3.x = INTP(p1.x, p2.x, pos);
p3.y = INTP(p1.y, p2.y, pos);
p3.w = INTP(p1.w, p2.w, pos);
p3.h = INTP(p1.h, p2.h, pos);
p3->x = INTP(p1->x, p2->x, pos);
p3->y = INTP(p1->y, p2->y, pos);
p3->w = INTP(p1->w, p2->w, pos);
p3->h = INTP(p1->h, p2->h, pos);
p3.req.x = INTP(p1.req.x, p2.req.x, pos);
p3.req.y = INTP(p1.req.y, p2.req.y, pos);
p3.req.w = INTP(p1.req.w, p2.req.w, pos);
p3.req.h = INTP(p1.req.h, p2.req.h, pos);
p3->req.x = INTP(p1->req.x, p2->req.x, pos);
p3->req.y = INTP(p1->req.y, p2->req.y, pos);
p3->req.w = INTP(p1->req.w, p2->req.w, pos);
p3->req.h = INTP(p1->req.h, p2->req.h, pos);
if (ep->part->dragable.x)
if (ep->part->dragable.x)
{
p3.req_drag.x = INTP(p1.req_drag.x, p2.req_drag.x, pos);
p3.req_drag.w = INTP(p1.req_drag.w, p2.req_drag.w, pos);
}
if (ep->part->dragable.y)
{
p3.req_drag.y = INTP(p1.req_drag.y, p2.req_drag.y, pos);
p3.req_drag.h = INTP(p1.req_drag.h, p2.req_drag.h, pos);
}
p3->req_drag.x = INTP(p1->req_drag.x, p2->req_drag.x, pos);
p3->req_drag.w = INTP(p1->req_drag.w, p2->req_drag.w, pos);
}
if (ep->part->dragable.y)
{
p3->req_drag.y = INTP(p1->req_drag.y, p2->req_drag.y, pos);
p3->req_drag.h = INTP(p1->req_drag.h, p2->req_drag.h, pos);
}
p3.color.r = INTP(p1.color.r, p2.color.r, pos);
p3.color.g = INTP(p1.color.g, p2.color.g, pos);
p3.color.b = INTP(p1.color.b, p2.color.b, pos);
p3.color.a = INTP(p1.color.a, p2.color.a, pos);
p3->color.r = INTP(p1->color.r, p2->color.r, pos);
p3->color.g = INTP(p1->color.g, p2->color.g, pos);
p3->color.b = INTP(p1->color.b, p2->color.b, pos);
p3->color.a = INTP(p1->color.a, p2->color.a, pos);
switch (part_type)
{
case EDJE_PART_TYPE_IMAGE:
case EDJE_PART_TYPE_GRADIENT:
p3.fill.x = INTP(p1.fill.x, p2.fill.x, pos);
p3.fill.y = INTP(p1.fill.y, p2.fill.y, pos);
p3.fill.w = INTP(p1.fill.w, p2.fill.w, pos);
p3.fill.h = INTP(p1.fill.h, p2.fill.h, pos);
if (part_type == EDJE_PART_TYPE_GRADIENT)
{
p3.fill.angle = INTP(p1.fill.angle, p2.fill.angle, pos);
p3.fill.spread = (beginning_pos) ? p1.fill.spread : p2.fill.spread;
p3.type.gradient = (beginning_pos) ? p1.type.gradient : p2.type.gradient;
}
else
{
p3.type.border.l = INTP(p1.type.border.l, p2.type.border.l, pos);
p3.type.border.r = INTP(p1.type.border.r, p2.type.border.r, pos);
p3.type.border.t = INTP(p1.type.border.t, p2.type.border.t, pos);
p3.type.border.b = INTP(p1.type.border.b, p2.type.border.b, pos);
}
break;
case EDJE_PART_TYPE_TEXT:
p3.type.text.size = INTP(p1.type.text.size, p2.type.text.size, pos);
case EDJE_PART_TYPE_TEXTBLOCK:
p3.color2.r = INTP(p1.color2.r, p2.color2.r, pos);
p3.color2.g = INTP(p1.color2.g, p2.color2.g, pos);
p3.color2.b = INTP(p1.color2.b, p2.color2.b, pos);
p3.color2.a = INTP(p1.color2.a, p2.color2.a, pos);
switch (part_type)
{
case EDJE_PART_TYPE_IMAGE:
case EDJE_PART_TYPE_GRADIENT:
p3->fill.x = INTP(p1->fill.x, p2->fill.x, pos);
p3->fill.y = INTP(p1->fill.y, p2->fill.y, pos);
p3->fill.w = INTP(p1->fill.w, p2->fill.w, pos);
p3->fill.h = INTP(p1->fill.h, p2->fill.h, pos);
if (part_type == EDJE_PART_TYPE_GRADIENT)
{
p3->fill.angle = INTP(p1->fill.angle, p2->fill.angle, pos);
p3->fill.spread = (beginning_pos) ? p1->fill.spread : p2->fill.spread;
p3->type.gradient = (beginning_pos) ? p1->type.gradient : p2->type.gradient;
}
else
{
p3->type.border.l = INTP(p1->type.border.l, p2->type.border.l, pos);
p3->type.border.r = INTP(p1->type.border.r, p2->type.border.r, pos);
p3->type.border.t = INTP(p1->type.border.t, p2->type.border.t, pos);
p3->type.border.b = INTP(p1->type.border.b, p2->type.border.b, pos);
}
break;
case EDJE_PART_TYPE_TEXT:
p3->type.text.size = INTP(p1->type.text.size, p2->type.text.size, pos);
case EDJE_PART_TYPE_TEXTBLOCK:
p3->color2.r = INTP(p1->color2.r, p2->color2.r, pos);
p3->color2.g = INTP(p1->color2.g, p2->color2.g, pos);
p3->color2.b = INTP(p1->color2.b, p2->color2.b, pos);
p3->color2.a = INTP(p1->color2.a, p2->color2.a, pos);
p3.color3.r = INTP(p1.color3.r, p2.color3.r, pos);
p3.color3.g = INTP(p1.color3.g, p2.color3.g, pos);
p3.color3.b = INTP(p1.color3.b, p2.color3.b, pos);
p3.color3.a = INTP(p1.color3.a, p2.color3.a, pos);
p3->color3.r = INTP(p1->color3.r, p2->color3.r, pos);
p3->color3.g = INTP(p1->color3.g, p2->color3.g, pos);
p3->color3.b = INTP(p1->color3.b, p2->color3.b, pos);
p3->color3.a = INTP(p1->color3.a, p2->color3.a, pos);
p3.type.text.align.x = INTP(p1.type.text.align.x, p2.type.text.align.x, pos);
p3.type.text.align.y = INTP(p1.type.text.align.y, p2.type.text.align.y, pos);
p3.type.text.elipsis = INTP(p1.type.text.elipsis, p2.type.text.elipsis, pos);
break;
}
p3->type.text.align.x = INTP(p1->type.text.align.x, p2->type.text.align.x, pos);
p3->type.text.align.y = INTP(p1->type.text.align.y, p2->type.text.align.y, pos);
p3->type.text.elipsis = INTP(p1->type.text.elipsis, p2->type.text.elipsis, pos);
break;
}
pf = &p3;
pf = p3;
#ifdef EDJE_CALC_CACHE
ep->state = ed->state;
#endif
}
else
{
pf = &p1;
pf = p1;
#ifdef EDJE_CALC_CACHE
ep->state = ep->param1.state;
#endif
}
#ifdef EDJE_CALC_CACHE
ep->invalidate = 0;
#endif
ep->req = pf->req;
if (ep->drag.need_reset)

15
legacy/edje/src/lib/edje_callbacks.c
View File

@ -116,6 +116,9 @@ _edje_mouse_down_cb(void *data, Evas * e, Evas_Object * obj, void *event_info)
_edje_emit(ed, buf, events->part->name);
}
ed->dirty = 1;
#ifdef EDJE_CALC_CACHE
rp->invalidate = 1;
#endif
}
_edje_recalc_do(ed);
/*
@ -138,6 +141,9 @@ _edje_mouse_down_cb(void *data, Evas * e, Evas_Object * obj, void *event_info)
if (!ignored)
_edje_emit(ed, "drag", rp->part->name);
ed->dirty = 1;
#ifdef EDJE_CALC_CACHE
rp->invalidate = 1;
#endif
rp->drag.need_reset = 1;
_edje_recalc_do(ed);
}
@ -213,6 +219,9 @@ _edje_mouse_up_cb(void *data, Evas * e, Evas_Object * obj, void *event_info)
{
rp->drag.need_reset = 1;
ed->dirty = 1;
#ifdef EDJE_CALC_CACHE
rp->invalidate = 1;
#endif
if (!ignored)
_edje_emit(ed, "drag,stop", rp->part->name);
}
@ -281,6 +290,9 @@ _edje_mouse_move_cb(void *data, Evas * e, Evas_Object * obj, void *event_info)
if (rp->part->dragable.y)
rp->drag.tmp.y = ev->cur.canvas.y - rp->drag.down.y;
ed->dirty = 1;
#ifdef EDJE_CALC_CACHE
rp->invalidate = 1;
#endif
}
_edje_recalc_do(ed);
}
@ -299,6 +311,9 @@ _edje_mouse_move_cb(void *data, Evas * e, Evas_Object * obj, void *event_info)
if (!ignored)
_edje_emit(ed, "drag", rp->part->name);
ed->dirty = 1;
#ifdef EDJE_CALC_CACHE
rp->invalidate = 1;
#endif
_edje_recalc_do(ed);
}
}

9
legacy/edje/src/lib/edje_embryo.c
View File

@ -675,6 +675,9 @@ _edje_embryo_fn_set_min_size(Embryo_Program *ep, Embryo_Cell *params)
ed->collection->prop.min.w = w;
ed->collection->prop.min.h = h;
ed->dirty = 1;
#ifdef EDJE_CALC_CACHE
ed->all_part_change = 1;
#endif
_edje_recalc(ed);
return 0;
}
@ -699,6 +702,9 @@ _edje_embryo_fn_set_max_size(Embryo_Program *ep, Embryo_Cell *params)
ed->collection->prop.max.w = w;
ed->collection->prop.max.h = h;
ed->dirty = 1;
#ifdef EDJE_CALC_CACHE
ed->all_part_change = 1;
#endif
_edje_recalc(ed);
return 0;
@ -1875,6 +1881,9 @@ _edje_embryo_fn_set_state_val(Embryo_Program *ep, Embryo_Cell *params)
break;
}
#ifdef EDJE_CALC_CACHE
rp->invalidate = 1;
#endif
ed->dirty=1;
return 0;
}

3
legacy/edje/src/lib/edje_load.c
View File

@ -524,6 +524,9 @@ _edje_object_file_set_internal(Evas_Object *obj, const char *file, const char *g
_edje_dragable_pos_set(ed, rp, rp->drag.val.x, rp->drag.val.y);
}
ed->dirty = 1;
#ifdef EDJE_CALC_CACHE
ed->all_part_change = 1;
#endif
if ((evas_object_clipees_get(ed->clipper)) &&
(evas_object_visible_get(obj)))
evas_object_show(ed->clipper);

78
legacy/edje/src/lib/edje_private.h
View File

@ -707,6 +707,8 @@ struct _Edje
} message;
int processing_messages;
int state;
unsigned short dirty : 1;
unsigned short recalc : 1;
unsigned short walking_callbacks : 1;
@ -720,8 +722,41 @@ struct _Edje
unsigned short block_break : 1;
unsigned short delete_me : 1;
unsigned short postponed : 1;
#ifdef EDJE_CALC_CACHE
unsigned short text_part_change : 1;
unsigned short all_part_change : 1;
#endif
};
struct _Edje_Calc_Params
{
int x, y, w, h; // 16
Edje_Rectangle req; // 16
Edje_Rectangle req_drag; // 16
struct {
int x, y, w, h; // 16
int angle; // 4
int spread; // 4
} fill;
Edje_Color color, color2, color3; // 12
union {
struct {
int l, r, t, b; // 16
} border; // 16
struct {
Edje_Alignment align; /* text alignment within bounds */ // 16
double elipsis; // 8
int size; // 4
} text; // 28
struct {
int id; // 4
char *type; // 4
} gradient; // 8
} type; // 28
unsigned char visible : 1;
unsigned char smooth : 1; // 4
}; // 116
struct _Edje_Real_Part
{
Edje *edje; // 4
@ -781,7 +816,17 @@ struct _Edje_Real_Part
Edje_Real_Part *rel1_to_y; // 4
Edje_Real_Part *rel2_to_x; // 4
Edje_Real_Part *rel2_to_y; // 4
#ifdef EDJE_CALC_CACHE
Edje_Calc_Params p; // 116
int state; // 4
#endif
} param1, param2, custom; // 60 // FIXME: custom should be alloced on demand - 20--
// WITH EDJE_CALC_CACHE: 180
#ifdef EDJE_CALC_CACHE
Edje_Calc_Params p;
int state;
#endif
Edje_Real_Part *confine_to; // 4 // fixme - make part of drag
Edje_Real_Part *clip_to; // 4
@ -796,7 +841,11 @@ struct _Edje_Real_Part
unsigned char calculating; // 1
unsigned char still_in : 1; // 2
#ifdef EDJE_CALC_CACHE
unsigned char invalidate : 1;
#endif
}; // 394
// WITH EDJE_CALC_CACHE: 514
struct _Edje_Running_Program
{
@ -816,35 +865,6 @@ struct _Edje_Signal_Callback
unsigned char delete_me : 1;
};
struct _Edje_Calc_Params
{
int x, y, w, h;
Edje_Rectangle req;
Edje_Rectangle req_drag;
struct {
int x, y, w, h;
int angle;
int spread;
} fill;
Edje_Color color, color2, color3;
union {
struct {
int l, r, t, b;
} border;
struct {
Edje_Alignment align; /* text alignment within bounds */
double elipsis;
int size;
} text;
struct {
int id;
char *type;
} gradient;
} type;
unsigned char visible : 1;
unsigned char smooth : 1;
};
struct _Edje_Pending_Program
{
Edje *edje;

3
legacy/edje/src/lib/edje_smart.c
View File

@ -164,6 +164,9 @@ _edje_smart_resize(Evas_Object * obj, Evas_Coord w, Evas_Coord h)
if ((w == ed->w) && (h == ed->h)) return;
ed->w = w;
ed->h = h;
#ifdef EDJE_CALC_CACHE
ed->all_part_change = 1;
#endif
if (_edje_script_only(ed))
{
_edje_script_only_resize(ed);

86
legacy/edje/src/lib/edje_util.c
View File

@ -359,6 +359,9 @@ edje_color_class_set(const char *color_class, int r, int g, int b, int a, int r2
ed = eina_list_data_get(members);
ed->dirty = 1;
#ifdef EDJE_CALC_CACHE
ed->all_part_change = 1;
#endif
_edje_recalc(ed);
members = eina_list_next(members);
}
@ -391,6 +394,9 @@ edje_color_class_del(const char *color_class)
ed = eina_list_data_get(members);
ed->dirty = 1;
#ifdef EDJE_CALC_CACHE
ed->all_part_change = 1;
#endif
_edje_recalc(ed);
members = eina_list_next(members);
}
@ -489,6 +495,9 @@ edje_object_color_class_set(Evas_Object *obj, const char *color_class, int r, in
cc->b3 = b3;
cc->a3 = a3;
ed->dirty = 1;
#ifdef EDJE_CALC_CACHE
ed->all_part_change = 1;
#endif
_edje_recalc(ed);
return;
}
@ -515,6 +524,9 @@ edje_object_color_class_set(Evas_Object *obj, const char *color_class, int r, in
cc->a3 = a3;
ed->color_classes = eina_list_append(ed->color_classes, cc);
ed->dirty = 1;
#ifdef EDJE_CALC_CACHE
ed->all_part_change = 1;
#endif
for (i = 0; i < ed->table_parts_size; i++)
{
@ -568,6 +580,9 @@ edje_object_color_class_del(Evas_Object *obj, const char *color_class)
}
ed->dirty = 1;
#ifdef EDJE_CALC_CACHE
ed->all_part_change = 1;
#endif
_edje_recalc(ed);
}
@ -632,6 +647,9 @@ edje_text_class_set(const char *text_class, const char *font, Evas_Font_Size siz
ed = eina_list_data_get(members);
ed->dirty = 1;
_edje_textblock_style_all_update(ed);
#ifdef EDJE_CALC_CACHE
ed->text_part_change = 1;
#endif
_edje_recalc(ed);
members = eina_list_next(members);
}
@ -666,6 +684,9 @@ edje_text_class_del(const char *text_class)
ed = eina_list_data_get(members);
ed->dirty = 1;
_edje_textblock_style_all_update(ed);
#ifdef EDJE_CALC_CACHE
ed->text_part_change = 1;
#endif
_edje_recalc(ed);
members = eina_list_next(members);
}
@ -738,6 +759,9 @@ edje_object_text_class_set(Evas_Object *obj, const char *text_class, const char
/* Update edje */
ed->dirty = 1;
#ifdef EDJE_CALC_CACHE
ed->text_part_change = 1;
#endif
_edje_recalc(ed);
return;
}
@ -769,6 +793,9 @@ edje_object_text_class_set(Evas_Object *obj, const char *text_class, const char
/* Add to edje's text class list */
ed->text_classes = eina_list_append(ed->text_classes, tc);
ed->dirty = 1;
#ifdef EDJE_CALC_CACHE
ed->text_part_change = 1;
#endif
_edje_textblock_style_all_update(ed);
_edje_recalc(ed);
}
@ -908,6 +935,9 @@ _edje_object_part_text_raw_set(Evas_Object *obj, Edje_Real_Part *rp, const char
else
if (text) rp->text.text = eina_stringshare_add(text);
rp->edje->dirty = 1;
#ifdef EDJE_CALC_CACHE
rp->invalidate = 1;
#endif
_edje_recalc(rp->edje);
if (rp->edje->text_change.func)
rp->edje->text_change.func(rp->edje->text_change.data, obj, part);
@ -1256,6 +1286,9 @@ edje_object_part_text_insert(Evas_Object *obj, const char *part, const char *tex
if (rp->part->entry_mode <= EDJE_ENTRY_EDIT_MODE_NONE) return;
_edje_entry_text_markup_insert(rp, text);
rp->edje->dirty = 1;
#ifdef EDJE_CALC_CACHE
rp->invalidate = 1;
#endif
_edje_recalc(rp->edje);
if (rp->edje->text_change.func)
rp->edje->text_change.func(rp->edje->text_change.data, obj, part);
@ -1748,6 +1781,9 @@ edje_object_part_unswallow(Evas_Object *obj, Evas_Object *obj_swallow)
rp->swallow_params.max.w = 0;
rp->swallow_params.max.h = 0;
rp->edje->dirty = 1;
#ifdef EDJE_CALC_CACHE
rp->invalidate = 1;
#endif
_edje_recalc_do(rp->edje);
return;
}
@ -1858,7 +1894,10 @@ edje_object_calc_force(Evas_Object *obj)
ed = _edje_fetch(obj);
if (!ed) return;
ed->dirty = 1;
#ifdef EDJE_CALC_CACHE
ed->all_part_change = 1;
#endif
pf2 = _edje_freeze_val;
pf = ed->freeze;
@ -1929,6 +1968,9 @@ edje_object_size_min_restricted_calc(Evas_Object *obj, Evas_Coord *minw, Evas_Co
ok = 0;
ed->dirty = 1;
#ifdef EDJE_CALC_CACHE
ed->all_part_change = 1;
#endif
_edje_recalc_do(ed);
if (reset_maxwh)
{
@ -2007,6 +2049,9 @@ edje_object_size_min_restricted_calc(Evas_Object *obj, Evas_Coord *minw, Evas_Co
ed->w = pw;
ed->h = ph;
ed->dirty = 1;
#ifdef EDJE_CALC_CACHE
ed->all_part_change = 1;
#endif
_edje_recalc(ed);
ed->calc_only = 0;
}
@ -2122,6 +2167,9 @@ edje_object_part_drag_value_set(Evas_Object *obj, const char *part, double dx, d
if ((rp->drag.val.x == dx) && (rp->drag.val.y == dy)) return;
rp->drag.val.x = dx;
rp->drag.val.y = dy;
#ifdef EDJE_CALC_CACHE
rp->invalidate = 1;
#endif
_edje_dragable_pos_set(rp->edje, rp, dx, dy);
_edje_emit(rp->edje, "drag,set", rp->part->name);
}
@ -2194,6 +2242,9 @@ edje_object_part_drag_size_set(Evas_Object *obj, const char *part, double dw, do
rp->drag.size.x = dw;
rp->drag.size.y = dh;
rp->edje->dirty = 1;
#ifdef EDJE_CALC_CACHE
rp->invalidate = 1;
#endif
_edje_recalc(rp->edje);
}
@ -2257,6 +2308,9 @@ edje_object_part_drag_step_set(Evas_Object *obj, const char *part, double dx, do
else if (dy > 1.0) dy = 1.0;
rp->drag.step.x = dx;
rp->drag.step.y = dy;
#ifdef EDJE_CALC_CACHE
rp->invalidate = 1;
#endif
}
/** Gets the drag step increment values.
@ -2319,6 +2373,9 @@ edje_object_part_drag_page_set(Evas_Object *obj, const char *part, double dx, do
else if (dy > 1.0) dy = 1.0;
rp->drag.page.x = dx;
rp->drag.page.y = dy;
#ifdef EDJE_CALC_CACHE
rp->invalidate = 1;
#endif
}
/** Gets the page step increments
@ -2385,6 +2442,9 @@ edje_object_part_drag_step(Evas_Object *obj, const char *part, double dx, double
rp->drag.val.x = CLAMP (rp->drag.val.x, 0.0, 1.0);
rp->drag.val.y = CLAMP (rp->drag.val.y, 0.0, 1.0);
if ((px == rp->drag.val.x) && (py == rp->drag.val.y)) return;
#ifdef EDJE_CALC_CACHE
rp->invalidate = 1;
#endif
_edje_dragable_pos_set(rp->edje, rp, rp->drag.val.x, rp->drag.val.y);
_edje_emit(rp->edje, "drag,step", rp->part->name);
}
@ -2417,6 +2477,9 @@ edje_object_part_drag_page(Evas_Object *obj, const char *part, double dx, double
rp->drag.val.x = CLAMP (rp->drag.val.x, 0.0, 1.0);
rp->drag.val.y = CLAMP (rp->drag.val.y, 0.0, 1.0);
if ((px == rp->drag.val.x) && (py == rp->drag.val.y)) return;
#ifdef EDJE_CALC_CACHE
rp->invalidate = 1;
#endif
_edje_dragable_pos_set(rp->edje, rp, rp->drag.val.x, rp->drag.val.y);
_edje_emit(rp->edje, "drag,page", rp->part->name);
}
@ -2630,6 +2693,9 @@ _edje_box_child_del_cb(void *data, Evas *e __UNUSED__, Evas_Object *child __UNUS
Edje_Real_Part *rp = data;
rp->edje->dirty = 1;
#ifdef EDJE_CALC_CACHE
rp->invalidate = 1;
#endif
_edje_recalc(rp->edje);
}
@ -2640,6 +2706,9 @@ _edje_box_child_add(Edje_Real_Part *rp, Evas_Object *child)
(child, EVAS_CALLBACK_DEL, _edje_box_child_del_cb, rp);
rp->edje->dirty = 1;
#ifdef EDJE_CALC_CACHE
rp->invalidate = 1;
#endif
_edje_recalc(rp->edje);
}
@ -2650,6 +2719,9 @@ _edje_box_child_remove(Edje_Real_Part *rp, Evas_Object *child)
(child, EVAS_CALLBACK_DEL, _edje_box_child_del_cb, rp);
rp->edje->dirty = 1;
#ifdef EDJE_CALC_CACHE
rp->invalidate = 1;
#endif
_edje_recalc(rp->edje);
}
@ -2762,6 +2834,9 @@ _edje_table_child_del_cb(void *data, Evas *e __UNUSED__, Evas_Object *child __UN
Edje_Real_Part *rp = data;
rp->edje->dirty = 1;
#ifdef EDJE_CALC_CACHE
rp->invalidate = 1;
#endif
_edje_recalc(rp->edje);
}
@ -2772,6 +2847,9 @@ _edje_table_child_add(Edje_Real_Part *rp, Evas_Object *child)
(child, EVAS_CALLBACK_DEL, _edje_table_child_del_cb, rp);
rp->edje->dirty = 1;
#ifdef EDJE_CALC_CACHE
rp->invalidate = 1;
#endif
_edje_recalc(rp->edje);
}
@ -2782,6 +2860,9 @@ _edje_table_child_remove(Edje_Real_Part *rp, Evas_Object *child)
(child, EVAS_CALLBACK_DEL, _edje_table_child_del_cb, rp);
rp->edje->dirty = 1;
#ifdef EDJE_CALC_CACHE
rp->invalidate = 1;
#endif
_edje_recalc(rp->edje);
}
@ -3285,6 +3366,9 @@ _edje_real_part_swallow(Edje_Real_Part *rp, Evas_Object *obj_swallow)
_edje_callbacks_del(rp->swallowed_object);
rp->swallowed_object = NULL;
}
#ifdef EDJE_CALC_CACHE
rp->invalidate = 1;
#endif
if (!obj_swallow) return;
rp->swallowed_object = obj_swallow;
evas_object_smart_member_add(rp->swallowed_object, rp->edje->obj);