2003-06-23 19:33:04 -07:00
|
|
|
#include "edje_private.h"
|
|
|
|
|
2006-03-18 20:22:35 -08:00
|
|
|
static void _edje_emit_cb(Edje *ed, const char *sig, const char *src);
|
2010-03-26 18:26:10 -07:00
|
|
|
static void _edje_param_copy(Edje_Real_Part *src_part, const char *src_param, Edje_Real_Part *dst_part, const char *dst_param);
|
2010-03-31 13:48:51 -07:00
|
|
|
static void _edje_param_set(Edje_Real_Part *part, const char *param, const char *value);
|
2003-08-15 06:35:25 -07:00
|
|
|
|
2004-09-05 01:11:36 -07:00
|
|
|
int _edje_anim_count = 0;
|
|
|
|
Ecore_Animator *_edje_timer = NULL;
|
2008-10-22 04:34:42 -07:00
|
|
|
Eina_List *_edje_animators = NULL;
|
2003-06-23 19:33:04 -07:00
|
|
|
|
2004-06-05 21:42:17 -07:00
|
|
|
|
2009-09-17 15:38:35 -07:00
|
|
|
/*============================================================================*
|
|
|
|
* API *
|
|
|
|
*============================================================================*/
|
|
|
|
|
2006-01-07 00:54:30 -08:00
|
|
|
EAPI void
|
2003-06-23 19:33:04 -07:00
|
|
|
edje_frametime_set(double t)
|
|
|
|
{
|
2004-09-05 01:11:36 -07:00
|
|
|
ecore_animator_frametime_set(t);
|
2003-06-23 19:33:04 -07:00
|
|
|
}
|
|
|
|
|
2006-01-07 00:54:30 -08:00
|
|
|
EAPI double
|
2003-06-23 19:33:04 -07:00
|
|
|
edje_frametime_get(void)
|
|
|
|
{
|
2004-09-05 01:11:36 -07:00
|
|
|
return ecore_animator_frametime_get();
|
2003-06-23 19:33:04 -07:00
|
|
|
}
|
|
|
|
|
2006-01-07 00:54:30 -08:00
|
|
|
EAPI void
|
2003-07-08 03:08:15 -07:00
|
|
|
edje_object_signal_callback_add(Evas_Object *obj, const char *emission, const char *source, void (*func) (void *data, Evas_Object *o, const char *emission, const char *source), void *data)
|
2003-06-23 19:33:04 -07:00
|
|
|
{
|
|
|
|
Edje *ed;
|
|
|
|
Edje_Signal_Callback *escb;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2003-06-23 19:33:04 -07:00
|
|
|
if ((!emission) || (!source) || (!func)) return;
|
|
|
|
ed = _edje_fetch(obj);
|
|
|
|
if (!ed) return;
|
2003-08-25 17:16:49 -07:00
|
|
|
if (ed->delete_me) return;
|
2003-06-23 19:33:04 -07:00
|
|
|
escb = calloc(1, sizeof(Edje_Signal_Callback));
|
2009-02-07 07:45:50 -08:00
|
|
|
if (emission[0])
|
2008-10-15 07:11:11 -07:00
|
|
|
escb->signal = eina_stringshare_add(emission);
|
2009-02-07 07:45:50 -08:00
|
|
|
if (source[0])
|
2008-10-15 07:11:11 -07:00
|
|
|
escb->source = eina_stringshare_add(source);
|
2003-06-23 19:33:04 -07:00
|
|
|
escb->func = func;
|
|
|
|
escb->data = data;
|
2008-10-22 04:34:42 -07:00
|
|
|
ed->callbacks = eina_list_append(ed->callbacks, escb);
|
2003-06-26 07:04:31 -07:00
|
|
|
if (ed->walking_callbacks)
|
|
|
|
{
|
|
|
|
escb->just_added = 1;
|
|
|
|
ed->just_added_callbacks = 1;
|
|
|
|
}
|
2008-02-26 09:56:51 -08:00
|
|
|
else
|
2008-02-26 12:12:00 -08:00
|
|
|
_edje_callbacks_patterns_clean(ed);
|
2003-06-23 19:33:04 -07:00
|
|
|
}
|
|
|
|
|
2006-01-07 00:54:30 -08:00
|
|
|
EAPI void *
|
2003-07-08 03:08:15 -07:00
|
|
|
edje_object_signal_callback_del(Evas_Object *obj, const char *emission, const char *source, void (*func) (void *data, Evas_Object *o, const char *emission, const char *source))
|
2003-06-23 19:33:04 -07:00
|
|
|
{
|
|
|
|
Edje *ed;
|
2008-10-22 04:34:42 -07:00
|
|
|
Eina_List *l;
|
|
|
|
Edje_Signal_Callback *escb;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2003-06-23 19:33:04 -07:00
|
|
|
if ((!emission) || (!source) || (!func)) return NULL;
|
|
|
|
ed = _edje_fetch(obj);
|
2003-10-18 19:11:06 -07:00
|
|
|
if (!ed) return NULL;
|
2003-08-25 17:16:49 -07:00
|
|
|
if (ed->delete_me) return NULL;
|
2008-10-22 04:34:42 -07:00
|
|
|
EINA_LIST_FOREACH(ed->callbacks, l, escb)
|
2003-06-23 19:33:04 -07:00
|
|
|
{
|
2007-09-08 11:31:56 -07:00
|
|
|
if ((escb->func == func) &&
|
2007-02-13 01:58:49 -08:00
|
|
|
((!escb->signal && !emission[0]) ||
|
|
|
|
(escb->signal && !strcmp(escb->signal, emission))) &&
|
2010-10-29 10:14:55 -07:00
|
|
|
((!escb->source && !source[0]) ||
|
|
|
|
(escb->source && !strcmp(escb->source, source))))
|
|
|
|
{
|
|
|
|
void *data;
|
|
|
|
|
|
|
|
data = escb->data;
|
|
|
|
if (ed->walking_callbacks)
|
|
|
|
{
|
|
|
|
escb->delete_me = 1;
|
|
|
|
ed->delete_callbacks = 1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
_edje_callbacks_patterns_clean(ed);
|
|
|
|
|
|
|
|
ed->callbacks = eina_list_remove_list(ed->callbacks, l);
|
|
|
|
if (escb->signal) eina_stringshare_del(escb->signal);
|
|
|
|
if (escb->source) eina_stringshare_del(escb->source);
|
|
|
|
free(escb);
|
|
|
|
}
|
|
|
|
return data;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void *
|
|
|
|
edje_object_signal_callback_del_full(Evas_Object *obj, const char *emission, const char *source, Edje_Signal_Cb func, void *data)
|
|
|
|
{
|
|
|
|
Edje *ed;
|
|
|
|
Eina_List *l;
|
|
|
|
Edje_Signal_Callback *escb;
|
|
|
|
|
|
|
|
if ((!emission) || (!source) || (!func)) return NULL;
|
|
|
|
ed = _edje_fetch(obj);
|
|
|
|
if (!ed) return NULL;
|
|
|
|
if (ed->delete_me) return NULL;
|
|
|
|
EINA_LIST_FOREACH(ed->callbacks, l, escb)
|
|
|
|
{
|
|
|
|
if ((escb->func == func) && (escb->data == data) &&
|
|
|
|
((!escb->signal && !emission[0]) ||
|
|
|
|
(escb->signal && !strcmp(escb->signal, emission))) &&
|
2007-02-13 01:58:49 -08:00
|
|
|
((!escb->source && !source[0]) ||
|
|
|
|
(escb->source && !strcmp(escb->source, source))))
|
2003-06-23 19:33:04 -07:00
|
|
|
{
|
2011-08-18 03:59:34 -07:00
|
|
|
void *data2;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2011-08-18 03:59:34 -07:00
|
|
|
data2 = escb->data;
|
2003-06-26 07:04:31 -07:00
|
|
|
if (ed->walking_callbacks)
|
|
|
|
{
|
|
|
|
escb->delete_me = 1;
|
|
|
|
ed->delete_callbacks = 1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2008-02-26 12:12:00 -08:00
|
|
|
_edje_callbacks_patterns_clean(ed);
|
2008-02-21 10:48:36 -08:00
|
|
|
|
2008-10-22 04:34:42 -07:00
|
|
|
ed->callbacks = eina_list_remove_list(ed->callbacks, l);
|
2008-10-15 07:11:11 -07:00
|
|
|
if (escb->signal) eina_stringshare_del(escb->signal);
|
|
|
|
if (escb->source) eina_stringshare_del(escb->source);
|
2003-06-26 07:04:31 -07:00
|
|
|
free(escb);
|
|
|
|
}
|
2011-08-18 03:59:34 -07:00
|
|
|
return data2;
|
2003-06-23 19:33:04 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2006-01-07 00:54:30 -08:00
|
|
|
EAPI void
|
2003-07-08 03:08:15 -07:00
|
|
|
edje_object_signal_emit(Evas_Object *obj, const char *emission, const char *source)
|
2003-06-23 19:33:04 -07:00
|
|
|
{
|
|
|
|
Edje *ed;
|
|
|
|
|
|
|
|
if ((!emission) || (!source)) return;
|
|
|
|
ed = _edje_fetch(obj);
|
|
|
|
if (!ed) return;
|
2003-08-25 17:16:49 -07:00
|
|
|
if (ed->delete_me) return;
|
2003-06-23 19:33:04 -07:00
|
|
|
_edje_emit(ed, (char *)emission, (char *)source);
|
|
|
|
}
|
|
|
|
|
2004-06-05 21:42:17 -07:00
|
|
|
/* FIXDOC: Verify/Expand */
|
2006-01-07 00:54:30 -08:00
|
|
|
EAPI void
|
2010-02-28 07:57:17 -08:00
|
|
|
edje_object_play_set(Evas_Object *obj, Eina_Bool play)
|
2003-07-07 00:55:18 -07:00
|
|
|
{
|
|
|
|
Edje *ed;
|
|
|
|
double t;
|
2008-10-22 04:34:42 -07:00
|
|
|
Eina_List *l;
|
|
|
|
Edje_Running_Program *runp;
|
2010-08-12 05:58:54 -07:00
|
|
|
unsigned int i;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2003-07-07 00:55:18 -07:00
|
|
|
ed = _edje_fetch(obj);
|
|
|
|
if (!ed) return;
|
2003-08-25 17:16:49 -07:00
|
|
|
if (ed->delete_me) return;
|
2003-07-07 00:55:18 -07:00
|
|
|
if (play)
|
|
|
|
{
|
|
|
|
if (!ed->paused) return;
|
|
|
|
ed->paused = 0;
|
|
|
|
t = ecore_time_get() - ed->paused_at;
|
2008-10-22 04:34:42 -07:00
|
|
|
EINA_LIST_FOREACH(ed->actions, l, runp)
|
|
|
|
runp->start_time += t;
|
2003-07-07 00:55:18 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (ed->paused) return;
|
2010-02-28 07:57:17 -08:00
|
|
|
ed->paused = EINA_TRUE;
|
2003-07-07 00:55:18 -07:00
|
|
|
ed->paused_at = ecore_time_get();
|
|
|
|
}
|
2007-05-26 22:28:07 -07:00
|
|
|
|
|
|
|
for (i = 0; i < ed->table_parts_size; i++)
|
|
|
|
{
|
|
|
|
Edje_Real_Part *rp;
|
|
|
|
rp = ed->table_parts[i];
|
|
|
|
if (rp->part->type == EDJE_PART_TYPE_GROUP && rp->swallowed_object)
|
|
|
|
edje_object_play_set(rp->swallowed_object, play);
|
|
|
|
}
|
2003-07-07 00:55:18 -07:00
|
|
|
}
|
|
|
|
|
2010-02-28 07:57:17 -08:00
|
|
|
EAPI Eina_Bool
|
2008-08-14 11:21:27 -07:00
|
|
|
edje_object_play_get(const Evas_Object *obj)
|
2003-07-07 00:55:18 -07:00
|
|
|
{
|
|
|
|
Edje *ed;
|
|
|
|
|
|
|
|
ed = _edje_fetch(obj);
|
2010-02-28 07:57:17 -08:00
|
|
|
if (!ed) return EINA_FALSE;
|
|
|
|
if (ed->delete_me) return EINA_FALSE;
|
|
|
|
if (ed->paused) return EINA_FALSE;
|
|
|
|
return EINA_TRUE;
|
2003-07-07 00:55:18 -07:00
|
|
|
}
|
|
|
|
|
2004-06-05 21:42:17 -07:00
|
|
|
/* FIXDOC: Verify/Expand */
|
2006-01-07 00:54:30 -08:00
|
|
|
EAPI void
|
2010-02-28 07:57:17 -08:00
|
|
|
edje_object_animation_set(Evas_Object *obj, Eina_Bool on)
|
2003-07-07 00:55:18 -07:00
|
|
|
{
|
|
|
|
Edje *ed;
|
2008-10-22 04:34:42 -07:00
|
|
|
Eina_List *l;
|
2010-08-12 05:58:54 -07:00
|
|
|
unsigned int i;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2003-07-07 00:55:18 -07:00
|
|
|
ed = _edje_fetch(obj);
|
2007-09-08 11:31:56 -07:00
|
|
|
if (!ed) return;
|
2003-08-25 17:16:49 -07:00
|
|
|
if (ed->delete_me) return;
|
|
|
|
_edje_block(ed);
|
2003-07-07 00:55:18 -07:00
|
|
|
ed->no_anim = !on;
|
|
|
|
_edje_freeze(ed);
|
|
|
|
if (!on)
|
|
|
|
{
|
2008-10-22 04:34:42 -07:00
|
|
|
Eina_List *newl = NULL;
|
|
|
|
const void *data;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2008-10-22 04:34:42 -07:00
|
|
|
EINA_LIST_FOREACH(ed->actions, l, data)
|
|
|
|
newl = eina_list_append(newl, data);
|
2003-07-07 00:55:18 -07:00
|
|
|
while (newl)
|
|
|
|
{
|
|
|
|
Edje_Running_Program *runp;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2008-10-22 04:34:42 -07:00
|
|
|
runp = eina_list_data_get(newl);
|
|
|
|
newl = eina_list_remove(newl, eina_list_data_get(newl));
|
2010-02-24 07:37:16 -08:00
|
|
|
_edje_program_run_iterate(runp, runp->start_time + TO_DOUBLE(runp->program->tween.time));
|
2003-08-25 17:16:49 -07:00
|
|
|
if (_edje_block_break(ed))
|
|
|
|
{
|
2008-10-22 04:34:42 -07:00
|
|
|
eina_list_free(newl);
|
2003-08-25 17:16:49 -07:00
|
|
|
goto break_prog;
|
|
|
|
}
|
2003-07-07 00:55:18 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2005-11-23 04:56:06 -08:00
|
|
|
_edje_emit(ed, "load", NULL);
|
2003-07-07 00:55:18 -07:00
|
|
|
if (evas_object_visible_get(obj))
|
|
|
|
{
|
|
|
|
evas_object_hide(obj);
|
|
|
|
evas_object_show(obj);
|
|
|
|
}
|
|
|
|
}
|
2003-08-25 17:16:49 -07:00
|
|
|
break_prog:
|
2007-05-26 22:28:07 -07:00
|
|
|
|
|
|
|
for (i = 0; i < ed->table_parts_size; i++)
|
|
|
|
{
|
|
|
|
Edje_Real_Part *rp;
|
|
|
|
rp = ed->table_parts[i];
|
|
|
|
if (rp->part->type == EDJE_PART_TYPE_GROUP && rp->swallowed_object)
|
|
|
|
edje_object_animation_set(rp->swallowed_object, on);
|
|
|
|
}
|
|
|
|
|
2003-07-07 00:55:18 -07:00
|
|
|
_edje_thaw(ed);
|
2003-08-25 17:16:49 -07:00
|
|
|
_edje_unblock(ed);
|
2003-07-07 00:55:18 -07:00
|
|
|
}
|
|
|
|
|
2009-09-17 15:38:35 -07:00
|
|
|
|
2010-02-28 07:57:17 -08:00
|
|
|
EAPI Eina_Bool
|
2008-08-14 11:21:27 -07:00
|
|
|
edje_object_animation_get(const Evas_Object *obj)
|
2003-07-07 00:55:18 -07:00
|
|
|
{
|
|
|
|
Edje *ed;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2003-07-07 00:55:18 -07:00
|
|
|
ed = _edje_fetch(obj);
|
2010-02-28 07:57:17 -08:00
|
|
|
if (!ed) return EINA_FALSE;
|
|
|
|
if (ed->delete_me) return EINA_FALSE;
|
|
|
|
if (ed->no_anim) return EINA_FALSE;
|
|
|
|
return EINA_TRUE;
|
2003-07-07 00:55:18 -07:00
|
|
|
}
|
|
|
|
|
2003-06-23 19:33:04 -07:00
|
|
|
/* Private Routines */
|
|
|
|
|
2010-02-28 07:57:17 -08:00
|
|
|
Eina_Bool
|
2003-06-23 19:33:04 -07:00
|
|
|
_edje_program_run_iterate(Edje_Running_Program *runp, double tim)
|
|
|
|
{
|
2010-02-24 07:37:16 -08:00
|
|
|
FLOAT_T t, total;
|
2008-10-22 04:34:42 -07:00
|
|
|
Eina_List *l;
|
2003-08-25 17:16:49 -07:00
|
|
|
Edje *ed;
|
2008-10-22 04:34:42 -07:00
|
|
|
Edje_Program_Target *pt;
|
|
|
|
Edje_Real_Part *rp;
|
2003-06-23 19:33:04 -07:00
|
|
|
|
2003-08-25 17:16:49 -07:00
|
|
|
ed = runp->edje;
|
2010-06-05 06:07:08 -07:00
|
|
|
if (ed->delete_me) return EINA_FALSE;
|
2003-08-25 17:16:49 -07:00
|
|
|
_edje_block(ed);
|
|
|
|
_edje_ref(ed);
|
|
|
|
_edje_freeze(ed);
|
2010-02-24 07:37:16 -08:00
|
|
|
t = FROM_DOUBLE(tim - runp->start_time);
|
2003-06-23 19:33:04 -07:00
|
|
|
total = runp->program->tween.time;
|
2010-02-24 07:37:16 -08:00
|
|
|
t = DIV(t, total);
|
|
|
|
if (t > FROM_INT(1)) t = FROM_INT(1);
|
2008-10-22 04:34:42 -07:00
|
|
|
EINA_LIST_FOREACH(runp->program->targets, l, pt)
|
2003-06-23 19:33:04 -07:00
|
|
|
{
|
2004-04-01 07:32:17 -08:00
|
|
|
if (pt->id >= 0)
|
|
|
|
{
|
|
|
|
rp = ed->table_parts[pt->id % ed->table_parts_size];
|
2007-09-08 11:31:56 -07:00
|
|
|
if (rp) _edje_part_pos_set(ed, rp,
|
2011-05-16 06:16:34 -07:00
|
|
|
runp->program->tween.mode, t,
|
|
|
|
runp->program->tween.v1,
|
|
|
|
runp->program->tween.v2);
|
2004-04-01 07:32:17 -08:00
|
|
|
}
|
2003-06-23 19:33:04 -07:00
|
|
|
}
|
2010-02-24 07:37:16 -08:00
|
|
|
if (t >= FROM_INT(1))
|
2003-06-23 19:33:04 -07:00
|
|
|
{
|
2008-10-22 04:34:42 -07:00
|
|
|
Edje_Program_After *pa;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2008-10-22 04:34:42 -07:00
|
|
|
EINA_LIST_FOREACH(runp->program->targets, l, pt)
|
|
|
|
{
|
2004-04-01 07:32:17 -08:00
|
|
|
if (pt->id >= 0)
|
2003-06-23 19:33:04 -07:00
|
|
|
{
|
2004-04-01 07:32:17 -08:00
|
|
|
rp = ed->table_parts[pt->id % ed->table_parts_size];
|
|
|
|
if (rp)
|
|
|
|
{
|
2007-09-08 11:31:56 -07:00
|
|
|
_edje_part_description_apply(ed, rp,
|
|
|
|
runp->program->state,
|
2004-04-01 07:32:17 -08:00
|
|
|
runp->program->value,
|
|
|
|
NULL,
|
|
|
|
0.0);
|
2007-09-08 11:31:56 -07:00
|
|
|
_edje_part_pos_set(ed, rp,
|
2011-05-16 06:16:34 -07:00
|
|
|
runp->program->tween.mode, ZERO,
|
|
|
|
runp->program->tween.v1,
|
|
|
|
runp->program->tween.v2);
|
2004-04-01 07:32:17 -08:00
|
|
|
rp->program = NULL;
|
|
|
|
}
|
2003-06-23 19:33:04 -07:00
|
|
|
}
|
|
|
|
}
|
2003-08-25 17:16:49 -07:00
|
|
|
_edje_recalc(ed);
|
2003-08-13 04:03:20 -07:00
|
|
|
runp->delete_me = 1;
|
2003-08-25 17:16:49 -07:00
|
|
|
if (!ed->walking_actions)
|
2003-08-13 04:03:20 -07:00
|
|
|
{
|
|
|
|
_edje_anim_count--;
|
2008-10-22 04:34:42 -07:00
|
|
|
ed->actions = eina_list_remove(ed->actions, runp);
|
2003-08-25 17:16:49 -07:00
|
|
|
if (!ed->actions)
|
2008-10-22 04:34:42 -07:00
|
|
|
_edje_animators = eina_list_remove(_edje_animators, ed);
|
2003-08-13 04:03:20 -07:00
|
|
|
}
|
2008-09-17 18:48:17 -07:00
|
|
|
// _edje_emit(ed, "program,stop", runp->program->name);
|
2004-02-05 19:40:15 -08:00
|
|
|
if (_edje_block_break(ed))
|
|
|
|
{
|
|
|
|
if (!ed->walking_actions) free(runp);
|
|
|
|
goto break_prog;
|
|
|
|
}
|
2008-10-22 04:34:42 -07:00
|
|
|
EINA_LIST_FOREACH(runp->program->after, l, pa)
|
2003-06-23 19:33:04 -07:00
|
|
|
{
|
|
|
|
Edje_Program *pr;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2004-03-07 18:43:48 -08:00
|
|
|
if (pa->id >= 0)
|
2004-02-05 19:40:15 -08:00
|
|
|
{
|
2004-04-01 07:32:17 -08:00
|
|
|
pr = ed->table_programs[pa->id % ed->table_programs_size];
|
2004-03-27 21:26:17 -08:00
|
|
|
if (pr) _edje_program_run(ed, pr, 0, "", "");
|
2004-03-16 00:38:51 -08:00
|
|
|
if (_edje_block_break(ed))
|
|
|
|
{
|
|
|
|
if (!ed->walking_actions) free(runp);
|
|
|
|
goto break_prog;
|
|
|
|
}
|
2004-02-05 19:40:15 -08:00
|
|
|
}
|
2003-06-23 19:33:04 -07:00
|
|
|
}
|
2003-08-25 17:16:49 -07:00
|
|
|
_edje_thaw(ed);
|
|
|
|
_edje_unref(ed);
|
|
|
|
if (!ed->walking_actions) free(runp);
|
|
|
|
_edje_unblock(ed);
|
2010-06-05 06:07:08 -07:00
|
|
|
return EINA_FALSE;
|
2003-06-23 19:33:04 -07:00
|
|
|
}
|
2003-08-25 17:16:49 -07:00
|
|
|
break_prog:
|
|
|
|
_edje_recalc(ed);
|
|
|
|
_edje_thaw(ed);
|
|
|
|
_edje_unref(ed);
|
|
|
|
_edje_unblock(ed);
|
2010-06-05 06:07:08 -07:00
|
|
|
return EINA_TRUE;
|
2003-06-23 19:33:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
_edje_program_end(Edje *ed, Edje_Running_Program *runp)
|
|
|
|
{
|
2008-10-22 04:34:42 -07:00
|
|
|
Eina_List *l;
|
|
|
|
Edje_Program_Target *pt;
|
2010-07-30 21:28:27 -07:00
|
|
|
// const char *pname = NULL;
|
2005-10-04 10:54:36 -07:00
|
|
|
int free_runp = 0;
|
2003-06-23 19:33:04 -07:00
|
|
|
|
2003-08-25 17:16:49 -07:00
|
|
|
if (ed->delete_me) return;
|
|
|
|
_edje_ref(ed);
|
|
|
|
_edje_freeze(ed);
|
2008-10-22 04:34:42 -07:00
|
|
|
EINA_LIST_FOREACH(runp->program->targets, l, pt)
|
2003-06-23 19:33:04 -07:00
|
|
|
{
|
|
|
|
Edje_Real_Part *rp;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2004-04-01 07:32:17 -08:00
|
|
|
if (pt->id >= 0)
|
2003-06-23 19:33:04 -07:00
|
|
|
{
|
2004-04-01 07:32:17 -08:00
|
|
|
rp = ed->table_parts[pt->id % ed->table_parts_size];
|
|
|
|
if (rp)
|
|
|
|
{
|
2007-09-08 11:31:56 -07:00
|
|
|
_edje_part_description_apply(ed, rp,
|
|
|
|
runp->program->state,
|
2004-04-01 07:32:17 -08:00
|
|
|
runp->program->value,
|
|
|
|
NULL,
|
|
|
|
0.0);
|
2007-09-08 11:31:56 -07:00
|
|
|
_edje_part_pos_set(ed, rp,
|
2011-05-16 06:16:34 -07:00
|
|
|
runp->program->tween.mode, ZERO,
|
|
|
|
runp->program->tween.v1,
|
|
|
|
runp->program->tween.v2);
|
2004-04-01 07:32:17 -08:00
|
|
|
rp->program = NULL;
|
|
|
|
}
|
2003-06-23 19:33:04 -07:00
|
|
|
}
|
|
|
|
}
|
2003-08-25 17:16:49 -07:00
|
|
|
_edje_recalc(ed);
|
2003-08-13 04:03:20 -07:00
|
|
|
runp->delete_me = 1;
|
2010-07-30 21:28:27 -07:00
|
|
|
// pname = runp->program->name;
|
2003-08-25 17:16:49 -07:00
|
|
|
if (!ed->walking_actions)
|
2003-08-13 04:03:20 -07:00
|
|
|
{
|
|
|
|
_edje_anim_count--;
|
2008-10-22 04:34:42 -07:00
|
|
|
ed->actions = eina_list_remove(ed->actions, runp);
|
2005-10-04 10:54:36 -07:00
|
|
|
free_runp = 1;
|
2003-08-25 17:16:49 -07:00
|
|
|
if (!ed->actions)
|
|
|
|
{
|
2008-10-22 04:34:42 -07:00
|
|
|
_edje_animators = eina_list_remove(_edje_animators, ed);
|
2003-08-25 17:16:49 -07:00
|
|
|
}
|
2003-08-13 04:03:20 -07:00
|
|
|
}
|
2008-09-17 18:48:17 -07:00
|
|
|
// _edje_emit(ed, "program,stop", pname);
|
2003-08-25 17:16:49 -07:00
|
|
|
_edje_thaw(ed);
|
2007-09-08 11:31:56 -07:00
|
|
|
_edje_unref(ed);
|
2005-10-04 10:54:36 -07:00
|
|
|
if (free_runp) free(runp);
|
2003-06-23 19:33:04 -07:00
|
|
|
}
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2003-06-23 19:33:04 -07:00
|
|
|
void
|
2010-02-28 07:57:17 -08:00
|
|
|
_edje_program_run(Edje *ed, Edje_Program *pr, Eina_Bool force, const char *ssig, const char *ssrc)
|
2003-06-23 19:33:04 -07:00
|
|
|
{
|
2008-10-22 04:34:42 -07:00
|
|
|
Eina_List *l;
|
|
|
|
Edje_Real_Part *rp;
|
|
|
|
Edje_Program_Target *pt;
|
|
|
|
Edje_Program *pr2;
|
|
|
|
Edje_Program_After *pa;
|
2003-06-27 20:08:25 -07:00
|
|
|
/* limit self-feeding loops in programs to 64 levels */
|
|
|
|
static int recursions = 0;
|
|
|
|
static int recursion_limit = 0;
|
2003-06-23 19:33:04 -07:00
|
|
|
|
2003-08-25 17:16:49 -07:00
|
|
|
if (ed->delete_me) return;
|
2003-08-05 04:51:28 -07:00
|
|
|
if ((pr->in.from > 0.0) && (pr->in.range >= 0.0) && (!force))
|
2003-06-27 21:20:41 -07:00
|
|
|
{
|
|
|
|
Edje_Pending_Program *pp;
|
2003-08-05 04:51:28 -07:00
|
|
|
double r = 0.0;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2003-06-27 21:20:41 -07:00
|
|
|
pp = calloc(1, sizeof(Edje_Pending_Program));
|
|
|
|
if (!pp) return;
|
|
|
|
if (pr->in.range > 0.0) r = ((double)rand() / RAND_MAX);
|
2007-09-08 11:31:56 -07:00
|
|
|
pp->timer = ecore_timer_add(pr->in.from + (pr->in.range * r),
|
2003-06-27 21:20:41 -07:00
|
|
|
_edje_pending_timer_cb, pp);
|
|
|
|
if (!pp->timer)
|
|
|
|
{
|
|
|
|
free(pp);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
pp->edje = ed;
|
|
|
|
pp->program = pr;
|
2008-10-22 04:34:42 -07:00
|
|
|
ed->pending_actions = eina_list_append(ed->pending_actions, pp);
|
2003-06-27 21:20:41 -07:00
|
|
|
return;
|
|
|
|
}
|
2003-06-27 20:08:25 -07:00
|
|
|
if ((recursions >= 64) || (recursion_limit))
|
|
|
|
{
|
2009-12-22 05:46:00 -08:00
|
|
|
ERR("Programs recursing up to recursion limit of %i. Disabled.",
|
|
|
|
64);
|
2003-06-27 20:08:25 -07:00
|
|
|
recursion_limit = 1;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
recursions++;
|
2003-08-25 17:16:49 -07:00
|
|
|
_edje_block(ed);
|
2003-06-26 07:04:31 -07:00
|
|
|
_edje_ref(ed);
|
2003-08-25 17:16:49 -07:00
|
|
|
_edje_freeze(ed);
|
2010-08-24 18:16:34 -07:00
|
|
|
switch (pr->action)
|
2003-06-23 19:33:04 -07:00
|
|
|
{
|
2010-08-24 18:16:34 -07:00
|
|
|
case EDJE_ACTION_TYPE_STATE_SET:
|
2010-02-24 07:37:16 -08:00
|
|
|
if ((pr->tween.time > ZERO) && (!ed->no_anim))
|
2003-06-23 19:33:04 -07:00
|
|
|
{
|
|
|
|
Edje_Running_Program *runp;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2003-06-23 19:33:04 -07:00
|
|
|
runp = calloc(1, sizeof(Edje_Running_Program));
|
2008-10-22 04:34:42 -07:00
|
|
|
EINA_LIST_FOREACH(pr->targets, l, pt)
|
2003-06-23 19:33:04 -07:00
|
|
|
{
|
2004-04-01 07:32:17 -08:00
|
|
|
if (pt->id >= 0)
|
2003-06-23 19:33:04 -07:00
|
|
|
{
|
2004-04-01 07:32:17 -08:00
|
|
|
rp = ed->table_parts[pt->id % ed->table_parts_size];
|
|
|
|
if (rp)
|
|
|
|
{
|
|
|
|
if (rp->program)
|
|
|
|
_edje_program_end(ed, rp->program);
|
2007-09-08 11:31:56 -07:00
|
|
|
_edje_part_description_apply(ed, rp,
|
2010-07-29 05:02:36 -07:00
|
|
|
rp->param1.description->state.name,
|
|
|
|
rp->param1.description->state.value,
|
2007-09-08 11:31:56 -07:00
|
|
|
pr->state,
|
2004-04-01 07:32:17 -08:00
|
|
|
pr->value);
|
2011-05-16 06:16:34 -07:00
|
|
|
_edje_part_pos_set(ed, rp, pr->tween.mode, ZERO,
|
|
|
|
pr->tween.v1,
|
|
|
|
pr->tween.v2);
|
2004-04-01 07:32:17 -08:00
|
|
|
rp->program = runp;
|
|
|
|
}
|
2003-06-23 19:33:04 -07:00
|
|
|
}
|
|
|
|
}
|
2010-08-24 18:16:34 -07:00
|
|
|
// _edje_emit(ed, "program,start", pr->name);
|
2004-03-07 18:43:48 -08:00
|
|
|
if (_edje_block_break(ed))
|
|
|
|
{
|
2008-10-22 04:34:42 -07:00
|
|
|
ed->actions = eina_list_append(ed->actions, runp);
|
2004-03-07 18:43:48 -08:00
|
|
|
goto break_prog;
|
|
|
|
}
|
2003-06-23 19:33:04 -07:00
|
|
|
if (!ed->actions)
|
2008-10-22 04:34:42 -07:00
|
|
|
_edje_animators = eina_list_append(_edje_animators, ed);
|
|
|
|
ed->actions = eina_list_append(ed->actions, runp);
|
2008-11-01 19:43:43 -07:00
|
|
|
runp->start_time = ecore_loop_time_get();
|
2003-06-23 19:33:04 -07:00
|
|
|
runp->edje = ed;
|
|
|
|
runp->program = pr;
|
|
|
|
if (!_edje_timer)
|
2004-09-05 01:11:36 -07:00
|
|
|
_edje_timer = ecore_animator_add(_edje_timer_cb, NULL);
|
2003-06-23 19:33:04 -07:00
|
|
|
_edje_anim_count++;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2008-10-22 04:34:42 -07:00
|
|
|
EINA_LIST_FOREACH(pr->targets, l, pt)
|
2003-06-23 19:33:04 -07:00
|
|
|
{
|
2004-04-01 07:32:17 -08:00
|
|
|
if (pt->id >= 0)
|
2003-06-23 19:33:04 -07:00
|
|
|
{
|
2004-04-01 07:32:17 -08:00
|
|
|
rp = ed->table_parts[pt->id % ed->table_parts_size];
|
|
|
|
if (rp)
|
|
|
|
{
|
|
|
|
if (rp->program)
|
|
|
|
_edje_program_end(ed, rp->program);
|
2007-09-08 11:31:56 -07:00
|
|
|
_edje_part_description_apply(ed, rp,
|
|
|
|
pr->state,
|
2004-04-01 07:32:17 -08:00
|
|
|
pr->value,
|
|
|
|
NULL,
|
|
|
|
0.0);
|
2011-05-16 06:16:34 -07:00
|
|
|
_edje_part_pos_set(ed, rp, pr->tween.mode, ZERO,
|
|
|
|
pr->tween.v1,
|
|
|
|
pr->tween.v2);
|
2004-04-01 07:32:17 -08:00
|
|
|
}
|
2003-06-23 19:33:04 -07:00
|
|
|
}
|
|
|
|
}
|
2010-08-24 18:16:34 -07:00
|
|
|
// _edje_emit(ed, "program,start", pr->name);
|
2003-08-25 17:16:49 -07:00
|
|
|
if (_edje_block_break(ed)) goto break_prog;
|
2010-08-24 18:16:34 -07:00
|
|
|
// _edje_emit(ed, "program,stop", pr->name);
|
2003-08-25 17:16:49 -07:00
|
|
|
if (_edje_block_break(ed)) goto break_prog;
|
2004-03-07 18:43:48 -08:00
|
|
|
|
2008-10-22 04:34:42 -07:00
|
|
|
EINA_LIST_FOREACH(pr->after, l, pa)
|
2003-08-08 00:45:39 -07:00
|
|
|
{
|
2004-03-07 18:43:48 -08:00
|
|
|
if (pa->id >= 0)
|
|
|
|
{
|
2004-04-01 07:32:17 -08:00
|
|
|
pr2 = ed->table_programs[pa->id % ed->table_programs_size];
|
2004-03-27 21:26:17 -08:00
|
|
|
if (pr2) _edje_program_run(ed, pr2, 0, "", "");
|
2004-03-07 18:43:48 -08:00
|
|
|
if (_edje_block_break(ed)) goto break_prog;
|
|
|
|
}
|
2003-08-08 00:45:39 -07:00
|
|
|
}
|
2003-06-23 19:33:04 -07:00
|
|
|
_edje_recalc(ed);
|
|
|
|
}
|
2010-08-24 18:16:34 -07:00
|
|
|
break;
|
|
|
|
case EDJE_ACTION_TYPE_ACTION_STOP:
|
|
|
|
// _edje_emit(ed, "program,start", pr->name);
|
2008-10-22 04:34:42 -07:00
|
|
|
EINA_LIST_FOREACH(pr->targets, l, pt)
|
2003-06-23 19:33:04 -07:00
|
|
|
{
|
2008-10-22 04:34:42 -07:00
|
|
|
Eina_List *ll;
|
|
|
|
Edje_Running_Program *runp;
|
|
|
|
Edje_Pending_Program *pp;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2010-11-09 01:44:39 -08:00
|
|
|
for (ll = ed->actions; ll; )
|
|
|
|
{
|
|
|
|
runp = ll->data;
|
|
|
|
ll = ll->next;
|
2003-06-23 19:33:04 -07:00
|
|
|
if (pt->id == runp->program->id)
|
|
|
|
{
|
|
|
|
_edje_program_end(ed, runp);
|
2009-04-01 02:11:48 -07:00
|
|
|
// goto done;
|
2003-06-23 19:33:04 -07:00
|
|
|
}
|
|
|
|
}
|
2010-11-09 01:44:39 -08:00
|
|
|
for (ll = ed->pending_actions; ll; )
|
|
|
|
{
|
|
|
|
pp = ll->data;
|
|
|
|
ll = ll->next;
|
2003-08-04 20:15:12 -07:00
|
|
|
if (pt->id == pp->program->id)
|
|
|
|
{
|
2008-10-22 04:34:42 -07:00
|
|
|
ed->pending_actions = eina_list_remove(ed->pending_actions, pp);
|
2003-08-04 20:15:12 -07:00
|
|
|
ecore_timer_del(pp->timer);
|
|
|
|
free(pp);
|
2009-04-01 02:11:48 -07:00
|
|
|
// goto done;
|
2003-08-04 20:15:12 -07:00
|
|
|
}
|
|
|
|
}
|
2009-11-08 12:26:36 -08:00
|
|
|
// done:
|
|
|
|
// continue;
|
2003-06-23 19:33:04 -07:00
|
|
|
}
|
2010-08-24 18:16:34 -07:00
|
|
|
// _edje_emit(ed, "program,stop", pr->name);
|
2003-08-25 17:16:49 -07:00
|
|
|
if (_edje_block_break(ed)) goto break_prog;
|
2010-08-24 18:16:34 -07:00
|
|
|
break;
|
|
|
|
case EDJE_ACTION_TYPE_SIGNAL_EMIT:
|
|
|
|
// _edje_emit(ed, "program,start", pr->name);
|
2003-08-25 17:16:49 -07:00
|
|
|
if (_edje_block_break(ed)) goto break_prog;
|
2003-06-23 19:33:04 -07:00
|
|
|
_edje_emit(ed, pr->state, pr->state2);
|
2003-08-25 17:16:49 -07:00
|
|
|
if (_edje_block_break(ed)) goto break_prog;
|
2010-08-24 18:16:34 -07:00
|
|
|
// _edje_emit(ed, "program,stop", pr->name);
|
2003-08-25 17:16:49 -07:00
|
|
|
if (_edje_block_break(ed)) goto break_prog;
|
2010-08-24 18:16:34 -07:00
|
|
|
break;
|
|
|
|
case EDJE_ACTION_TYPE_DRAG_VAL_SET:
|
|
|
|
// _edje_emit(ed, "program,start", pr->name);
|
2003-08-31 19:53:08 -07:00
|
|
|
if (_edje_block_break(ed)) goto break_prog;
|
2008-10-22 04:34:42 -07:00
|
|
|
EINA_LIST_FOREACH(pr->targets, l, pt)
|
2003-08-31 19:53:08 -07:00
|
|
|
{
|
2004-04-01 07:32:17 -08:00
|
|
|
if (pt->id >= 0)
|
2003-08-31 19:53:08 -07:00
|
|
|
{
|
2004-04-01 07:32:17 -08:00
|
|
|
rp = ed->table_parts[pt->id % ed->table_parts_size];
|
2009-08-11 05:47:00 -07:00
|
|
|
if ((rp) && (rp->drag) && (rp->drag->down.count == 0))
|
2004-04-01 07:32:17 -08:00
|
|
|
{
|
2009-08-11 05:47:00 -07:00
|
|
|
rp->drag->val.x = pr->value;
|
|
|
|
rp->drag->val.y = pr->value2;
|
|
|
|
if (rp->drag->val.x < 0.0) rp->drag->val.x = 0.0;
|
|
|
|
else if (rp->drag->val.x > 1.0) rp->drag->val.x = 1.0;
|
|
|
|
if (rp->drag->val.y < 0.0) rp->drag->val.y = 0.0;
|
|
|
|
else if (rp->drag->val.y > 1.0) rp->drag->val.y = 1.0;
|
|
|
|
_edje_dragable_pos_set(ed, rp, rp->drag->val.x, rp->drag->val.y);
|
2004-04-01 07:32:17 -08:00
|
|
|
_edje_emit(ed, "drag,set", rp->part->name);
|
|
|
|
if (_edje_block_break(ed)) goto break_prog;
|
|
|
|
}
|
2003-08-31 19:53:08 -07:00
|
|
|
}
|
|
|
|
}
|
2010-08-24 18:16:34 -07:00
|
|
|
// _edje_emit(ed, "program,stop", pr->name);
|
2003-08-31 19:53:08 -07:00
|
|
|
if (_edje_block_break(ed)) goto break_prog;
|
2010-08-24 18:16:34 -07:00
|
|
|
break;
|
|
|
|
case EDJE_ACTION_TYPE_DRAG_VAL_STEP:
|
|
|
|
// _edje_emit(ed, "program,start", pr->name);
|
2003-08-31 19:53:08 -07:00
|
|
|
if (_edje_block_break(ed)) goto break_prog;
|
2008-10-22 04:34:42 -07:00
|
|
|
EINA_LIST_FOREACH(pr->targets, l, pt)
|
2003-08-31 19:53:08 -07:00
|
|
|
{
|
2004-04-01 07:32:17 -08:00
|
|
|
if (pt->id >= 0)
|
2003-08-31 19:53:08 -07:00
|
|
|
{
|
2004-04-01 07:32:17 -08:00
|
|
|
rp = ed->table_parts[pt->id % ed->table_parts_size];
|
2009-08-11 05:47:00 -07:00
|
|
|
if ((rp) && (rp->drag) && (rp->drag->down.count == 0))
|
2004-04-01 07:32:17 -08:00
|
|
|
{
|
2009-08-11 05:47:00 -07:00
|
|
|
rp->drag->val.x += pr->value * rp->drag->step.x * rp->part->dragable.x;
|
|
|
|
rp->drag->val.y += pr->value2 * rp->drag->step.y * rp->part->dragable.y;
|
|
|
|
if (rp->drag->val.x < 0.0) rp->drag->val.x = 0.0;
|
|
|
|
else if (rp->drag->val.x > 1.0) rp->drag->val.x = 1.0;
|
|
|
|
if (rp->drag->val.y < 0.0) rp->drag->val.y = 0.0;
|
|
|
|
else if (rp->drag->val.y > 1.0) rp->drag->val.y = 1.0;
|
|
|
|
_edje_dragable_pos_set(ed, rp, rp->drag->val.x, rp->drag->val.y);
|
2004-04-01 07:32:17 -08:00
|
|
|
_edje_emit(ed, "drag,step", rp->part->name);
|
|
|
|
if (_edje_block_break(ed)) goto break_prog;
|
|
|
|
}
|
2003-08-31 19:53:08 -07:00
|
|
|
}
|
|
|
|
}
|
2010-08-24 18:16:34 -07:00
|
|
|
// _edje_emit(ed, "program,stop", pr->name);
|
2003-08-31 19:53:08 -07:00
|
|
|
if (_edje_block_break(ed)) goto break_prog;
|
2010-08-24 18:16:34 -07:00
|
|
|
break;
|
|
|
|
case EDJE_ACTION_TYPE_DRAG_VAL_PAGE:
|
|
|
|
// _edje_emit(ed, "program,start", pr->name);
|
2003-08-31 19:53:08 -07:00
|
|
|
if (_edje_block_break(ed)) goto break_prog;
|
2008-10-22 04:34:42 -07:00
|
|
|
EINA_LIST_FOREACH(pr->targets, l, pt)
|
2003-08-31 19:53:08 -07:00
|
|
|
{
|
2004-04-01 07:32:17 -08:00
|
|
|
if (pt->id >= 0)
|
2003-08-31 19:53:08 -07:00
|
|
|
{
|
2004-04-01 07:32:17 -08:00
|
|
|
rp = ed->table_parts[pt->id % ed->table_parts_size];
|
2009-08-11 05:47:00 -07:00
|
|
|
if ((rp) && (rp->drag) && (rp->drag->down.count == 0))
|
2004-04-01 07:32:17 -08:00
|
|
|
{
|
2009-08-11 05:47:00 -07:00
|
|
|
rp->drag->val.x += pr->value * rp->drag->page.x * rp->part->dragable.x;
|
|
|
|
rp->drag->val.y += pr->value2 * rp->drag->page.y * rp->part->dragable.y;
|
|
|
|
if (rp->drag->val.x < 0.0) rp->drag->val.x = 0.0;
|
|
|
|
else if (rp->drag->val.x > 1.0) rp->drag->val.x = 1.0;
|
|
|
|
if (rp->drag->val.y < 0.0) rp->drag->val.y = 0.0;
|
|
|
|
else if (rp->drag->val.y > 1.0) rp->drag->val.y = 1.0;
|
|
|
|
_edje_dragable_pos_set(ed, rp, rp->drag->val.x, rp->drag->val.y);
|
2004-04-01 07:32:17 -08:00
|
|
|
_edje_emit(ed, "drag,page", rp->part->name);
|
|
|
|
if (_edje_block_break(ed)) goto break_prog;
|
|
|
|
}
|
2003-08-31 19:53:08 -07:00
|
|
|
}
|
|
|
|
}
|
2010-08-24 18:16:34 -07:00
|
|
|
// _edje_emit(ed, "program,stop", pr->name);
|
2003-08-31 19:53:08 -07:00
|
|
|
if (_edje_block_break(ed)) goto break_prog;
|
2010-08-24 18:16:34 -07:00
|
|
|
break;
|
|
|
|
case EDJE_ACTION_TYPE_SCRIPT:
|
|
|
|
{
|
|
|
|
char fname[128];
|
|
|
|
|
|
|
|
// _edje_emit(ed, "program,start", pr->name);
|
|
|
|
if (_edje_block_break(ed)) goto break_prog;
|
|
|
|
snprintf(fname, sizeof(fname), "_p%i", pr->id);
|
|
|
|
_edje_embryo_test_run(ed, fname, ssig, ssrc);
|
|
|
|
// _edje_emit(ed, "program,stop", pr->name);
|
|
|
|
if (_edje_block_break(ed)) goto break_prog;
|
|
|
|
_edje_recalc_do(ed);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case EDJE_ACTION_TYPE_FOCUS_SET:
|
2008-10-13 02:19:04 -07:00
|
|
|
if (!pr->targets)
|
2010-08-24 18:16:34 -07:00
|
|
|
ed->focused_part = NULL;
|
2008-10-13 02:19:04 -07:00
|
|
|
else
|
|
|
|
{
|
2010-02-23 05:39:19 -08:00
|
|
|
EINA_LIST_FOREACH(pr->targets, l, pt)
|
2008-10-13 02:19:04 -07:00
|
|
|
{
|
|
|
|
if (pt->id >= 0)
|
|
|
|
{
|
|
|
|
rp = ed->table_parts[pt->id % ed->table_parts_size];
|
|
|
|
if (rp)
|
|
|
|
{
|
|
|
|
if (ed->focused_part != rp)
|
|
|
|
{
|
|
|
|
if (ed->focused_part)
|
|
|
|
_edje_emit(ed, "focus,part,out",
|
|
|
|
ed->focused_part->part->name);
|
|
|
|
ed->focused_part = rp;
|
|
|
|
_edje_emit(ed, "focus,part,in",
|
|
|
|
ed->focused_part->part->name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2010-08-24 18:16:34 -07:00
|
|
|
break;
|
|
|
|
case EDJE_ACTION_TYPE_FOCUS_OBJECT:
|
2010-02-23 05:39:19 -08:00
|
|
|
if (!pr->targets)
|
|
|
|
{
|
|
|
|
Evas_Object *focused;
|
|
|
|
|
|
|
|
focused = evas_focus_get(evas_object_evas_get(ed->obj));
|
|
|
|
if (focused)
|
|
|
|
{
|
2010-08-12 05:58:54 -07:00
|
|
|
unsigned int i;
|
2010-02-23 05:39:19 -08:00
|
|
|
|
|
|
|
/* Check if the current swallowed object is one of my child. */
|
|
|
|
for (i = 0; i < ed->table_parts_size; ++i)
|
|
|
|
{
|
|
|
|
rp = ed->table_parts[i];
|
|
|
|
if (rp && rp->swallowed_object == focused)
|
|
|
|
{
|
|
|
|
evas_object_focus_set(focused, EINA_FALSE);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
EINA_LIST_FOREACH(pr->targets, l, pt)
|
|
|
|
{
|
|
|
|
if (pt->id >= 0)
|
|
|
|
{
|
|
|
|
rp = ed->table_parts[pt->id % ed->table_parts_size];
|
|
|
|
if (rp && rp->swallowed_object)
|
2010-08-24 18:16:34 -07:00
|
|
|
evas_object_focus_set(rp->swallowed_object, EINA_TRUE);
|
2010-02-23 05:39:19 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2010-08-24 18:16:34 -07:00
|
|
|
break;
|
|
|
|
case EDJE_ACTION_TYPE_PARAM_COPY:
|
|
|
|
{
|
|
|
|
Edje_Real_Part *src_part, *dst_part;
|
|
|
|
|
|
|
|
// _edje_emit(ed, "program,start", pr->name);
|
|
|
|
if (_edje_block_break(ed)) goto break_prog;
|
|
|
|
|
|
|
|
src_part = ed->table_parts[pr->param.src % ed->table_parts_size];
|
|
|
|
dst_part = ed->table_parts[pr->param.dst % ed->table_parts_size];
|
|
|
|
_edje_param_copy(src_part, pr->state, dst_part, pr->state2);
|
|
|
|
|
|
|
|
if (_edje_block_break(ed)) goto break_prog;
|
|
|
|
// _edje_emit(ed, "program,stop", pr->name);
|
|
|
|
if (_edje_block_break(ed)) goto break_prog;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case EDJE_ACTION_TYPE_PARAM_SET:
|
|
|
|
{
|
|
|
|
Edje_Real_Part *part;
|
|
|
|
|
|
|
|
// _edje_emit(ed, "program,start", pr->name);
|
|
|
|
if (_edje_block_break(ed)) goto break_prog;
|
|
|
|
|
|
|
|
part = ed->table_parts[pr->param.dst % ed->table_parts_size];
|
|
|
|
_edje_param_set(part, pr->state, pr->state2);
|
|
|
|
|
|
|
|
if (_edje_block_break(ed)) goto break_prog;
|
|
|
|
// _edje_emit(ed, "program,stop", pr->name);
|
|
|
|
if (_edje_block_break(ed)) goto break_prog;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
// _edje_emit(ed, "program,start", pr->name);
|
|
|
|
// _edje_emit(ed, "program,stop", pr->name);
|
|
|
|
break;
|
2004-08-17 18:09:14 -07:00
|
|
|
}
|
2007-09-08 11:31:56 -07:00
|
|
|
if (!((pr->action == EDJE_ACTION_TYPE_STATE_SET)
|
2003-09-05 00:17:54 -07:00
|
|
|
/* hmm this fucks somethgin up. must look into it later */
|
2010-02-24 07:37:16 -08:00
|
|
|
/* && (pr->tween.time > ZERO) && (!ed->no_anim))) */
|
2003-09-05 00:17:54 -07:00
|
|
|
))
|
2003-08-05 04:51:28 -07:00
|
|
|
{
|
2008-10-22 04:34:42 -07:00
|
|
|
EINA_LIST_FOREACH(pr->after, l, pa)
|
2003-08-05 04:51:28 -07:00
|
|
|
{
|
2004-03-07 18:43:48 -08:00
|
|
|
if (pa->id >= 0)
|
|
|
|
{
|
2004-04-01 07:32:17 -08:00
|
|
|
pr2 = ed->table_programs[pa->id % ed->table_programs_size];
|
|
|
|
if (pr2) _edje_program_run(ed, pr2, 0, "", "");
|
|
|
|
if (_edje_block_break(ed)) goto break_prog;
|
2004-03-07 18:43:48 -08:00
|
|
|
}
|
2003-08-05 04:51:28 -07:00
|
|
|
}
|
2003-06-23 19:33:04 -07:00
|
|
|
}
|
2003-08-25 17:16:49 -07:00
|
|
|
break_prog:
|
2003-06-23 19:33:04 -07:00
|
|
|
_edje_thaw(ed);
|
2003-08-25 17:16:49 -07:00
|
|
|
_edje_unref(ed);
|
2003-06-27 20:08:25 -07:00
|
|
|
recursions--;
|
|
|
|
if (recursions == 0) recursion_limit = 0;
|
2003-08-25 17:16:49 -07:00
|
|
|
_edje_unblock(ed);
|
2003-06-23 19:33:04 -07:00
|
|
|
}
|
|
|
|
|
2004-06-30 20:46:05 -07:00
|
|
|
void
|
2006-03-18 20:22:35 -08:00
|
|
|
_edje_emit(Edje *ed, const char *sig, const char *src)
|
2004-02-04 11:41:27 -08:00
|
|
|
{
|
2004-07-01 20:24:56 -07:00
|
|
|
Edje_Message_Signal emsg;
|
2008-11-16 21:54:01 -08:00
|
|
|
Eina_List *l;
|
|
|
|
Evas_Object *obj;
|
2009-05-02 13:05:53 -07:00
|
|
|
const char *sep;
|
|
|
|
|
2004-06-30 20:46:05 -07:00
|
|
|
if (ed->delete_me) return;
|
2009-05-02 13:05:53 -07:00
|
|
|
|
2011-03-10 09:27:55 -08:00
|
|
|
sep = strchr(sig, EDJE_PART_PATH_SEPARATOR);
|
2010-06-10 08:40:51 -07:00
|
|
|
|
|
|
|
/* If we are not sending the signal to a part of the child, the
|
|
|
|
* signal if for ourself
|
|
|
|
*/
|
2009-05-02 13:05:53 -07:00
|
|
|
if (sep)
|
|
|
|
{
|
2011-01-24 05:29:17 -08:00
|
|
|
Edje_Real_Part *rp = NULL;
|
2011-03-10 09:27:55 -08:00
|
|
|
const char *newsig;
|
2011-01-24 05:29:17 -08:00
|
|
|
Edje *ed2;
|
2009-05-02 16:22:07 -07:00
|
|
|
char *part;
|
2011-03-10 09:27:55 -08:00
|
|
|
char *idx;
|
|
|
|
size_t length;
|
2010-09-13 11:40:32 -07:00
|
|
|
|
2011-03-10 09:27:55 -08:00
|
|
|
/* the signal contains a colon, split the signal into "parts:signal" */
|
|
|
|
length = sep - sig + 1;
|
2010-09-13 11:40:32 -07:00
|
|
|
part = alloca(length);
|
2011-03-10 09:27:55 -08:00
|
|
|
memcpy(part, sig, length - 1);
|
|
|
|
part[length - 1] = '\0';
|
2010-09-13 11:40:32 -07:00
|
|
|
|
2011-03-10 09:27:55 -08:00
|
|
|
newsig = sep + 1;
|
2010-09-13 11:40:32 -07:00
|
|
|
|
2011-03-10 09:27:55 -08:00
|
|
|
/* lookup for alias */
|
|
|
|
if (ed->collection && ed->collection->alias)
|
2011-01-24 05:29:17 -08:00
|
|
|
{
|
2011-03-10 09:27:55 -08:00
|
|
|
char *alias;
|
|
|
|
|
|
|
|
alias = eina_hash_find(ed->collection->alias, part);
|
|
|
|
if (alias) {
|
|
|
|
char *aliased;
|
|
|
|
int alien;
|
|
|
|
int nslen;
|
|
|
|
|
|
|
|
alien = strlen(alias);
|
|
|
|
nslen = strlen(newsig);
|
|
|
|
length = alien + nslen + 2;
|
|
|
|
|
|
|
|
aliased = alloca(length);
|
|
|
|
memcpy(aliased, alias, alien);
|
|
|
|
aliased[alien] = EDJE_PART_PATH_SEPARATOR;
|
|
|
|
memcpy(aliased + alien + 1, newsig, nslen + 1);
|
|
|
|
|
2011-03-24 00:58:00 -07:00
|
|
|
_edje_emit(ed, aliased, src);
|
|
|
|
return;
|
2011-03-10 09:27:55 -08:00
|
|
|
}
|
2011-01-24 05:29:17 -08:00
|
|
|
}
|
2011-03-10 09:27:55 -08:00
|
|
|
|
|
|
|
/* search for the index if present and remove it from the part */
|
|
|
|
idx = strchr(part, EDJE_PART_PATH_SEPARATOR_INDEXL);
|
|
|
|
if (idx)
|
2010-09-13 11:40:32 -07:00
|
|
|
{
|
2011-03-10 09:27:55 -08:00
|
|
|
char *end;
|
|
|
|
|
|
|
|
end = strchr(idx + 1, EDJE_PART_PATH_SEPARATOR_INDEXR);
|
|
|
|
if (end && end != idx + 1)
|
2010-09-13 11:40:32 -07:00
|
|
|
{
|
2011-03-10 09:27:55 -08:00
|
|
|
char *tmp;
|
2010-11-30 05:09:03 -08:00
|
|
|
|
2011-03-10 09:27:55 -08:00
|
|
|
tmp = alloca(end - idx - 1);
|
|
|
|
memcpy(tmp, idx + 1, end - idx - 1);
|
|
|
|
tmp[end - idx - 1] = '\0';
|
|
|
|
*idx = '\0';
|
|
|
|
idx = tmp;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
idx = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* search for the right part now */
|
|
|
|
rp = _edje_real_part_get(ed, part);
|
|
|
|
if (!rp) goto end;
|
|
|
|
|
|
|
|
switch (rp->part->type)
|
|
|
|
{
|
|
|
|
case EDJE_PART_TYPE_GROUP:
|
|
|
|
if (!rp->swallowed_object) goto end;
|
|
|
|
ed2 = _edje_fetch(rp->swallowed_object);
|
|
|
|
if (!ed2) goto end;
|
2011-01-24 05:29:17 -08:00
|
|
|
|
2011-03-10 09:27:55 -08:00
|
|
|
_edje_emit(ed2, newsig, src);
|
|
|
|
break;
|
2011-01-24 05:29:17 -08:00
|
|
|
|
2011-03-10 09:27:55 -08:00
|
|
|
case EDJE_PART_TYPE_EXTERNAL:
|
|
|
|
if (!rp->swallowed_object) break ;
|
|
|
|
|
|
|
|
if (!idx)
|
|
|
|
{
|
|
|
|
_edje_external_signal_emit(rp->swallowed_object, newsig, src);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
Evas_Object *child;
|
|
|
|
|
|
|
|
child = _edje_children_get(rp, idx);
|
|
|
|
ed2 = _edje_fetch(child);
|
|
|
|
if (!ed2) goto end;
|
2011-01-24 05:29:17 -08:00
|
|
|
_edje_emit(ed2, newsig, src);
|
2011-03-10 09:27:55 -08:00
|
|
|
}
|
|
|
|
break ;
|
|
|
|
|
|
|
|
case EDJE_PART_TYPE_BOX:
|
|
|
|
case EDJE_PART_TYPE_TABLE:
|
|
|
|
if (idx)
|
|
|
|
{
|
|
|
|
Evas_Object *child;
|
|
|
|
|
|
|
|
child = _edje_children_get(rp, idx);
|
|
|
|
ed2 = _edje_fetch(child);
|
|
|
|
if (!ed2) goto end;
|
|
|
|
_edje_emit(ed2, newsig, src);
|
|
|
|
}
|
|
|
|
break ;
|
|
|
|
|
|
|
|
default:
|
|
|
|
fprintf(stderr, "SPANK SPANK SPANK !!!\nYou should never be here !\n");
|
|
|
|
break;
|
2010-09-13 11:40:32 -07:00
|
|
|
}
|
2009-05-02 13:05:53 -07:00
|
|
|
}
|
|
|
|
|
2011-03-10 09:27:55 -08:00
|
|
|
end:
|
2004-07-01 20:24:56 -07:00
|
|
|
emsg.sig = sig;
|
|
|
|
emsg.src = src;
|
2004-07-02 03:17:25 -07:00
|
|
|
_edje_message_send(ed, EDJE_QUEUE_SCRIPT, EDJE_MESSAGE_SIGNAL, 0, &emsg);
|
2008-11-16 21:54:01 -08:00
|
|
|
EINA_LIST_FOREACH(ed->subobjs, l, obj)
|
|
|
|
{
|
|
|
|
Edje *ed2;
|
2010-11-30 05:09:03 -08:00
|
|
|
|
2008-11-16 21:54:01 -08:00
|
|
|
ed2 = _edje_fetch(obj);
|
|
|
|
if (!ed2) continue;
|
|
|
|
if (ed2->delete_me) continue;
|
|
|
|
_edje_message_send(ed2, EDJE_QUEUE_SCRIPT, EDJE_MESSAGE_SIGNAL, 0, &emsg);
|
|
|
|
}
|
2004-02-04 11:41:27 -08:00
|
|
|
}
|
|
|
|
|
2008-01-17 22:34:04 -08:00
|
|
|
struct _Edje_Program_Data
|
|
|
|
{
|
|
|
|
#ifdef EDJE_PROGRAM_CACHE
|
2008-10-22 04:34:42 -07:00
|
|
|
Eina_List *matches;
|
2008-01-17 22:34:04 -08:00
|
|
|
int matched;
|
|
|
|
#endif
|
|
|
|
Edje *ed;
|
|
|
|
const char *signal;
|
|
|
|
const char *source;
|
|
|
|
};
|
|
|
|
|
2010-02-28 07:57:17 -08:00
|
|
|
static Eina_Bool _edje_glob_callback(Edje_Program *pr, void *dt)
|
2008-01-17 22:34:04 -08:00
|
|
|
{
|
2010-02-10 07:07:17 -08:00
|
|
|
struct _Edje_Program_Data *data = dt;
|
|
|
|
Edje_Real_Part *rp = NULL;
|
|
|
|
Eina_Bool exec = EINA_TRUE;
|
2008-01-17 22:34:04 -08:00
|
|
|
|
|
|
|
#ifdef EDJE_PROGRAM_CACHE
|
|
|
|
data->matched++;
|
|
|
|
#endif
|
|
|
|
|
2010-02-19 10:30:46 -08:00
|
|
|
if (pr->filter.state)
|
|
|
|
{
|
|
|
|
rp = _edje_real_part_get(data->ed, pr->filter.part ? pr->filter.part : data->source);
|
|
|
|
if (rp)
|
2010-07-29 05:02:36 -07:00
|
|
|
exec = (rp->chosen_description->state.name == pr->filter.state);
|
2010-02-19 10:30:46 -08:00
|
|
|
}
|
2010-02-10 07:07:17 -08:00
|
|
|
|
|
|
|
if (exec)
|
|
|
|
_edje_program_run(data->ed, pr, 0, data->signal, data->source);
|
2010-02-19 10:30:46 -08:00
|
|
|
|
2008-01-17 22:34:04 -08:00
|
|
|
if (_edje_block_break(data->ed))
|
|
|
|
{
|
|
|
|
#ifdef EDJE_PROGRAM_CACHE
|
2008-10-22 04:34:42 -07:00
|
|
|
eina_list_free(data->matches);
|
2008-01-17 22:34:04 -08:00
|
|
|
data->matches = NULL;
|
|
|
|
#endif
|
2010-02-28 07:57:17 -08:00
|
|
|
return EINA_TRUE;
|
2008-01-17 22:34:04 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef EDJE_PROGRAM_CACHE
|
2008-10-22 04:34:42 -07:00
|
|
|
data->matches = eina_list_append(data->matches, pr);
|
2008-01-17 22:34:04 -08:00
|
|
|
#endif
|
|
|
|
|
2010-02-28 07:57:17 -08:00
|
|
|
return EINA_FALSE;
|
2008-01-17 22:34:04 -08:00
|
|
|
}
|
|
|
|
|
2008-02-26 12:12:00 -08:00
|
|
|
|
|
|
|
void
|
|
|
|
_edje_callbacks_patterns_clean(Edje *ed)
|
|
|
|
{
|
|
|
|
_edje_signals_sources_patterns_clean(&ed->patterns.callbacks);
|
2008-11-10 08:37:52 -08:00
|
|
|
|
|
|
|
eina_rbtree_delete(ed->patterns.callbacks.exact_match,
|
|
|
|
EINA_RBTREE_FREE_CB(edje_match_signal_source_free),
|
|
|
|
NULL);
|
|
|
|
ed->patterns.callbacks.exact_match = NULL;
|
|
|
|
|
2010-08-04 07:25:40 -07:00
|
|
|
ed->patterns.callbacks.u.callbacks.globing = eina_list_free(ed->patterns.callbacks.u.callbacks.globing);
|
2008-02-26 12:12:00 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_edje_callbacks_patterns_init(Edje *ed)
|
|
|
|
{
|
|
|
|
Edje_Signals_Sources_Patterns *ssp = &ed->patterns.callbacks;
|
|
|
|
|
2008-12-05 14:32:04 -08:00
|
|
|
if ((ssp->signals_patterns) || (ssp->sources_patterns) ||
|
2010-08-04 07:25:40 -07:00
|
|
|
(ssp->u.callbacks.globing) || (ssp->exact_match))
|
2008-02-26 12:12:00 -08:00
|
|
|
return;
|
|
|
|
|
2010-08-04 07:25:40 -07:00
|
|
|
ssp->u.callbacks.globing = edje_match_callback_hash_build(ed->callbacks,
|
|
|
|
&ssp->exact_match);
|
2008-11-10 08:37:52 -08:00
|
|
|
|
2010-08-04 07:25:40 -07:00
|
|
|
ssp->signals_patterns = edje_match_callback_signal_init(ssp->u.callbacks.globing);
|
|
|
|
ssp->sources_patterns = edje_match_callback_source_init(ssp->u.callbacks.globing);
|
2008-02-26 12:12:00 -08:00
|
|
|
}
|
|
|
|
|
2004-06-30 20:46:05 -07:00
|
|
|
/* FIXME: what if we delete the evas object??? */
|
2003-06-23 19:33:04 -07:00
|
|
|
void
|
2006-03-18 20:22:35 -08:00
|
|
|
_edje_emit_handle(Edje *ed, const char *sig, const char *src)
|
2003-06-23 19:33:04 -07:00
|
|
|
{
|
2003-08-25 17:16:49 -07:00
|
|
|
if (ed->delete_me) return;
|
2005-11-23 06:00:39 -08:00
|
|
|
if (!sig) sig = "";
|
|
|
|
if (!src) src = "";
|
2010-09-03 20:53:12 -07:00
|
|
|
// printf("EDJE EMIT: (%p) signal: \"%s\" source: \"%s\"\n", ed, sig, src);
|
2003-08-25 17:16:49 -07:00
|
|
|
_edje_block(ed);
|
|
|
|
_edje_ref(ed);
|
|
|
|
_edje_freeze(ed);
|
2010-08-24 18:09:44 -07:00
|
|
|
|
2010-07-08 22:12:35 -07:00
|
|
|
if (ed->collection && ed->L)
|
|
|
|
_edje_lua2_script_func_signal(ed, sig, src);
|
2010-08-24 18:09:44 -07:00
|
|
|
|
2004-06-30 20:46:05 -07:00
|
|
|
if (ed->collection)
|
2003-06-23 19:33:04 -07:00
|
|
|
{
|
2004-03-26 01:10:05 -08:00
|
|
|
#ifdef EDJE_PROGRAM_CACHE
|
2010-07-30 21:58:32 -07:00
|
|
|
Edje_Part_Collection *ec;
|
2004-06-30 20:46:05 -07:00
|
|
|
char *tmps;
|
|
|
|
int l1, l2;
|
2007-09-08 11:31:56 -07:00
|
|
|
#endif
|
2004-06-30 20:46:05 -07:00
|
|
|
int done;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2004-03-26 01:10:05 -08:00
|
|
|
#ifdef EDJE_PROGRAM_CACHE
|
2010-07-30 21:58:32 -07:00
|
|
|
ec = ed->collection;
|
2004-06-30 20:46:05 -07:00
|
|
|
l1 = strlen(sig);
|
|
|
|
l2 = strlen(src);
|
2008-12-05 14:32:04 -08:00
|
|
|
tmps = alloca(l1 + l2 + 3); /* \0, \337, \0 */
|
2005-11-30 07:36:34 -08:00
|
|
|
strcpy(tmps, sig);
|
|
|
|
tmps[l1] = '\377';
|
|
|
|
strcpy(&(tmps[l1 + 1]), src);
|
2007-09-08 11:31:56 -07:00
|
|
|
#endif
|
2004-06-30 20:46:05 -07:00
|
|
|
done = 0;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2004-06-30 20:46:05 -07:00
|
|
|
#ifdef EDJE_PROGRAM_CACHE
|
|
|
|
{
|
2008-10-22 04:34:42 -07:00
|
|
|
Eina_List *matches;
|
|
|
|
Eina_List *l;
|
|
|
|
Edje_Program *pr;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2008-12-17 06:26:47 -08:00
|
|
|
if (eina_hash_find(ec->prog_cache.no_matches, tmps))
|
2003-07-19 19:08:47 -07:00
|
|
|
{
|
2004-06-30 20:46:05 -07:00
|
|
|
done = 1;
|
2003-07-19 19:08:47 -07:00
|
|
|
}
|
2008-12-17 06:26:47 -08:00
|
|
|
else if ((matches = eina_hash_find(ec->prog_cache.matches, tmps)))
|
2003-07-19 19:08:47 -07:00
|
|
|
{
|
2008-10-22 04:34:42 -07:00
|
|
|
EINA_LIST_FOREACH(matches, l, pr)
|
2003-07-19 19:08:47 -07:00
|
|
|
{
|
2004-06-30 20:46:05 -07:00
|
|
|
_edje_program_run(ed, pr, 0, sig, src);
|
|
|
|
if (_edje_block_break(ed))
|
2003-07-19 19:08:47 -07:00
|
|
|
{
|
2004-06-30 20:46:05 -07:00
|
|
|
goto break_prog;
|
2003-07-19 19:08:47 -07:00
|
|
|
}
|
|
|
|
}
|
2004-06-30 20:46:05 -07:00
|
|
|
done = 1;
|
2003-07-19 19:08:47 -07:00
|
|
|
}
|
2004-06-30 20:46:05 -07:00
|
|
|
}
|
2004-03-26 01:10:05 -08:00
|
|
|
#endif
|
2004-06-30 20:46:05 -07:00
|
|
|
if (!done)
|
|
|
|
{
|
2008-01-17 22:34:04 -08:00
|
|
|
struct _Edje_Program_Data data;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2008-01-17 22:34:04 -08:00
|
|
|
data.ed = ed;
|
|
|
|
data.source = src;
|
|
|
|
data.signal = sig;
|
2004-03-26 01:10:05 -08:00
|
|
|
#ifdef EDJE_PROGRAM_CACHE
|
2008-01-17 22:34:04 -08:00
|
|
|
data.matched = 0;
|
|
|
|
data.matches = NULL;
|
2007-09-08 11:31:56 -07:00
|
|
|
#endif
|
2010-08-04 07:25:40 -07:00
|
|
|
if (ed->table_programs_size > 0)
|
2008-01-17 22:34:04 -08:00
|
|
|
{
|
2008-11-10 08:37:52 -08:00
|
|
|
const Eina_List *match;
|
|
|
|
const Eina_List *l;
|
|
|
|
Edje_Program *pr;
|
|
|
|
|
2010-08-04 07:25:40 -07:00
|
|
|
if (ed->patterns.programs.u.programs.globing)
|
2008-11-10 08:37:52 -08:00
|
|
|
if (edje_match_programs_exec(ed->patterns.programs.signals_patterns,
|
|
|
|
ed->patterns.programs.sources_patterns,
|
|
|
|
sig,
|
|
|
|
src,
|
2010-08-04 07:25:40 -07:00
|
|
|
ed->patterns.programs.u.programs.globing,
|
2008-11-10 08:37:52 -08:00
|
|
|
_edje_glob_callback,
|
|
|
|
&data) == 0)
|
|
|
|
goto break_prog;
|
|
|
|
|
|
|
|
match = edje_match_signal_source_hash_get(sig, src,
|
|
|
|
ed->patterns.programs.exact_match);
|
|
|
|
EINA_LIST_FOREACH(match, l, pr)
|
|
|
|
_edje_glob_callback(pr, &data);
|
2008-01-17 22:34:04 -08:00
|
|
|
}
|
|
|
|
|
2004-03-26 01:10:05 -08:00
|
|
|
#ifdef EDJE_PROGRAM_CACHE
|
2004-06-30 20:46:05 -07:00
|
|
|
if (tmps)
|
|
|
|
{
|
2008-09-11 04:14:39 -07:00
|
|
|
if (data.matched == 0)
|
2008-12-17 06:26:47 -08:00
|
|
|
{
|
|
|
|
if (!ec->prog_cache.no_matches)
|
|
|
|
ec->prog_cache.no_matches = eina_hash_string_superfast_new(NULL);
|
|
|
|
eina_hash_add(ec->prog_cache.no_matches, tmps, ed);
|
|
|
|
}
|
2004-06-30 20:46:05 -07:00
|
|
|
else
|
2008-12-17 06:26:47 -08:00
|
|
|
{
|
|
|
|
if (!ec->prog_cache.matches)
|
|
|
|
ec->prog_cache.matches = eina_hash_string_superfast_new(NULL);
|
|
|
|
eina_hash_add(ec->prog_cache.matches, tmps, data.matches);
|
|
|
|
}
|
2003-08-25 17:16:49 -07:00
|
|
|
}
|
2007-09-08 11:31:56 -07:00
|
|
|
#endif
|
2004-06-30 20:46:05 -07:00
|
|
|
}
|
|
|
|
_edje_emit_cb(ed, sig, src);
|
|
|
|
if (_edje_block_break(ed))
|
|
|
|
{
|
|
|
|
goto break_prog;
|
2003-06-23 19:33:04 -07:00
|
|
|
}
|
|
|
|
}
|
2003-08-25 17:16:49 -07:00
|
|
|
break_prog:
|
|
|
|
_edje_thaw(ed);
|
|
|
|
_edje_unref(ed);
|
|
|
|
_edje_unblock(ed);
|
2003-06-23 19:33:04 -07:00
|
|
|
}
|
2003-08-15 06:35:25 -07:00
|
|
|
|
2004-06-30 20:46:05 -07:00
|
|
|
/* FIXME: what if we delete the evas object??? */
|
2003-08-15 06:35:25 -07:00
|
|
|
static void
|
2006-03-18 20:22:35 -08:00
|
|
|
_edje_emit_cb(Edje *ed, const char *sig, const char *src)
|
2003-08-15 06:35:25 -07:00
|
|
|
{
|
2008-10-22 04:34:42 -07:00
|
|
|
Eina_List *l;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2003-08-25 17:16:49 -07:00
|
|
|
if (ed->delete_me) return;
|
|
|
|
_edje_ref(ed);
|
2007-09-08 11:31:56 -07:00
|
|
|
_edje_freeze(ed);
|
2003-08-25 17:16:49 -07:00
|
|
|
_edje_block(ed);
|
2008-02-26 09:56:51 -08:00
|
|
|
|
|
|
|
if (ed->just_added_callbacks)
|
2008-02-26 12:12:00 -08:00
|
|
|
_edje_callbacks_patterns_clean(ed);
|
2008-02-26 09:56:51 -08:00
|
|
|
|
2003-08-15 06:35:25 -07:00
|
|
|
ed->walking_callbacks = 1;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2008-01-17 22:34:04 -08:00
|
|
|
if (ed->callbacks)
|
|
|
|
{
|
2008-11-10 08:37:52 -08:00
|
|
|
Edje_Signal_Callback *escb;
|
|
|
|
const Eina_List *match;
|
2011-08-18 03:59:34 -07:00
|
|
|
const Eina_List *l2;
|
2008-11-10 08:37:52 -08:00
|
|
|
int r = 1;
|
2008-01-17 22:34:04 -08:00
|
|
|
|
2008-02-26 12:12:00 -08:00
|
|
|
_edje_callbacks_patterns_init(ed);
|
2010-08-04 07:25:40 -07:00
|
|
|
if (ed->patterns.callbacks.u.callbacks.globing)
|
2008-11-10 08:37:52 -08:00
|
|
|
r = edje_match_callback_exec(ed->patterns.callbacks.signals_patterns,
|
|
|
|
ed->patterns.callbacks.sources_patterns,
|
|
|
|
sig,
|
|
|
|
src,
|
2010-08-04 07:25:40 -07:00
|
|
|
ed->patterns.callbacks.u.callbacks.globing,
|
2008-11-10 08:37:52 -08:00
|
|
|
ed);
|
2008-01-17 22:34:04 -08:00
|
|
|
|
|
|
|
if (!r)
|
2008-02-21 10:48:36 -08:00
|
|
|
goto break_prog;
|
2008-11-10 08:37:52 -08:00
|
|
|
|
|
|
|
match = edje_match_signal_source_hash_get(sig, src,
|
|
|
|
ed->patterns.callbacks.exact_match);
|
2011-08-18 03:59:34 -07:00
|
|
|
EINA_LIST_FOREACH(match, l2, escb)
|
2008-11-10 08:37:52 -08:00
|
|
|
if ((!escb->just_added) && (!escb->delete_me))
|
|
|
|
{
|
|
|
|
escb->func(escb->data, ed->obj, sig, src);
|
|
|
|
if (_edje_block_break(ed))
|
|
|
|
goto break_prog;
|
|
|
|
}
|
2003-08-15 06:35:25 -07:00
|
|
|
}
|
2008-12-05 14:32:04 -08:00
|
|
|
break_prog:
|
2008-01-17 22:34:04 -08:00
|
|
|
|
2003-08-15 06:35:25 -07:00
|
|
|
ed->walking_callbacks = 0;
|
|
|
|
if ((ed->delete_callbacks) || (ed->just_added_callbacks))
|
|
|
|
{
|
|
|
|
ed->delete_callbacks = 0;
|
|
|
|
ed->just_added_callbacks = 0;
|
2008-12-05 14:32:04 -08:00
|
|
|
l = ed->callbacks;
|
|
|
|
while (l)
|
2003-08-15 06:35:25 -07:00
|
|
|
{
|
2008-12-05 14:32:04 -08:00
|
|
|
Edje_Signal_Callback *escb = l->data;
|
|
|
|
Eina_List *next_l = l->next;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2003-08-15 06:35:25 -07:00
|
|
|
if (escb->just_added)
|
|
|
|
escb->just_added = 0;
|
|
|
|
if (escb->delete_me)
|
|
|
|
{
|
2008-10-22 04:34:42 -07:00
|
|
|
ed->callbacks = eina_list_remove_list(ed->callbacks, l);
|
2008-10-15 07:11:11 -07:00
|
|
|
if (escb->signal) eina_stringshare_del(escb->signal);
|
|
|
|
if (escb->source) eina_stringshare_del(escb->source);
|
2003-08-15 06:35:25 -07:00
|
|
|
free(escb);
|
|
|
|
}
|
|
|
|
l = next_l;
|
|
|
|
}
|
2008-02-26 09:56:51 -08:00
|
|
|
|
2008-02-26 12:12:00 -08:00
|
|
|
_edje_callbacks_patterns_clean(ed);
|
2003-08-15 06:35:25 -07:00
|
|
|
}
|
2003-08-25 17:16:49 -07:00
|
|
|
_edje_unblock(ed);
|
|
|
|
_edje_thaw(ed);
|
|
|
|
_edje_unref(ed);
|
2003-08-15 06:35:25 -07:00
|
|
|
}
|
2009-09-28 23:13:33 -07:00
|
|
|
|
2010-03-26 18:26:10 -07:00
|
|
|
static const Edje_External_Param_Info *
|
|
|
|
_edje_external_param_info_get(const Evas_Object *obj, const char *name)
|
|
|
|
{
|
|
|
|
const Edje_External_Type *type;
|
|
|
|
const Edje_External_Param_Info *info;
|
|
|
|
|
|
|
|
type = evas_object_data_get(obj, "Edje_External_Type");
|
|
|
|
if (!type) return NULL;
|
2010-08-21 06:52:25 -07:00
|
|
|
for (info = type->parameters_info; info->name; info++)
|
2010-03-26 18:26:10 -07:00
|
|
|
if (!strcmp(info->name, name)) return info;
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Edje_External_Param *
|
2010-11-19 14:50:33 -08:00
|
|
|
_edje_param_external_get(Edje_Real_Part *rp, const char *name, Edje_External_Param *param)
|
2010-03-26 18:26:10 -07:00
|
|
|
{
|
2010-11-19 14:50:33 -08:00
|
|
|
Evas_Object *swallowed_object = rp->swallowed_object;
|
2010-03-26 18:26:10 -07:00
|
|
|
const Edje_External_Param_Info *info;
|
|
|
|
|
2010-11-19 14:50:33 -08:00
|
|
|
info = _edje_external_param_info_get(swallowed_object, name);
|
2010-03-26 18:26:10 -07:00
|
|
|
if (!info) return NULL;
|
|
|
|
|
|
|
|
memset(param, 0, sizeof(*param));
|
|
|
|
param->name = info->name;
|
|
|
|
param->type = info->type;
|
2010-11-19 14:50:33 -08:00
|
|
|
if (!_edje_external_param_get(NULL, rp, param)) return NULL;
|
2010-03-26 18:26:10 -07:00
|
|
|
return param;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* simulate external properties for native objects */
|
|
|
|
static Edje_External_Param *
|
|
|
|
_edje_param_native_get(Edje_Real_Part *rp, const char *name, Edje_External_Param *param, void **free_ptr)
|
|
|
|
{
|
|
|
|
*free_ptr = NULL;
|
|
|
|
if ((rp->part->type == EDJE_PART_TYPE_TEXT) ||
|
|
|
|
(rp->part->type == EDJE_PART_TYPE_TEXTBLOCK))
|
|
|
|
{
|
|
|
|
if (!strcmp(name, "text"))
|
|
|
|
{
|
|
|
|
param->name = name;
|
|
|
|
param->type = EDJE_EXTERNAL_PARAM_TYPE_STRING;
|
|
|
|
|
|
|
|
_edje_recalc_do(rp->edje);
|
|
|
|
if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
|
|
|
|
param->s = _edje_entry_text_get(rp);
|
|
|
|
else if (rp->part->type == EDJE_PART_TYPE_TEXT)
|
|
|
|
param->s = rp->text.text;
|
|
|
|
else
|
|
|
|
param->s = evas_object_textblock_text_markup_get(rp->object);
|
|
|
|
return param;
|
|
|
|
}
|
|
|
|
if (rp->part->type == EDJE_PART_TYPE_TEXTBLOCK)
|
|
|
|
{
|
|
|
|
if (!strcmp(name, "text_unescaped"))
|
|
|
|
{
|
|
|
|
param->name = name;
|
|
|
|
param->type = EDJE_EXTERNAL_PARAM_TYPE_STRING;
|
|
|
|
|
|
|
|
_edje_recalc_do(rp->edje);
|
|
|
|
if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
|
|
|
|
{
|
|
|
|
const char *tmp = _edje_entry_text_get(rp);
|
|
|
|
char *unescaped = _edje_text_unescape(tmp);
|
|
|
|
*free_ptr = unescaped;
|
|
|
|
param->s = unescaped;
|
|
|
|
}
|
|
|
|
else if (rp->part->type == EDJE_PART_TYPE_TEXT)
|
|
|
|
param->s = rp->text.text;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
const char *tmp;
|
|
|
|
char *unescaped;
|
|
|
|
|
|
|
|
tmp = evas_object_textblock_text_markup_get(rp->object);
|
|
|
|
unescaped = _edje_text_unescape(tmp);
|
|
|
|
*free_ptr = unescaped;
|
|
|
|
param->s = unescaped;
|
|
|
|
}
|
|
|
|
|
|
|
|
return param;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((rp->entry_data) &&
|
|
|
|
(rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE) &&
|
|
|
|
(!strcmp(name, "select_allow")))
|
|
|
|
{
|
|
|
|
param->name = name;
|
|
|
|
param->type = EDJE_EXTERNAL_PARAM_TYPE_BOOL;
|
|
|
|
param->i = _edje_entry_select_allow_get(rp);
|
|
|
|
return param;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((rp->drag) && (rp->drag->down.count == 0))
|
|
|
|
{
|
|
|
|
if (!strncmp(name, "drag_", sizeof("drag_") - 1))
|
|
|
|
{
|
|
|
|
const char *sub_name = name + sizeof("drag_") - 1;
|
|
|
|
if (!strcmp(sub_name, "value_x"))
|
|
|
|
{
|
|
|
|
double d;
|
|
|
|
|
|
|
|
_edje_recalc_do(rp->edje);
|
|
|
|
d = TO_DOUBLE(rp->drag->val.x);
|
|
|
|
if (rp->part->dragable.x < 0) d = 1.0 - d;
|
|
|
|
param->name = name;
|
|
|
|
param->type = EDJE_EXTERNAL_PARAM_TYPE_DOUBLE;
|
|
|
|
param->d = d;
|
|
|
|
return param;
|
|
|
|
}
|
|
|
|
if (!strcmp(sub_name, "value_y"))
|
|
|
|
{
|
|
|
|
double d;
|
|
|
|
|
|
|
|
_edje_recalc_do(rp->edje);
|
|
|
|
d = TO_DOUBLE(rp->drag->val.y);
|
|
|
|
if (rp->part->dragable.y < 0) d = 1.0 - d;
|
|
|
|
param->name = name;
|
|
|
|
param->type = EDJE_EXTERNAL_PARAM_TYPE_DOUBLE;
|
|
|
|
param->d = d;
|
|
|
|
return param;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!strcmp(sub_name, "size_w"))
|
|
|
|
{
|
|
|
|
_edje_recalc_do(rp->edje);
|
|
|
|
param->name = name;
|
|
|
|
param->type = EDJE_EXTERNAL_PARAM_TYPE_DOUBLE;
|
|
|
|
param->d = TO_DOUBLE(rp->drag->size.x);
|
|
|
|
return param;
|
|
|
|
}
|
|
|
|
if (!strcmp(sub_name, "size_h"))
|
|
|
|
{
|
|
|
|
_edje_recalc_do(rp->edje);
|
|
|
|
param->name = name;
|
|
|
|
param->type = EDJE_EXTERNAL_PARAM_TYPE_DOUBLE;
|
|
|
|
param->d = TO_DOUBLE(rp->drag->size.y);
|
|
|
|
return param;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!strcmp(sub_name, "step_x"))
|
|
|
|
{
|
|
|
|
_edje_recalc_do(rp->edje);
|
|
|
|
param->name = name;
|
|
|
|
param->type = EDJE_EXTERNAL_PARAM_TYPE_DOUBLE;
|
|
|
|
param->d = TO_DOUBLE(rp->drag->step.x);
|
|
|
|
return param;
|
|
|
|
}
|
|
|
|
if (!strcmp(sub_name, "step_y"))
|
|
|
|
{
|
|
|
|
_edje_recalc_do(rp->edje);
|
|
|
|
param->name = name;
|
|
|
|
param->type = EDJE_EXTERNAL_PARAM_TYPE_DOUBLE;
|
|
|
|
param->d = TO_DOUBLE(rp->drag->step.y);
|
|
|
|
return param;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!strcmp(sub_name, "page_x"))
|
|
|
|
{
|
|
|
|
_edje_recalc_do(rp->edje);
|
|
|
|
param->name = name;
|
|
|
|
param->type = EDJE_EXTERNAL_PARAM_TYPE_DOUBLE;
|
|
|
|
param->d = TO_DOUBLE(rp->drag->page.x);
|
|
|
|
return param;
|
|
|
|
}
|
|
|
|
if (!strcmp(sub_name, "page_y"))
|
|
|
|
{
|
|
|
|
_edje_recalc_do(rp->edje);
|
|
|
|
param->name = name;
|
|
|
|
param->type = EDJE_EXTERNAL_PARAM_TYPE_DOUBLE;
|
|
|
|
param->d = TO_DOUBLE(rp->drag->page.y);
|
|
|
|
return param;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_edje_param_native_set(Edje_Real_Part *rp, const char *name, const Edje_External_Param *param)
|
|
|
|
{
|
|
|
|
if ((rp->part->type == EDJE_PART_TYPE_TEXT) ||
|
|
|
|
(rp->part->type == EDJE_PART_TYPE_TEXTBLOCK))
|
|
|
|
{
|
|
|
|
if (!strcmp(name, "text"))
|
|
|
|
{
|
|
|
|
if (param->type != EDJE_EXTERNAL_PARAM_TYPE_STRING)
|
|
|
|
return EINA_FALSE;
|
|
|
|
|
|
|
|
_edje_object_part_text_raw_set
|
|
|
|
(rp->edje->obj, rp, rp->part->name, param->s);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
if (rp->part->type == EDJE_PART_TYPE_TEXTBLOCK)
|
|
|
|
{
|
|
|
|
if (!strcmp(name, "text_unescaped"))
|
|
|
|
{
|
|
|
|
if (param->type != EDJE_EXTERNAL_PARAM_TYPE_STRING)
|
|
|
|
return EINA_FALSE;
|
|
|
|
|
|
|
|
if (rp->part->type == EDJE_PART_TYPE_TEXT)
|
|
|
|
_edje_object_part_text_raw_set
|
|
|
|
(rp->edje->obj, rp, rp->part->name, param->s);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
char *escaped = _edje_text_escape(param->s);
|
|
|
|
_edje_object_part_text_raw_set
|
|
|
|
(rp->edje->obj, rp, rp->part->name, escaped);
|
|
|
|
free(escaped);
|
|
|
|
}
|
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((rp->entry_data) &&
|
|
|
|
(rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE) &&
|
|
|
|
(!strcmp(name, "select_allow")))
|
|
|
|
{
|
|
|
|
if (param->type != EDJE_EXTERNAL_PARAM_TYPE_BOOL)
|
|
|
|
return EINA_FALSE;
|
|
|
|
_edje_entry_select_allow_set(rp, param->i);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((rp->drag) && (rp->drag->down.count == 0))
|
|
|
|
{
|
|
|
|
if (!strncmp(name, "drag_", sizeof("drag_") - 1))
|
|
|
|
{
|
|
|
|
const char *sub_name = name + sizeof("drag_") - 1;
|
|
|
|
if (!strcmp(sub_name, "value_x"))
|
|
|
|
{
|
|
|
|
double d;
|
|
|
|
if (param->type != EDJE_EXTERNAL_PARAM_TYPE_DOUBLE)
|
|
|
|
return EINA_FALSE;
|
|
|
|
d = param->d;
|
|
|
|
if (rp->part->dragable.confine_id != -1)
|
|
|
|
d = CLAMP(d, 0.0, 1.0);
|
|
|
|
if (rp->part->dragable.x < 0) d = 1.0 - d;
|
|
|
|
if (rp->drag->val.x == FROM_DOUBLE(d)) return EINA_TRUE;
|
|
|
|
rp->drag->val.x = FROM_DOUBLE(d);
|
|
|
|
#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,set", rp->part->name);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
if (!strcmp(sub_name, "value_y"))
|
|
|
|
{
|
|
|
|
double d;
|
|
|
|
if (param->type != EDJE_EXTERNAL_PARAM_TYPE_DOUBLE)
|
|
|
|
return EINA_FALSE;
|
|
|
|
d = param->d;
|
|
|
|
if (rp->part->dragable.confine_id != -1)
|
|
|
|
d = CLAMP(d, 0.0, 1.0);
|
|
|
|
if (rp->part->dragable.y < 0) d = 1.0 - d;
|
|
|
|
if (rp->drag->val.y == FROM_DOUBLE(d)) return EINA_TRUE;
|
|
|
|
rp->drag->val.y = FROM_DOUBLE(d);
|
|
|
|
#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,set", rp->part->name);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!strcmp(sub_name, "size_w"))
|
|
|
|
{
|
|
|
|
if (param->type != EDJE_EXTERNAL_PARAM_TYPE_DOUBLE)
|
|
|
|
return EINA_FALSE;
|
|
|
|
rp->drag->size.x = FROM_DOUBLE(CLAMP(param->d, 0.0, 1.0));
|
|
|
|
rp->edje->dirty = 1;
|
|
|
|
#ifdef EDJE_CALC_CACHE
|
|
|
|
rp->invalidate = 1;
|
|
|
|
#endif
|
|
|
|
_edje_recalc(rp->edje);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
if (!strcmp(sub_name, "size_h"))
|
|
|
|
{
|
|
|
|
if (param->type != EDJE_EXTERNAL_PARAM_TYPE_DOUBLE)
|
|
|
|
return EINA_FALSE;
|
|
|
|
rp->drag->size.y = FROM_DOUBLE(CLAMP(param->d, 0.0, 1.0));
|
|
|
|
rp->edje->dirty = 1;
|
|
|
|
#ifdef EDJE_CALC_CACHE
|
|
|
|
rp->invalidate = 1;
|
|
|
|
#endif
|
|
|
|
_edje_recalc(rp->edje);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!strcmp(sub_name, "step_x"))
|
|
|
|
{
|
|
|
|
if (param->type != EDJE_EXTERNAL_PARAM_TYPE_DOUBLE)
|
|
|
|
return EINA_FALSE;
|
|
|
|
rp->drag->step.x = FROM_DOUBLE(CLAMP(param->d, 0.0, 1.0));
|
|
|
|
#ifdef EDJE_CALC_CACHE
|
|
|
|
rp->invalidate = 1;
|
|
|
|
#endif
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
if (!strcmp(sub_name, "step_y"))
|
|
|
|
{
|
|
|
|
if (param->type != EDJE_EXTERNAL_PARAM_TYPE_DOUBLE)
|
|
|
|
return EINA_FALSE;
|
|
|
|
rp->drag->step.y = FROM_DOUBLE(CLAMP(param->d, 0.0, 1.0));
|
|
|
|
#ifdef EDJE_CALC_CACHE
|
|
|
|
rp->invalidate = 1;
|
|
|
|
#endif
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!strcmp(sub_name, "page_x"))
|
|
|
|
{
|
|
|
|
if (param->type != EDJE_EXTERNAL_PARAM_TYPE_DOUBLE)
|
|
|
|
return EINA_FALSE;
|
|
|
|
rp->drag->page.x = FROM_DOUBLE(CLAMP(param->d, 0.0, 1.0));
|
|
|
|
#ifdef EDJE_CALC_CACHE
|
|
|
|
rp->invalidate = 1;
|
|
|
|
#endif
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
if (!strcmp(sub_name, "page_y"))
|
|
|
|
{
|
|
|
|
if (param->type != EDJE_EXTERNAL_PARAM_TYPE_DOUBLE)
|
|
|
|
return EINA_FALSE;
|
|
|
|
rp->drag->page.y = FROM_DOUBLE(CLAMP(param->d, 0.0, 1.0));
|
|
|
|
#ifdef EDJE_CALC_CACHE
|
|
|
|
rp->invalidate = 1;
|
|
|
|
#endif
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
2010-03-29 14:51:40 -07:00
|
|
|
static const Edje_External_Param_Info *
|
|
|
|
_edje_native_param_info_get(const Edje_Real_Part *rp, const char *name)
|
2010-03-26 18:26:10 -07:00
|
|
|
{
|
|
|
|
if ((rp->part->type == EDJE_PART_TYPE_TEXT) ||
|
|
|
|
(rp->part->type == EDJE_PART_TYPE_TEXTBLOCK))
|
|
|
|
{
|
2010-03-29 14:51:40 -07:00
|
|
|
if (!strcmp(name, "text"))
|
|
|
|
{
|
|
|
|
static const Edje_External_Param_Info pi =
|
|
|
|
EDJE_EXTERNAL_PARAM_INFO_STRING("text");
|
|
|
|
return π
|
|
|
|
}
|
2010-03-26 18:26:10 -07:00
|
|
|
if (rp->part->type == EDJE_PART_TYPE_TEXTBLOCK)
|
|
|
|
{
|
|
|
|
if (!strcmp(name, "text_unescaped"))
|
2010-03-29 14:51:40 -07:00
|
|
|
{
|
|
|
|
static const Edje_External_Param_Info pi =
|
|
|
|
EDJE_EXTERNAL_PARAM_INFO_STRING("text_unescaped");
|
|
|
|
return π
|
|
|
|
}
|
2010-03-26 18:26:10 -07:00
|
|
|
if (!strcmp(name, "select_allow"))
|
2010-03-29 14:51:40 -07:00
|
|
|
{
|
|
|
|
static const Edje_External_Param_Info pi =
|
|
|
|
EDJE_EXTERNAL_PARAM_INFO_BOOL("text_unescaped");
|
|
|
|
return π
|
|
|
|
}
|
2010-03-26 18:26:10 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((rp->drag) && (rp->drag->down.count == 0))
|
|
|
|
{
|
|
|
|
if (!strncmp(name, "drag_", sizeof("drag_") - 1))
|
|
|
|
{
|
|
|
|
name += sizeof("drag_") - 1;
|
2010-03-29 14:51:40 -07:00
|
|
|
if (!strcmp(name, "value_x"))
|
|
|
|
{
|
|
|
|
static const Edje_External_Param_Info pi =
|
|
|
|
EDJE_EXTERNAL_PARAM_INFO_DOUBLE("drag_value_x");
|
|
|
|
return π
|
|
|
|
}
|
|
|
|
if (!strcmp(name, "value_y"))
|
|
|
|
{
|
|
|
|
static const Edje_External_Param_Info pi =
|
|
|
|
EDJE_EXTERNAL_PARAM_INFO_DOUBLE("drag_value_y");
|
|
|
|
return π
|
|
|
|
}
|
|
|
|
if (!strcmp(name, "size_w"))
|
|
|
|
{
|
|
|
|
static const Edje_External_Param_Info pi =
|
|
|
|
EDJE_EXTERNAL_PARAM_INFO_DOUBLE("drag_size_w");
|
|
|
|
return π
|
|
|
|
}
|
|
|
|
if (!strcmp(name, "size_h"))
|
|
|
|
{
|
|
|
|
static const Edje_External_Param_Info pi =
|
|
|
|
EDJE_EXTERNAL_PARAM_INFO_DOUBLE("drag_size_h");
|
|
|
|
return π
|
|
|
|
}
|
|
|
|
if (!strcmp(name, "step_x"))
|
|
|
|
{
|
|
|
|
static const Edje_External_Param_Info pi =
|
|
|
|
EDJE_EXTERNAL_PARAM_INFO_DOUBLE("drag_step_x");
|
|
|
|
return π
|
|
|
|
}
|
|
|
|
if (!strcmp(name, "step_y"))
|
|
|
|
{
|
|
|
|
static const Edje_External_Param_Info pi =
|
|
|
|
EDJE_EXTERNAL_PARAM_INFO_DOUBLE("drag_step_y");
|
|
|
|
return π
|
|
|
|
}
|
|
|
|
if (!strcmp(name, "page_x"))
|
|
|
|
{
|
|
|
|
static const Edje_External_Param_Info pi =
|
|
|
|
EDJE_EXTERNAL_PARAM_INFO_DOUBLE("drag_page_x");
|
|
|
|
return π
|
|
|
|
}
|
|
|
|
if (!strcmp(name, "page_y"))
|
|
|
|
{
|
|
|
|
static const Edje_External_Param_Info pi =
|
|
|
|
EDJE_EXTERNAL_PARAM_INFO_DOUBLE("drag_page_y");
|
|
|
|
return π
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
2010-03-26 18:26:10 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-03-29 14:51:40 -07:00
|
|
|
return NULL;
|
2010-03-26 18:26:10 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static Edje_External_Param *
|
2010-03-29 14:51:40 -07:00
|
|
|
_edje_param_convert(Edje_External_Param *param, const Edje_External_Param_Info *dst_info)
|
2010-03-26 18:26:10 -07:00
|
|
|
{
|
2010-03-29 14:51:40 -07:00
|
|
|
if (param->type == dst_info->type) return param;
|
2010-03-26 18:26:10 -07:00
|
|
|
|
2010-03-29 14:51:40 -07:00
|
|
|
switch (dst_info->type)
|
2010-03-26 18:26:10 -07:00
|
|
|
{
|
|
|
|
case EDJE_EXTERNAL_PARAM_TYPE_BOOL:
|
|
|
|
case EDJE_EXTERNAL_PARAM_TYPE_INT:
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
switch (param->type)
|
|
|
|
{
|
|
|
|
case EDJE_EXTERNAL_PARAM_TYPE_DOUBLE:
|
|
|
|
i = (int)param->d;
|
|
|
|
break;
|
|
|
|
case EDJE_EXTERNAL_PARAM_TYPE_STRING:
|
2010-03-29 14:51:40 -07:00
|
|
|
case EDJE_EXTERNAL_PARAM_TYPE_CHOICE:
|
2010-03-26 18:26:10 -07:00
|
|
|
i = (param->s) ? atoi(param->s) : 0;
|
|
|
|
break;
|
|
|
|
case EDJE_EXTERNAL_PARAM_TYPE_BOOL:
|
2010-03-29 14:51:40 -07:00
|
|
|
case EDJE_EXTERNAL_PARAM_TYPE_INT:
|
2010-03-26 18:26:10 -07:00
|
|
|
i = param->i;
|
2010-07-30 21:58:32 -07:00
|
|
|
break;
|
2010-03-26 18:26:10 -07:00
|
|
|
default:
|
|
|
|
return NULL;
|
|
|
|
}
|
2010-03-29 14:51:40 -07:00
|
|
|
if (dst_info->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
|
|
|
|
i = !!i;
|
|
|
|
param->type = dst_info->type;
|
2010-03-26 18:26:10 -07:00
|
|
|
param->i = i;
|
|
|
|
return param;
|
|
|
|
}
|
|
|
|
|
|
|
|
case EDJE_EXTERNAL_PARAM_TYPE_DOUBLE:
|
|
|
|
{
|
|
|
|
double d;
|
|
|
|
switch (param->type)
|
|
|
|
{
|
|
|
|
case EDJE_EXTERNAL_PARAM_TYPE_INT:
|
|
|
|
d = (double)param->i;
|
|
|
|
break;
|
|
|
|
case EDJE_EXTERNAL_PARAM_TYPE_STRING:
|
2010-03-29 14:51:40 -07:00
|
|
|
case EDJE_EXTERNAL_PARAM_TYPE_CHOICE:
|
2010-03-26 18:26:10 -07:00
|
|
|
d = (param->s) ? atof(param->s) : 0.0;
|
|
|
|
break;
|
|
|
|
case EDJE_EXTERNAL_PARAM_TYPE_BOOL:
|
|
|
|
d = (double)param->i;
|
2010-07-30 21:28:27 -07:00
|
|
|
break;
|
2010-03-26 18:26:10 -07:00
|
|
|
default:
|
|
|
|
return NULL;
|
|
|
|
}
|
2010-03-29 14:51:40 -07:00
|
|
|
param->type = dst_info->type;
|
2010-03-26 18:26:10 -07:00
|
|
|
param->d = d;
|
|
|
|
return param;
|
|
|
|
}
|
|
|
|
|
|
|
|
case EDJE_EXTERNAL_PARAM_TYPE_STRING:
|
|
|
|
{
|
|
|
|
static char s[64];
|
|
|
|
switch (param->type)
|
|
|
|
{
|
|
|
|
case EDJE_EXTERNAL_PARAM_TYPE_BOOL:
|
|
|
|
case EDJE_EXTERNAL_PARAM_TYPE_INT:
|
|
|
|
if (!snprintf(s, sizeof(s), "%i", param->i)) return NULL;
|
|
|
|
break;
|
|
|
|
case EDJE_EXTERNAL_PARAM_TYPE_DOUBLE:
|
|
|
|
if (!snprintf(s, sizeof(s), "%f", param->d)) return NULL;
|
|
|
|
break;
|
2010-03-29 14:51:40 -07:00
|
|
|
case EDJE_EXTERNAL_PARAM_TYPE_CHOICE:
|
|
|
|
param->type = dst_info->type;
|
|
|
|
return param;
|
2010-03-26 18:26:10 -07:00
|
|
|
default:
|
|
|
|
return NULL;
|
|
|
|
}
|
2010-03-29 14:51:40 -07:00
|
|
|
param->type = dst_info->type;
|
2010-03-26 18:26:10 -07:00
|
|
|
param->s = s;
|
|
|
|
return param;
|
|
|
|
}
|
|
|
|
|
2010-03-29 14:51:40 -07:00
|
|
|
case EDJE_EXTERNAL_PARAM_TYPE_CHOICE:
|
|
|
|
{
|
|
|
|
static char s[64];
|
|
|
|
const char *val;
|
|
|
|
switch (param->type)
|
|
|
|
{
|
|
|
|
case EDJE_EXTERNAL_PARAM_TYPE_BOOL:
|
|
|
|
case EDJE_EXTERNAL_PARAM_TYPE_INT:
|
|
|
|
if (!snprintf(s, sizeof(s), "%i", param->i)) return NULL;
|
|
|
|
val = s;
|
|
|
|
break;
|
|
|
|
case EDJE_EXTERNAL_PARAM_TYPE_DOUBLE:
|
|
|
|
if (!snprintf(s, sizeof(s), "%f", param->d)) return NULL;
|
|
|
|
val = s;
|
|
|
|
break;
|
|
|
|
case EDJE_EXTERNAL_PARAM_TYPE_STRING:
|
|
|
|
val = param->s;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
param->type = dst_info->type;
|
|
|
|
if (param->s != val) param->s = val;
|
|
|
|
return param;
|
|
|
|
}
|
|
|
|
|
2010-03-26 18:26:10 -07:00
|
|
|
default: return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-03-29 14:51:40 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_edje_param_validate(const Edje_External_Param *param, const Edje_External_Param_Info *info)
|
|
|
|
{
|
|
|
|
switch (info->type)
|
|
|
|
{
|
|
|
|
case EDJE_EXTERNAL_PARAM_TYPE_BOOL:
|
|
|
|
return ((param->i == 0) || (param->i == 1));
|
|
|
|
|
|
|
|
case EDJE_EXTERNAL_PARAM_TYPE_INT:
|
|
|
|
if ((info->info.i.min != EDJE_EXTERNAL_INT_UNSET) &&
|
|
|
|
(info->info.i.min > param->i))
|
|
|
|
return EINA_FALSE;
|
|
|
|
|
|
|
|
if ((info->info.i.max != EDJE_EXTERNAL_INT_UNSET) &&
|
|
|
|
(info->info.i.max < param->i))
|
|
|
|
return EINA_FALSE;
|
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
|
|
|
|
case EDJE_EXTERNAL_PARAM_TYPE_DOUBLE:
|
|
|
|
if ((info->info.d.min != EDJE_EXTERNAL_DOUBLE_UNSET) &&
|
|
|
|
(info->info.d.min > param->d))
|
|
|
|
return EINA_FALSE;
|
|
|
|
|
|
|
|
if ((info->info.d.max != EDJE_EXTERNAL_DOUBLE_UNSET) &&
|
|
|
|
(info->info.d.max < param->d))
|
|
|
|
return EINA_FALSE;
|
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
|
|
|
|
case EDJE_EXTERNAL_PARAM_TYPE_STRING:
|
|
|
|
if (!param->s) return EINA_FALSE;
|
|
|
|
if (info->info.s.accept_fmt)
|
|
|
|
INF("string 'accept_fmt' validation not implemented.");
|
|
|
|
if (info->info.s.deny_fmt)
|
|
|
|
INF("string 'deny_fmt' validation not implemented.");
|
|
|
|
return EINA_TRUE;
|
|
|
|
|
|
|
|
case EDJE_EXTERNAL_PARAM_TYPE_CHOICE:
|
|
|
|
{
|
|
|
|
const char **itr = info->info.c.choices;
|
|
|
|
if (!itr) return EINA_FALSE;
|
2010-08-21 06:52:25 -07:00
|
|
|
for (; *itr; itr++)
|
2010-03-29 14:51:40 -07:00
|
|
|
if (!strcmp(*itr, param->s))
|
|
|
|
return EINA_TRUE;
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
default: return EINA_FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-03-26 18:26:10 -07:00
|
|
|
static void
|
|
|
|
_edje_param_copy(Edje_Real_Part *src_part, const char *src_param, Edje_Real_Part *dst_part, const char *dst_param)
|
|
|
|
{
|
|
|
|
Edje_External_Param val;
|
2010-03-29 14:51:40 -07:00
|
|
|
const Edje_External_Param_Info *dst_info;
|
2010-03-26 18:26:10 -07:00
|
|
|
void *free_ptr = NULL;
|
|
|
|
|
|
|
|
if ((!src_part) || (!src_param) || (!dst_part) || (!dst_param))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (dst_part->part->type == EDJE_PART_TYPE_EXTERNAL)
|
2010-03-29 14:51:40 -07:00
|
|
|
dst_info = _edje_external_param_info_get
|
2010-03-26 18:26:10 -07:00
|
|
|
(dst_part->swallowed_object, dst_param);
|
|
|
|
else
|
2010-03-29 14:51:40 -07:00
|
|
|
dst_info = _edje_native_param_info_get(dst_part, dst_param);
|
2010-03-26 18:26:10 -07:00
|
|
|
|
2010-03-29 14:51:40 -07:00
|
|
|
if (!dst_info)
|
2010-03-26 18:26:10 -07:00
|
|
|
{
|
|
|
|
ERR("cannot copy, invalid destination parameter '%s' of part '%s'",
|
|
|
|
dst_param, dst_part->part->name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (src_part->part->type == EDJE_PART_TYPE_EXTERNAL)
|
|
|
|
{
|
|
|
|
if (!_edje_param_external_get
|
2010-11-19 14:50:33 -08:00
|
|
|
(src_part, src_param, &val))
|
2010-03-26 18:26:10 -07:00
|
|
|
{
|
|
|
|
ERR("cannot get parameter '%s' of part '%s'",
|
|
|
|
src_param, src_part->part->name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (!_edje_param_native_get(src_part, src_param, &val, &free_ptr))
|
|
|
|
{
|
|
|
|
ERR("cannot get parameter '%s' of part '%s'",
|
|
|
|
src_param, src_part->part->name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-03-29 14:51:40 -07:00
|
|
|
if (!_edje_param_convert(&val, dst_info))
|
2010-03-26 18:26:10 -07:00
|
|
|
{
|
|
|
|
ERR("cannot convert parameter type %s to requested type %s",
|
|
|
|
edje_external_param_type_str(val.type),
|
2010-03-29 14:51:40 -07:00
|
|
|
edje_external_param_type_str(dst_info->type));
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!_edje_param_validate(&val, dst_info))
|
|
|
|
{
|
|
|
|
ERR("incorrect parameter value failed validation for type %s",
|
|
|
|
edje_external_param_type_str(dst_info->type));
|
2010-03-26 18:26:10 -07:00
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dst_part->part->type == EDJE_PART_TYPE_EXTERNAL)
|
|
|
|
{
|
|
|
|
val.name = dst_param;
|
2010-11-19 14:50:33 -08:00
|
|
|
if (!_edje_external_param_set(NULL, dst_part, &val))
|
2010-03-26 18:26:10 -07:00
|
|
|
{
|
|
|
|
ERR("failed to set parameter '%s' (%s) of part '%s'",
|
2010-03-29 14:51:40 -07:00
|
|
|
dst_param, edje_external_param_type_str(dst_info->type),
|
2010-03-26 18:26:10 -07:00
|
|
|
dst_part->part->name);
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (!_edje_param_native_set(dst_part, dst_param, &val))
|
|
|
|
{
|
|
|
|
ERR("failed to set parameter '%s' (%s) of part '%s'",
|
2010-03-29 14:51:40 -07:00
|
|
|
dst_param, edje_external_param_type_str(dst_info->type),
|
2010-03-26 18:26:10 -07:00
|
|
|
dst_part->part->name);
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
end:
|
|
|
|
free(free_ptr);
|
|
|
|
}
|
|
|
|
|
2010-03-31 13:48:51 -07:00
|
|
|
static void
|
|
|
|
_edje_param_set(Edje_Real_Part *part, const char *param, const char *value)
|
|
|
|
{
|
|
|
|
Edje_External_Param val;
|
|
|
|
const Edje_External_Param_Info *info;
|
|
|
|
|
|
|
|
if ((!part) || (!param) || (!value))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (part->part->type == EDJE_PART_TYPE_EXTERNAL)
|
|
|
|
info = _edje_external_param_info_get(part->swallowed_object, param);
|
|
|
|
else
|
|
|
|
info = _edje_native_param_info_get(part, param);
|
|
|
|
|
|
|
|
if (!info)
|
|
|
|
{
|
|
|
|
ERR("cannot copy, invalid destination parameter '%s' of part '%s'",
|
|
|
|
param, part->part->name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
val.name = "(temp)";
|
|
|
|
val.type = EDJE_EXTERNAL_PARAM_TYPE_STRING;
|
|
|
|
val.s = value;
|
|
|
|
|
|
|
|
if (!_edje_param_convert(&val, info))
|
|
|
|
{
|
|
|
|
ERR("cannot convert parameter type STRING to requested type %s",
|
|
|
|
edje_external_param_type_str(info->type));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!_edje_param_validate(&val, info))
|
|
|
|
{
|
|
|
|
ERR("incorrect parameter value failed validation for type %s",
|
|
|
|
edje_external_param_type_str(info->type));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (part->part->type == EDJE_PART_TYPE_EXTERNAL)
|
|
|
|
{
|
|
|
|
val.name = param;
|
2010-11-19 14:50:33 -08:00
|
|
|
if (!_edje_external_param_set(NULL, part, &val))
|
2010-03-31 13:48:51 -07:00
|
|
|
{
|
|
|
|
ERR("failed to set parameter '%s' (%s) of part '%s'",
|
|
|
|
param, edje_external_param_type_str(info->type),
|
|
|
|
part->part->name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (!_edje_param_native_set(part, param, &val))
|
|
|
|
{
|
|
|
|
ERR("failed to set parameter '%s' (%s) of part '%s'",
|
|
|
|
param, edje_external_param_type_str(info->type),
|
|
|
|
part->part->name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|