text to the end of the textblock part. This lets us do cool thing
like population of textblock using idler.
+2011-05-16 Carsten Haitzler (The Rasterman)
+
+ * Add new interpolation modes for programs to make animation
+ much easier. Added: ACCEL_FAC, DECEL_FAC, SIN_FAC, DIVIS,
+ BOUNCE, SPRING (also made short name versions of the long ones
+ possible too).
+
@property
transition
@parameters
- [type] [length]
+ [type] [length] [[interp val 1]] [[interp val 2]]
@effect
Defines how transitions occur using STATE_SET action.\n
Where 'type' is the style of the transition and 'length' is a double
specifying the number of seconds in which to preform the transition.\n
- Valid types are: LINEAR, SINUSOIDAL, ACCELERATE, and DECELERATE.
+ Valid types are: LIN or LINEAR, SIN or SINUSOIDAL,
+ ACCEL or ACCELERATE, DECEL or DECELERATE,
+ ACCEL_FAC or ACCELERATE_FACTOR, DECEL_FAC or DECELERATE_FACTOR,
+ SIN_FAC or SINUSOIDAL_FACTOR, DIVIS or DIVISOR_INTERP,
+ BOUNCE, SPRING.
+
+ ACCEL_FAC, DECEL_FAC and SIN_FAC need the extra optional
+ "interp val 1" to determine the "factor" of curviness. 1.0 is the same
+ as their non-factor counterparts, where 0.0 is equal to linear.
+ numbers higher than one make the curve angles steeper with a more
+ prnounced curve point.
+
+ DIVIS, BOUNCE and SPRING also require "interp val 2" in addition
+ to "interp val 1".
+
+ DIVIS uses val 1 as the initial graident start
+ (0.0 is horizontal, 1.0 is diagonal (linear), 2.0 is twice the
+ gradient of linear etc.). val 2 is interpreted as an integer factor
+ defining how much the value swings "outside" the gradient only to come
+ back to the final resting spot at the end. 0.0 for val 2 is equivalent
+ to linear interpolation. Note that DIVIS can exceed 1.0
+
+ BOUNCE uses val 2 as the number of bounces (so its rounded down to
+ the nearest integer value), with val 2 determining how much the
+ bounce decays, with 0.0 giving linear decay per bounce, and higher
+ values giving much more decay.
+
+ SPRING is similar to bounce, where val 2 specifies the number of
+ spring "swings" and val 1 specifies the decay, but it can exceed 1.0
+ on the outer swings.
+
@endproperty
*/
static void
st_collections_group_programs_program_transition(void)
{
- check_arg_count(2);
+ check_min_arg_count(2);
current_program->tween.mode = parse_enum(0,
+ // short names
+ "LIN", EDJE_TWEEN_MODE_LINEAR,
+ "SIN", EDJE_TWEEN_MODE_SINUSOIDAL,
+ "ACCEL", EDJE_TWEEN_MODE_ACCELERATE,
+ "DECEL", EDJE_TWEEN_MODE_DECELERATE,
+ "ACCEL_FAC", EDJE_TWEEN_MODE_ACCELERATE_FACTOR,
+ "DECEL_FAC", EDJE_TWEEN_MODE_DECELERATE_FACTOR,
+ "SIN_FAC", EDJE_TWEEN_MODE_SINUSOIDAL_FACTOR,
+ "DIVIS", EDJE_TWEEN_MODE_DIVISOR_INTERP,
+
+ // long/full names
"LINEAR", EDJE_TWEEN_MODE_LINEAR,
"SINUSOIDAL", EDJE_TWEEN_MODE_SINUSOIDAL,
"ACCELERATE", EDJE_TWEEN_MODE_ACCELERATE,
"DECELERATE", EDJE_TWEEN_MODE_DECELERATE,
+ "ACCELERATE_FACTOR", EDJE_TWEEN_MODE_ACCELERATE_FACTOR,
+ "DECELERATE_FACTOR", EDJE_TWEEN_MODE_DECELERATE_FACTOR,
+ "SINUSOIDAL_FACTOR", EDJE_TWEEN_MODE_SINUSOIDAL_FACTOR,
+ "DIVISOR_INTERP", EDJE_TWEEN_MODE_DIVISOR_INTERP,
+
+ // long/full is short enough
+ "BOUNCE", EDJE_TWEEN_MODE_BOUNCE,
+ "SPRING", EDJE_TWEEN_MODE_SPRING,
NULL);
current_program->tween.time = FROM_DOUBLE(parse_float_range(1, 0.0, 999999999.0));
+ // the following need v1
+ // EDJE_TWEEN_MODE_ACCELERATE_FACTOR
+ // EDJE_TWEEN_MODE_DECELERATE_FACTOR
+ // EDJE_TWEEN_MODE_SINUSOIDAL_FACTOR
+ // current_program->tween.v1
+ if ((current_program->tween.mode >= EDJE_TWEEN_MODE_ACCELERATE_FACTOR) &&
+ (current_program->tween.mode <= EDJE_TWEEN_MODE_SINUSOIDAL_FACTOR))
+ {
+ if (get_arg_count() != 3)
+ {
+ ERR("%s: Error. parse error %s:%i. "
+ "Need 3rd parameter to set factor",
+ progname, file_in, line - 1);
+ exit(-1);
+ }
+ current_program->tween.v1 = FROM_DOUBLE(parse_float_range(2, 0.0, 999999999.0));
+ }
+ // the followjng also need v2
+ // EDJE_TWEEN_MODE_DIVISOR_INTERP
+ // EDJE_TWEEN_MODE_BOUNCE
+ // EDJE_TWEEN_MODE_SPRING
+ // current_program->tween.v2
+ else if ((current_program->tween.mode >= EDJE_TWEEN_MODE_DIVISOR_INTERP) &&
+ (current_program->tween.mode <= EDJE_TWEEN_MODE_SPRING))
+ {
+ if (get_arg_count() != 4)
+ {
+ ERR("%s: Error. parse error %s:%i. "
+ "Need 3rd and 4th parameters to set factor and counts",
+ progname, file_in, line - 1);
+ exit(-1);
+ }
+ current_program->tween.v1 = FROM_DOUBLE(parse_float_range(2, 0.0, 999999999.0));
+ current_program->tween.v2 = FROM_DOUBLE(parse_float_range(3, 0.0, 999999999.0));
+ }
}
/**
typedef enum _Edje_Tween_Mode
{
- EDJE_TWEEN_MODE_NONE = 0,
- EDJE_TWEEN_MODE_LINEAR = 1,
- EDJE_TWEEN_MODE_SINUSOIDAL = 2,
- EDJE_TWEEN_MODE_ACCELERATE = 3,
- EDJE_TWEEN_MODE_DECELERATE = 4,
- EDJE_TWEEN_MODE_LAST = 5
+ EDJE_TWEEN_MODE_NONE = 0,
+ EDJE_TWEEN_MODE_LINEAR = 1,
+ EDJE_TWEEN_MODE_SINUSOIDAL = 2,
+ EDJE_TWEEN_MODE_ACCELERATE = 3,
+ EDJE_TWEEN_MODE_DECELERATE = 4,
+ EDJE_TWEEN_MODE_ACCELERATE_FACTOR = 5,
+ EDJE_TWEEN_MODE_DECELERATE_FACTOR = 6,
+ EDJE_TWEEN_MODE_SINUSOIDAL_FACTOR = 7,
+ EDJE_TWEEN_MODE_DIVISOR_INTERP = 8,
+ EDJE_TWEEN_MODE_BOUNCE = 9,
+ EDJE_TWEEN_MODE_SPRING = 10,
+ EDJE_TWEEN_MODE_LAST = 11
} Edje_Tween_Mode;
typedef enum _Edje_Cursor
static void _edje_part_recalc(Edje *ed, Edje_Real_Part *ep, int flags);
void
-_edje_part_pos_set(Edje *ed, Edje_Real_Part *ep, int mode, FLOAT_T pos)
+_edje_part_pos_set(Edje *ed, Edje_Real_Part *ep, int mode, FLOAT_T pos, FLOAT_T v1, FLOAT_T v2)
{
FLOAT_T fp_pos;
FLOAT_T npos;
fp_pos = pos;
npos = ZERO;
+#if 0 // old code - easy to enable for comparing float vs fixed point
/* take linear pos along timescale and use interpolation method */
switch (mode)
{
npos = fp_pos;
break;
default:
- break;
+ npos = fp_pos;
+ break;
+ }
+#else
+ switch (mode)
+ {
+ case EDJE_TWEEN_MODE_SINUSOIDAL:
+ npos = FROM_DOUBLE(ecore_animator_pos_map(TO_DOUBLE(pos),
+ ECORE_POS_MAP_SINUSOIDAL,
+ 0.0, 0.0));
+ break;
+ case EDJE_TWEEN_MODE_ACCELERATE:
+ npos = FROM_DOUBLE(ecore_animator_pos_map(TO_DOUBLE(pos),
+ ECORE_POS_MAP_ACCELERATE,
+ 0.0, 0.0));
+ break;
+ case EDJE_TWEEN_MODE_DECELERATE:
+ npos = FROM_DOUBLE(ecore_animator_pos_map(TO_DOUBLE(pos),
+ ECORE_POS_MAP_DECELERATE,
+ 0.0, 0.0));
+ break;
+ case EDJE_TWEEN_MODE_LINEAR:
+ npos = fp_pos;
+/* npos = FROM_DOUBLE(ecore_animator_pos_map(TO_DOUBLE(pos),
+ ECORE_POS_MAP_LINEAR,
+ 0.0, 0.0));
+ */
+ break;
+ case EDJE_TWEEN_MODE_ACCELERATE_FACTOR:
+ npos = FROM_DOUBLE(ecore_animator_pos_map(TO_DOUBLE(pos),
+ ECORE_POS_MAP_ACCELERATE_FACTOR,
+ TO_DOUBLE(v1), 0.0));
+ break;
+ case EDJE_TWEEN_MODE_DECELERATE_FACTOR:
+ npos = FROM_DOUBLE(ecore_animator_pos_map(TO_DOUBLE(pos),
+ ECORE_POS_MAP_DECELERATE_FACTOR,
+ TO_DOUBLE(v1), 0.0));
+ break;
+ case EDJE_TWEEN_MODE_SINUSOIDAL_FACTOR:
+ npos = FROM_DOUBLE(ecore_animator_pos_map(TO_DOUBLE(pos),
+ ECORE_POS_MAP_SINUSOIDAL_FACTOR,
+ TO_DOUBLE(v1), 0.0));
+ break;
+ case EDJE_TWEEN_MODE_DIVISOR_INTERP:
+ npos = FROM_DOUBLE(ecore_animator_pos_map(TO_DOUBLE(pos),
+ ECORE_POS_MAP_DIVISOR_INTERP,
+ TO_DOUBLE(v1), TO_DOUBLE(v2)));
+ break;
+ case EDJE_TWEEN_MODE_BOUNCE:
+ npos = FROM_DOUBLE(ecore_animator_pos_map(TO_DOUBLE(pos),
+ ECORE_POS_MAP_BOUNCE,
+ TO_DOUBLE(v1), TO_DOUBLE(v2)));
+ break;
+ case EDJE_TWEEN_MODE_SPRING:
+ npos = FROM_DOUBLE(ecore_animator_pos_map(TO_DOUBLE(pos),
+ ECORE_POS_MAP_SPRING,
+ TO_DOUBLE(v1), TO_DOUBLE(v2)));
+ break;
+ default:
+ npos = fp_pos;
+ break;
}
+#endif
if (npos == ep->description_pos) return;
ep->description_pos = npos;
Edje_Calc_Params *p1, *pf;
Edje_Part_Description_Common *chosen_desc;
Edje_Real_Part *confine_to = NULL;
- FLOAT_T pos = ZERO;
+ FLOAT_T pos = ZERO, pos2;
Edje_Calc_Params lp3;
/* GRADIENT ARE GONE, WE MUST IGNORE IT FROM OLD FILE. */
}
pos = ep->description_pos;
+ pos2 = pos;
+ if (pos2 < ZERO) pos2 = ZERO;
+ else if (pos2 > FROM_INT(1)) pos2 = FROM_INT(1);
beginning_pos = (pos < FROM_DOUBLE(0.5));
part_type = ep->part->type;
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, pos2);
+ p3->color.g = INTP(p1->color.g, p2->color.g, pos2);
+ p3->color.b = INTP(p1->color.b, p2->color.b, pos2);
+ p3->color.a = INTP(p1->color.a, p2->color.a, pos2);
switch (part_type)
{
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->type.text.color2.r = INTP(p1->type.text.color2.r, p2->type.text.color2.r, pos);
- p3->type.text.color2.g = INTP(p1->type.text.color2.g, p2->type.text.color2.g, pos);
- p3->type.text.color2.b = INTP(p1->type.text.color2.b, p2->type.text.color2.b, pos);
- p3->type.text.color2.a = INTP(p1->type.text.color2.a, p2->type.text.color2.a, pos);
+ p3->type.text.color2.r = INTP(p1->type.text.color2.r, p2->type.text.color2.r, pos2);
+ p3->type.text.color2.g = INTP(p1->type.text.color2.g, p2->type.text.color2.g, pos2);
+ p3->type.text.color2.b = INTP(p1->type.text.color2.b, p2->type.text.color2.b, pos2);
+ p3->type.text.color2.a = INTP(p1->type.text.color2.a, p2->type.text.color2.a, pos2);
- p3->type.text.color3.r = INTP(p1->type.text.color3.r, p2->type.text.color3.r, pos);
- p3->type.text.color3.g = INTP(p1->type.text.color3.g, p2->type.text.color3.g, pos);
- p3->type.text.color3.b = INTP(p1->type.text.color3.b, p2->type.text.color3.b, pos);
- p3->type.text.color3.a = INTP(p1->type.text.color3.a, p2->type.text.color3.a, pos);
+ p3->type.text.color3.r = INTP(p1->type.text.color3.r, p2->type.text.color3.r, pos2);
+ p3->type.text.color3.g = INTP(p1->type.text.color3.g, p2->type.text.color3.g, pos2);
+ p3->type.text.color3.b = INTP(p1->type.text.color3.b, p2->type.text.color3.b, pos2);
+ p3->type.text.color3.a = INTP(p1->type.text.color3.a, p2->type.text.color3.a, pos2);
p3->type.text.align.x = FFP(p1->type.text.align.x, p2->type.text.align.x, pos);
p3->type.text.align.y = FFP(p1->type.text.align.y, p2->type.text.align.y, pos);
- p3->type.text.elipsis = TO_DOUBLE(FINTP(p1->type.text.elipsis, p2->type.text.elipsis, pos));
+ p3->type.text.elipsis = TO_DOUBLE(FINTP(p1->type.text.elipsis, p2->type.text.elipsis, pos2));
break;
}
desc2 = NULL;
if (ep->param2) desc2 = ep->param2->description;
pos = ep->description_pos;
+ pos2 = pos;
+ if (pos2 < ZERO) pos2 = ZERO;
+ else if (pos2 > FROM_INT(1)) pos2 = FROM_INT(1);
ed->have_mapped_part = 1;
// create map and populate with part geometry
if (ep2)
{
Edje_Part_Description_Common *ep2desc1, *ep2desc2;
- FLOAT_T ep2pos;
+ FLOAT_T ep2pos, ep2pos2;
do1 = 1;
if (!ep2->calculated)
ep2desc2 = NULL;
if (ep2->param2) ep2desc2 = ep2->param2->description;
ep2pos = ep2->description_pos;
+ ep2pos2 = ep2pos;
+ if (ep2pos2 < ZERO) ep2pos2 = ZERO;
+ else if (ep2pos2 > FROM_INT(1)) ep2pos2 = FROM_INT(1);
// light x and y are already interpolated in part geom
lx1 = ed->x + ep2->x + (ep2->w / 2);
TO_INT(SCALE(ep2pos, ep2desc2->persp.zplane -
ep2desc1->persp.zplane));
lr1 = ep2desc1->color.r +
- TO_INT(SCALE(ep2pos, ep2desc2->color.r -
+ TO_INT(SCALE(ep2pos2, ep2desc2->color.r -
ep2desc1->color.r));
lg1 = ep2desc1->color.g +
- TO_INT(SCALE(ep2pos, ep2desc2->color.g -
+ TO_INT(SCALE(ep2pos2, ep2desc2->color.g -
ep2desc1->color.b));
lb1 = ep2desc1->color.b +
- TO_INT(SCALE(ep2pos, ep2desc2->color.g -
+ TO_INT(SCALE(ep2pos2, ep2desc2->color.g -
ep2desc1->color.b));
lar1 = ep2desc1->color2.r +
- TO_INT(SCALE(ep2pos, ep2desc2->color2.r -
+ TO_INT(SCALE(ep2pos2, ep2desc2->color2.r -
ep2desc1->color2.r));
lag1 = ep2desc1->color2.g +
- TO_INT(SCALE(ep2pos, ep2desc2->color2.g -
+ TO_INT(SCALE(ep2pos2, ep2desc2->color2.g -
ep2desc1->color2.b));
lab1 = ep2desc1->color2.b +
- TO_INT(SCALE(ep2pos, ep2desc2->color2.g -
+ TO_INT(SCALE(ep2pos2, ep2desc2->color2.g -
ep2desc1->color2.b));
}
else
if (ep2)
{
Edje_Part_Description_Common *ep2desc1, *ep2desc2;
- FLOAT_T ep2pos;
+ FLOAT_T ep2pos, ep2pos2;
do2 = 1;
if (!ep2->calculated)
ep2desc2 = NULL;
if (ep2->param2) ep2desc2 = ep2->param2->description;
ep2pos = ep2->description_pos;
+ ep2pos2 = ep2pos;
+ if (ep2pos2 < ZERO) ep2pos2 = ZERO;
+ else if (ep2pos2 > FROM_INT(1)) ep2pos2 = FROM_INT(1);
// light x and y are already interpolated in part geom
lx2 = ed->x + ep2->x + (ep2->w / 2);
TO_INT(SCALE(ep2pos, ep2desc2->persp.zplane -
ep2desc1->persp.zplane));
lr2 = ep2desc1->color.r +
- TO_INT(SCALE(ep2pos, ep2desc2->color.r -
+ TO_INT(SCALE(ep2pos2, ep2desc2->color.r -
ep2desc1->color.r));
lg2 = ep2desc1->color.g +
- TO_INT(SCALE(ep2pos, ep2desc2->color.g -
+ TO_INT(SCALE(ep2pos2, ep2desc2->color.g -
ep2desc1->color.b));
lb2 = ep2desc1->color.b +
- TO_INT(SCALE(ep2pos, ep2desc2->color.g -
+ TO_INT(SCALE(ep2pos2, ep2desc2->color.g -
ep2desc1->color.b));
lar2 = ep2desc1->color2.r +
- TO_INT(SCALE(ep2pos, ep2desc2->color2.r -
+ TO_INT(SCALE(ep2pos2, ep2desc2->color2.r -
ep2desc1->color2.r));
lag2 = ep2desc1->color2.g +
- TO_INT(SCALE(ep2pos, ep2desc2->color2.g -
+ TO_INT(SCALE(ep2pos2, ep2desc2->color2.g -
ep2desc1->color2.b));
lab2 = ep2desc1->color2.b +
- TO_INT(SCALE(ep2pos, ep2desc2->color2.g -
+ TO_INT(SCALE(ep2pos2, ep2desc2->color2.g -
ep2desc1->color2.b));
}
else
lx = lx1 + TO_INT(SCALE(pos, lx2 - lx1));
ly = ly1 + TO_INT(SCALE(pos, ly2 - ly1));
lz = lz1 + TO_INT(SCALE(pos, lz2 - lz1));
- lr = lr1 + TO_INT(SCALE(pos, lr2 - lr1));
- lg = lg1 + TO_INT(SCALE(pos, lg2 - lg1));
- lb = lb1 + TO_INT(SCALE(pos, lb2 - lb1));
- lar = lar1 + TO_INT(SCALE(pos, lar2 - lar1));
- lag = lag1 + TO_INT(SCALE(pos, lag2 - lag1));
- lab = lab1 + TO_INT(SCALE(pos, lab2 - lab1));
+ lr = lr1 + TO_INT(SCALE(pos2, lr2 - lr1));
+ lg = lg1 + TO_INT(SCALE(pos2, lg2 - lg1));
+ lb = lb1 + TO_INT(SCALE(pos2, lb2 - lb1));
+ lar = lar1 + TO_INT(SCALE(pos2, lar2 - lar1));
+ lag = lag1 + TO_INT(SCALE(pos2, lag2 - lag1));
+ lab = lab1 + TO_INT(SCALE(pos2, lab2 - lab1));
}
else if (do1)
{
EET_DATA_DESCRIPTOR_ADD_BASIC(_edje_edd_edje_program, Edje_Program, "value2", value2, EET_T_DOUBLE);
EET_DATA_DESCRIPTOR_ADD_BASIC(_edje_edd_edje_program, Edje_Program, "tween.mode", tween.mode, EET_T_INT);
EET_DATA_DESCRIPTOR_ADD_BASIC(_edje_edd_edje_program, Edje_Program, "tween.time", tween.time, EDJE_T_FLOAT);
+ EET_DATA_DESCRIPTOR_ADD_BASIC(_edje_edd_edje_program, Edje_Program, "v1", tween.v1, EDJE_T_FLOAT);
+ EET_DATA_DESCRIPTOR_ADD_BASIC(_edje_edd_edje_program, Edje_Program, "v2", tween.v2, EDJE_T_FLOAT);
EET_DATA_DESCRIPTOR_ADD_LIST(_edje_edd_edje_program, Edje_Program, "targets", targets, _edje_edd_edje_program_target);
EET_DATA_DESCRIPTOR_ADD_LIST(_edje_edd_edje_program, Edje_Program, "after", after, _edje_edd_edje_program_after);
EET_DATA_DESCRIPTOR_ADD_BASIC(_edje_edd_edje_program, Edje_Program, "api.name", api.name, EET_T_STRING);
{
if (rp->program) _edje_program_end(ed, rp->program);
_edje_part_description_apply(ed, rp, state, value, NULL, 0.0);
- _edje_part_pos_set(ed, rp, EDJE_TWEEN_MODE_LINEAR, ZERO);
+ _edje_part_pos_set(ed, rp, EDJE_TWEEN_MODE_LINEAR, ZERO, ZERO, ZERO);
_edje_recalc(ed);
}
return 0;
{
if (rp->program) _edje_program_end(ed, rp->program);
_edje_part_description_apply(ed, rp, state1, value1, state2, value2);
- _edje_part_pos_set(ed, rp, EDJE_TWEEN_MODE_LINEAR, FROM_DOUBLE(tween));
+ _edje_part_pos_set(ed, rp, EDJE_TWEEN_MODE_LINEAR, FROM_DOUBLE(tween), ZERO, ZERO);
_edje_recalc(ed);
}
return 0;
_edje_part_description_apply(obj->ed, obj->rp,
luaL_checkstring(L, -2), luaL_checknumber(L, -1),
NULL, 0.0);
- _edje_part_pos_set(obj->ed, obj->rp, EDJE_TWEEN_MODE_LINEAR, ZERO);
+ _edje_part_pos_set(obj->ed, obj->rp, EDJE_TWEEN_MODE_LINEAR, ZERO, ZERO, ZERO);
_edje_recalc(obj->ed);
return 0;
}
luaL_checkstring(L, -4), luaL_checknumber(L, -3),
luaL_checkstring(L, -2), luaL_checknumber(L, -1));
_edje_part_pos_set(obj->ed, obj->rp, EDJE_TWEEN_MODE_LINEAR,
- FROM_DOUBLE(luaL_checknumber(L, -5)));
+ FROM_DOUBLE(luaL_checknumber(L, -5)), ZERO, ZERO);
_edje_recalc(obj->ed);
return 0;
}
struct {
int mode; /* how to tween - linear, sinusoidal etc. */
FLOAT_T time; /* time to graduate between current and new state */
+ FLOAT_T v1; /* other value for drag actions */
+ FLOAT_T v2; /* other value for drag actions */
} tween;
Eina_List *targets; /* list of target parts to apply the state to */
extern Eina_Mempool *_emp_EXTERNAL;
extern Eina_Mempool *_emp_part;
-void _edje_part_pos_set(Edje *ed, Edje_Real_Part *ep, int mode, FLOAT_T pos);
+void _edje_part_pos_set(Edje *ed, Edje_Real_Part *ep, int mode, FLOAT_T pos, FLOAT_T v1, FLOAT_T v2);
Edje_Part_Description_Common *_edje_part_description_find(Edje *ed,
Edje_Real_Part *rp,
const char *name, double val);
{
rp = ed->table_parts[pt->id % ed->table_parts_size];
if (rp) _edje_part_pos_set(ed, rp,
- runp->program->tween.mode, t);
+ runp->program->tween.mode, t,
+ runp->program->tween.v1,
+ runp->program->tween.v2);
}
}
if (t >= FROM_INT(1))
NULL,
0.0);
_edje_part_pos_set(ed, rp,
- runp->program->tween.mode, ZERO);
+ runp->program->tween.mode, ZERO,
+ runp->program->tween.v1,
+ runp->program->tween.v2);
rp->program = NULL;
}
}
NULL,
0.0);
_edje_part_pos_set(ed, rp,
- runp->program->tween.mode, ZERO);
+ runp->program->tween.mode, ZERO,
+ runp->program->tween.v1,
+ runp->program->tween.v2);
rp->program = NULL;
}
}
rp->param1.description->state.value,
pr->state,
pr->value);
- _edje_part_pos_set(ed, rp, pr->tween.mode, ZERO);
+ _edje_part_pos_set(ed, rp, pr->tween.mode, ZERO,
+ pr->tween.v1,
+ pr->tween.v2);
rp->program = runp;
}
}
pr->value,
NULL,
0.0);
- _edje_part_pos_set(ed, rp, pr->tween.mode, ZERO);
+ _edje_part_pos_set(ed, rp, pr->tween.mode, ZERO,
+ pr->tween.v1,
+ pr->tween.v2);
}
}
}
projects / platform / upstream / efl.git / commitdiff