2007-05-26 22:28:07 -07:00
|
|
|
/*
|
|
|
|
* vim:ts=8:sw=3:sts=8:noexpandtab:cino=>5n-3f0^-2{2
|
|
|
|
*/
|
2003-06-23 19:33:04 -07:00
|
|
|
#include "Edje.h"
|
|
|
|
#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);
|
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;
|
|
|
|
Evas_List *_edje_animators = NULL;
|
2003-06-23 19:33:04 -07:00
|
|
|
|
2004-06-05 21:42:17 -07:00
|
|
|
/************************** API Routines **************************/
|
|
|
|
|
|
|
|
/* FIXDOC: Expand */
|
|
|
|
/** Set the frametime
|
|
|
|
* @param t The frametime
|
|
|
|
*
|
2007-04-14 21:05:41 -07:00
|
|
|
* Sets the global frametime in seconds, by default this is 1/30.
|
2004-06-05 21:42:17 -07:00
|
|
|
*/
|
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
|
|
|
}
|
|
|
|
|
2004-06-05 21:42:17 -07:00
|
|
|
/* FIXDOC: Expand */
|
|
|
|
/** Get the frametime
|
|
|
|
* @return The frametime
|
|
|
|
*
|
2004-09-05 01:11:36 -07:00
|
|
|
* Returns the frametime in seconds, by default this is 1/30.
|
2004-06-05 21:42:17 -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
|
|
|
}
|
|
|
|
|
2004-06-05 21:42:17 -07:00
|
|
|
/* FIXDOC: Expand */
|
2007-04-14 21:05:41 -07:00
|
|
|
/** Add a callback for a signal emitted by @a obj.
|
2004-06-05 21:42:17 -07:00
|
|
|
* @param obj A valid Evas_Object handle
|
2007-04-14 21:05:41 -07:00
|
|
|
* @param emission The signal name
|
|
|
|
* @param source The signal source
|
|
|
|
* @param func The callback function to be executed when the signal is emitted
|
|
|
|
* @param data A pointer to data to pass in to the callback function
|
|
|
|
*
|
|
|
|
* Connects a callback function to a signal emitted by @a obj.
|
|
|
|
* In EDC, a program can emit a signal as follows:
|
|
|
|
*
|
|
|
|
* @code
|
|
|
|
* program {
|
|
|
|
* name: "emit_example";
|
|
|
|
* action: SIGNAL_EMIT "a_signal" "a_source";
|
|
|
|
* }
|
|
|
|
* @endcode
|
|
|
|
*
|
|
|
|
* Assuming a function with the following declaration is definded:
|
|
|
|
*
|
|
|
|
* @code
|
|
|
|
* void cb_signal(void *data, Evas_Object *o, const char *emission, const char *source);
|
|
|
|
* @endcode
|
|
|
|
*
|
|
|
|
* a callback is attached using:
|
|
|
|
*
|
|
|
|
* @code
|
|
|
|
* edje_object_callback_add(obj, "a_signal", "a_source", cb_signal, data);
|
|
|
|
* @endcode
|
|
|
|
*
|
|
|
|
* Here, @a data is an arbitrary pointer to be used as desired.
|
|
|
|
* Note that @a emission and @a source correspond respectively to first and
|
|
|
|
* second parameters to the SIGNAL_EMIT action.
|
2004-06-05 21:42:17 -07:00
|
|
|
*
|
2007-04-14 21:05:41 -07:00
|
|
|
* Internal edje signals can also be attached to, and globs can be in either
|
|
|
|
* the emission or source name. e.g.
|
|
|
|
*
|
|
|
|
* @code
|
|
|
|
* edje_object_callback_add(obj, "mouse,down,*", "button.*", NULL);
|
|
|
|
* @endcode
|
|
|
|
*
|
2007-09-08 11:31:56 -07:00
|
|
|
* Here, any mouse down events on an edje part whose name begins with
|
2007-04-14 21:05:41 -07:00
|
|
|
* "button." will trigger the callback. The actual signal and source name
|
|
|
|
* will be passed in to the @a emission and @a source parameters of the
|
|
|
|
* callback function. (e.g. "mouse,down,2" and "button.close").
|
2004-06-05 21:42:17 -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));
|
2005-11-23 06:47:36 -08:00
|
|
|
if ((emission) && (emission[0]))
|
2005-11-30 07:36:34 -08:00
|
|
|
escb->signal = evas_stringshare_add(emission);
|
2005-11-23 06:47:36 -08:00
|
|
|
if ((source) && (source[0]))
|
2005-11-30 07:36:34 -08:00
|
|
|
escb->source = evas_stringshare_add(source);
|
2003-06-23 19:33:04 -07:00
|
|
|
escb->func = func;
|
|
|
|
escb->data = data;
|
|
|
|
ed->callbacks = evas_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
|
|
|
}
|
|
|
|
|
2007-04-14 21:05:41 -07:00
|
|
|
/** Remove a callback from an object
|
2004-06-05 21:42:17 -07:00
|
|
|
* @param obj A valid Evas_Object handle
|
2007-04-14 21:05:41 -07:00
|
|
|
* @param emission the emission string
|
|
|
|
* @param source the source string
|
|
|
|
* @param func the callback function
|
|
|
|
* @return the data pointer
|
2004-06-05 21:42:17 -07:00
|
|
|
*
|
2007-04-14 21:05:41 -07:00
|
|
|
* Removes a callback from an object. The parameters @a emission, @a source
|
|
|
|
* and @a func must match exactly those passed to a previous call to
|
2007-09-08 11:31:56 -07:00
|
|
|
* edje_object_signal_callback_add(). The data pointer that was passed to
|
2007-04-14 21:05:41 -07:00
|
|
|
* this call will be returned.
|
2004-06-05 21:42:17 -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;
|
|
|
|
Evas_List *l;
|
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;
|
2003-06-23 19:33:04 -07:00
|
|
|
for (l = ed->callbacks; l; l = l->next)
|
|
|
|
{
|
|
|
|
Edje_Signal_Callback *escb;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2003-06-23 19:33:04 -07:00
|
|
|
escb = l->data;
|
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))) &&
|
|
|
|
((!escb->source && !source[0]) ||
|
|
|
|
(escb->source && !strcmp(escb->source, source))))
|
2003-06-23 19:33:04 -07:00
|
|
|
{
|
|
|
|
void *data;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2003-06-23 19:33:04 -07:00
|
|
|
data = 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
|
|
|
|
2003-06-26 07:04:31 -07:00
|
|
|
ed->callbacks = evas_list_remove_list(ed->callbacks, l);
|
2005-11-30 07:36:34 -08:00
|
|
|
if (escb->signal) evas_stringshare_del(escb->signal);
|
|
|
|
if (escb->source) evas_stringshare_del(escb->source);
|
2003-06-26 07:04:31 -07:00
|
|
|
free(escb);
|
|
|
|
}
|
2003-06-23 19:33:04 -07:00
|
|
|
return data;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2004-06-05 21:42:17 -07:00
|
|
|
/* FIXDOC: Verify/Expand */
|
2007-04-14 21:05:41 -07:00
|
|
|
/** Send a signal to the Edje object
|
2004-10-27 12:24:42 -07:00
|
|
|
* @param obj A vaild Evas_Object handle
|
2004-06-05 21:42:17 -07:00
|
|
|
* @param emission The signal
|
|
|
|
* @param source The signal source
|
|
|
|
*
|
2007-04-14 21:05:41 -07:00
|
|
|
* This sends a signal to the edje object.
|
2007-09-08 11:31:56 -07:00
|
|
|
*
|
2007-04-14 21:05:41 -07:00
|
|
|
* An edje program can respond to a signal by specifying matching 'signal'
|
|
|
|
* and 'source' fields.
|
|
|
|
*
|
|
|
|
* E.g.
|
|
|
|
*
|
|
|
|
* @code
|
|
|
|
* edje_object_signal_emit(obj, "a_signal", "");
|
|
|
|
* @endcode
|
|
|
|
*
|
|
|
|
* will trigger a program whose edc is:
|
|
|
|
*
|
|
|
|
* @code
|
|
|
|
* program {
|
|
|
|
* name: "a_program";
|
|
|
|
* signal: "a_signal";
|
|
|
|
* source: "";
|
|
|
|
* action: ...
|
|
|
|
* }
|
|
|
|
* @endcode
|
2007-05-26 22:28:07 -07:00
|
|
|
*
|
|
|
|
* FIXME should this signal be sent to children also?
|
2004-06-05 21:42:17 -07:00
|
|
|
*/
|
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 */
|
|
|
|
/** Set the Edje to play or pause
|
2005-09-20 20:11:31 -07:00
|
|
|
* @param obj A valid Evas_Object handle
|
2004-06-05 21:42:17 -07:00
|
|
|
* @param play Play instruction (1 to play, 0 to pause)
|
|
|
|
*
|
2005-09-20 20:11:31 -07:00
|
|
|
* This sets the Edje to play or pause depending on the parameter.
|
|
|
|
* This has no effect if the Edje is already in that state.
|
2004-06-05 21:42:17 -07:00
|
|
|
*/
|
2006-01-07 00:54:30 -08:00
|
|
|
EAPI void
|
2003-07-08 03:08:15 -07:00
|
|
|
edje_object_play_set(Evas_Object *obj, int play)
|
2003-07-07 00:55:18 -07:00
|
|
|
{
|
|
|
|
Edje *ed;
|
|
|
|
double t;
|
|
|
|
Evas_List *l;
|
2007-05-26 22:28:07 -07:00
|
|
|
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;
|
|
|
|
for (l = ed->actions; l; l = l->next)
|
|
|
|
{
|
|
|
|
Edje_Running_Program *runp;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2003-07-07 00:55:18 -07:00
|
|
|
runp = l->data;
|
|
|
|
runp->start_time += t;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (ed->paused) return;
|
|
|
|
ed->paused = 1;
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2004-06-05 21:42:17 -07:00
|
|
|
/* FIXDOC: Verify/Expand */
|
|
|
|
/** Get the Edje play/pause state
|
|
|
|
* @param obj A valid Evas_Object handle
|
|
|
|
* @return 0 if Edje not connected, Edje delete_me, or Edje paused\n
|
|
|
|
* 1 if Edje set to play
|
|
|
|
*/
|
2007-09-08 11:31:56 -07:00
|
|
|
EAPI int
|
2003-07-08 03:08:15 -07:00
|
|
|
edje_object_play_get(Evas_Object *obj)
|
2003-07-07 00:55:18 -07:00
|
|
|
{
|
|
|
|
Edje *ed;
|
|
|
|
|
|
|
|
ed = _edje_fetch(obj);
|
|
|
|
if (!ed) return 0;
|
2003-08-25 17:16:49 -07:00
|
|
|
if (ed->delete_me) return 0;
|
2003-07-07 00:55:18 -07:00
|
|
|
if (ed->paused) return 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2004-06-05 21:42:17 -07:00
|
|
|
/* FIXDOC: Verify/Expand */
|
|
|
|
/** Set Animation state
|
|
|
|
* @param obj A valid Evas_Object handle
|
|
|
|
* @param on Animation State
|
|
|
|
*
|
|
|
|
* Stop or start an Edje animation.
|
|
|
|
*/
|
2006-01-07 00:54:30 -08:00
|
|
|
EAPI void
|
2003-07-08 03:08:15 -07:00
|
|
|
edje_object_animation_set(Evas_Object *obj, int on)
|
2003-07-07 00:55:18 -07:00
|
|
|
{
|
|
|
|
Edje *ed;
|
|
|
|
Evas_List *l;
|
2007-05-26 22:28:07 -07:00
|
|
|
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)
|
|
|
|
{
|
|
|
|
Evas_List *newl = NULL;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2003-07-07 00:55:18 -07:00
|
|
|
for (l = ed->actions; l; l = l->next)
|
|
|
|
newl = evas_list_append(newl, l->data);
|
|
|
|
while (newl)
|
|
|
|
{
|
|
|
|
Edje_Running_Program *runp;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2003-07-07 00:55:18 -07:00
|
|
|
runp = newl->data;
|
|
|
|
newl = evas_list_remove(newl, newl->data);
|
|
|
|
_edje_program_run_iterate(runp, runp->start_time + runp->program->tween.time);
|
2003-08-25 17:16:49 -07:00
|
|
|
if (_edje_block_break(ed))
|
|
|
|
{
|
|
|
|
evas_list_free(newl);
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2004-06-05 21:42:17 -07:00
|
|
|
/* FIXDOC: Verify/Expand */
|
|
|
|
/** Get the animation state
|
|
|
|
* @param obj A valid Evas_Object handle
|
|
|
|
* @return 0 on Error or if not animated\n
|
|
|
|
* 1 if animated
|
|
|
|
*/
|
2006-01-07 00:54:30 -08:00
|
|
|
EAPI int
|
2003-07-08 03:08:15 -07:00
|
|
|
edje_object_animation_get(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);
|
|
|
|
if (!ed) return 0;
|
2003-08-25 17:16:49 -07:00
|
|
|
if (ed->delete_me) return 0;
|
2003-07-07 00:55:18 -07:00
|
|
|
if (ed->no_anim) return 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2003-06-23 19:33:04 -07:00
|
|
|
/* Private Routines */
|
|
|
|
|
|
|
|
int
|
|
|
|
_edje_program_run_iterate(Edje_Running_Program *runp, double tim)
|
|
|
|
{
|
|
|
|
double t, total;
|
|
|
|
Evas_List *l;
|
2003-08-25 17:16:49 -07:00
|
|
|
Edje *ed;
|
2003-06-23 19:33:04 -07:00
|
|
|
|
2003-08-25 17:16:49 -07:00
|
|
|
ed = runp->edje;
|
|
|
|
if (ed->delete_me) return 0;
|
|
|
|
_edje_block(ed);
|
|
|
|
_edje_ref(ed);
|
|
|
|
_edje_freeze(ed);
|
2003-06-23 19:33:04 -07:00
|
|
|
t = tim - runp->start_time;
|
|
|
|
total = runp->program->tween.time;
|
|
|
|
t /= total;
|
|
|
|
if (t > 1.0) t = 1.0;
|
|
|
|
for (l = runp->program->targets; l; l = l->next)
|
|
|
|
{
|
|
|
|
Edje_Real_Part *rp;
|
|
|
|
Edje_Program_Target *pt;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2003-06-23 19:33:04 -07:00
|
|
|
pt = l->data;
|
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,
|
2004-04-01 07:32:17 -08:00
|
|
|
runp->program->tween.mode, t);
|
|
|
|
}
|
2003-06-23 19:33:04 -07:00
|
|
|
}
|
|
|
|
if (t >= 1.0)
|
|
|
|
{
|
|
|
|
for (l = runp->program->targets; l; l = l->next)
|
|
|
|
{
|
|
|
|
Edje_Real_Part *rp;
|
|
|
|
Edje_Program_Target *pt;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2003-06-23 19:33:04 -07:00
|
|
|
pt = l->data;
|
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,
|
2004-04-01 07:32:17 -08:00
|
|
|
runp->program->tween.mode, 0.0);
|
|
|
|
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--;
|
2003-08-25 17:16:49 -07:00
|
|
|
ed->actions = evas_list_remove(ed->actions, runp);
|
|
|
|
if (!ed->actions)
|
|
|
|
_edje_animators = evas_list_remove(_edje_animators, ed);
|
2003-08-13 04:03:20 -07:00
|
|
|
}
|
2003-08-25 17:16:49 -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;
|
|
|
|
}
|
2004-03-07 18:43:48 -08:00
|
|
|
for (l = runp->program->after; l; l = l->next)
|
2003-06-23 19:33:04 -07:00
|
|
|
{
|
|
|
|
Edje_Program *pr;
|
2004-03-07 18:43:48 -08:00
|
|
|
Edje_Program_After *pa = l->data;
|
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);
|
2003-06-23 19:33:04 -07:00
|
|
|
return 0;
|
|
|
|
}
|
2003-08-25 17:16:49 -07:00
|
|
|
break_prog:
|
|
|
|
_edje_recalc(ed);
|
|
|
|
_edje_thaw(ed);
|
|
|
|
_edje_unref(ed);
|
|
|
|
_edje_unblock(ed);
|
2003-06-23 19:33:04 -07:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
_edje_program_end(Edje *ed, Edje_Running_Program *runp)
|
|
|
|
{
|
|
|
|
Evas_List *l;
|
2008-03-12 23:38:16 -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);
|
2003-06-23 19:33:04 -07:00
|
|
|
for (l = runp->program->targets; l; l = l->next)
|
|
|
|
{
|
|
|
|
Edje_Real_Part *rp;
|
|
|
|
Edje_Program_Target *pt;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2003-06-23 19:33:04 -07:00
|
|
|
pt = l->data;
|
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,
|
2004-04-01 07:32:17 -08:00
|
|
|
runp->program->tween.mode, 0.0);
|
|
|
|
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
|
|
|
pname = runp->program->name;
|
|
|
|
if (!ed->walking_actions)
|
2003-08-13 04:03:20 -07:00
|
|
|
{
|
|
|
|
_edje_anim_count--;
|
2003-08-25 17:16:49 -07:00
|
|
|
ed->actions = evas_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)
|
|
|
|
{
|
|
|
|
_edje_animators = evas_list_remove(_edje_animators, ed);
|
|
|
|
}
|
2003-08-13 04:03:20 -07:00
|
|
|
}
|
2003-08-25 17:16:49 -07:00
|
|
|
_edje_emit(ed, "program,stop", pname);
|
|
|
|
_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
|
2006-03-18 20:22:35 -08:00
|
|
|
_edje_program_run(Edje *ed, Edje_Program *pr, int force, const char *ssig, const char *ssrc)
|
2003-06-23 19:33:04 -07:00
|
|
|
{
|
|
|
|
Evas_List *l;
|
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;
|
|
|
|
ed->pending_actions = evas_list_append(ed->pending_actions, pp);
|
|
|
|
return;
|
|
|
|
}
|
2003-06-27 20:08:25 -07:00
|
|
|
if ((recursions >= 64) || (recursion_limit))
|
|
|
|
{
|
2003-08-05 15:56:29 -07:00
|
|
|
printf("EDJE ERROR: programs recursing up to recursion limit of %i. Disabled.\n",
|
|
|
|
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);
|
2003-06-23 19:33:04 -07:00
|
|
|
if (pr->action == EDJE_ACTION_TYPE_STATE_SET)
|
|
|
|
{
|
2003-07-07 00:55:18 -07:00
|
|
|
if ((pr->tween.time > 0.0) && (!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));
|
|
|
|
for (l = pr->targets; l; l = l->next)
|
|
|
|
{
|
|
|
|
Edje_Real_Part *rp;
|
|
|
|
Edje_Program_Target *pt;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2003-06-23 19:33:04 -07:00
|
|
|
pt = l->data;
|
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,
|
2004-04-01 07:32:17 -08:00
|
|
|
rp->param1.description->state.name,
|
2007-09-08 11:31:56 -07:00
|
|
|
rp->param1.description->state.value,
|
|
|
|
pr->state,
|
2004-04-01 07:32:17 -08:00
|
|
|
pr->value);
|
|
|
|
_edje_part_pos_set(ed, rp, pr->tween.mode, 0.0);
|
|
|
|
rp->program = runp;
|
|
|
|
}
|
2003-06-23 19:33:04 -07:00
|
|
|
}
|
|
|
|
}
|
2003-07-21 22:17:44 -07:00
|
|
|
_edje_emit(ed, "program,start", pr->name);
|
2004-03-07 18:43:48 -08:00
|
|
|
if (_edje_block_break(ed))
|
|
|
|
{
|
|
|
|
ed->actions = evas_list_append(ed->actions, runp);
|
|
|
|
goto break_prog;
|
|
|
|
}
|
2003-06-23 19:33:04 -07:00
|
|
|
if (!ed->actions)
|
|
|
|
_edje_animators = evas_list_append(_edje_animators, ed);
|
|
|
|
ed->actions = evas_list_append(ed->actions, runp);
|
|
|
|
runp->start_time = ecore_time_get();
|
|
|
|
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
|
|
|
|
{
|
|
|
|
for (l = pr->targets; l; l = l->next)
|
|
|
|
{
|
|
|
|
Edje_Real_Part *rp;
|
|
|
|
Edje_Program_Target *pt;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2003-06-23 19:33:04 -07:00
|
|
|
pt = l->data;
|
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);
|
|
|
|
_edje_part_pos_set(ed, rp, pr->tween.mode, 0.0);
|
|
|
|
}
|
2003-06-23 19:33:04 -07:00
|
|
|
}
|
|
|
|
}
|
2003-07-21 22:17:44 -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;
|
2003-07-21 20:04:46 -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
|
|
|
|
|
|
|
for (l = pr->after; l; l = l->next)
|
2003-08-08 00:45:39 -07:00
|
|
|
{
|
2003-08-08 01:14:35 -07:00
|
|
|
Edje_Program *pr2;
|
2004-03-07 18:43:48 -08:00
|
|
|
Edje_Program_After *pa = l->data;
|
2007-09-08 11:31:56 -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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (pr->action == EDJE_ACTION_TYPE_ACTION_STOP)
|
|
|
|
{
|
2003-07-21 22:17:44 -07:00
|
|
|
_edje_emit(ed, "program,start", pr->name);
|
2003-06-23 19:33:04 -07:00
|
|
|
for (l = pr->targets; l; l = l->next)
|
|
|
|
{
|
|
|
|
Edje_Program_Target *pt;
|
|
|
|
Evas_List *ll;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2003-06-23 19:33:04 -07:00
|
|
|
pt = l->data;
|
|
|
|
for (ll = ed->actions; ll; ll = ll->next)
|
|
|
|
{
|
|
|
|
Edje_Running_Program *runp;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2003-06-23 19:33:04 -07:00
|
|
|
runp = ll->data;
|
|
|
|
if (pt->id == runp->program->id)
|
|
|
|
{
|
|
|
|
_edje_program_end(ed, runp);
|
2003-08-04 20:15:12 -07:00
|
|
|
goto done;
|
2003-06-23 19:33:04 -07:00
|
|
|
}
|
|
|
|
}
|
2003-08-04 20:15:12 -07:00
|
|
|
for (ll = ed->pending_actions; ll; ll = ll->next)
|
|
|
|
{
|
|
|
|
Edje_Pending_Program *pp;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2003-08-04 20:15:12 -07:00
|
|
|
pp = ll->data;
|
|
|
|
if (pt->id == pp->program->id)
|
|
|
|
{
|
|
|
|
ed->pending_actions = evas_list_remove(ed->pending_actions, pp);
|
|
|
|
ecore_timer_del(pp->timer);
|
|
|
|
free(pp);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
done:
|
2004-01-17 05:09:35 -08:00
|
|
|
continue;
|
2003-06-23 19:33:04 -07:00
|
|
|
}
|
2003-07-21 22:17:44 -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;
|
2003-06-23 19:33:04 -07:00
|
|
|
}
|
|
|
|
else if (pr->action == EDJE_ACTION_TYPE_SIGNAL_EMIT)
|
|
|
|
{
|
2003-07-21 22:17:44 -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;
|
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;
|
2003-08-05 04:51:28 -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;
|
2003-08-05 04:51:28 -07:00
|
|
|
}
|
2003-08-31 19:53:08 -07:00
|
|
|
else if (pr->action == EDJE_ACTION_TYPE_DRAG_VAL_SET)
|
|
|
|
{
|
|
|
|
_edje_emit(ed, "program,start", pr->name);
|
|
|
|
if (_edje_block_break(ed)) goto break_prog;
|
|
|
|
for (l = pr->targets; l; l = l->next)
|
|
|
|
{
|
|
|
|
Edje_Real_Part *rp;
|
|
|
|
Edje_Program_Target *pt;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2003-08-31 19:53:08 -07:00
|
|
|
pt = l->data;
|
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];
|
|
|
|
if ((rp) && (rp->drag.down.count == 0))
|
|
|
|
{
|
|
|
|
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);
|
|
|
|
_edje_emit(ed, "drag,set", rp->part->name);
|
|
|
|
if (_edje_block_break(ed)) goto break_prog;
|
|
|
|
}
|
2003-08-31 19:53:08 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
_edje_emit(ed, "program,stop", pr->name);
|
|
|
|
if (_edje_block_break(ed)) goto break_prog;
|
|
|
|
}
|
|
|
|
else if (pr->action == EDJE_ACTION_TYPE_DRAG_VAL_STEP)
|
|
|
|
{
|
|
|
|
_edje_emit(ed, "program,start", pr->name);
|
|
|
|
if (_edje_block_break(ed)) goto break_prog;
|
|
|
|
for (l = pr->targets; l; l = l->next)
|
|
|
|
{
|
|
|
|
Edje_Real_Part *rp;
|
|
|
|
Edje_Program_Target *pt;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2003-08-31 19:53:08 -07:00
|
|
|
pt = l->data;
|
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];
|
|
|
|
if ((rp) && (rp->drag.down.count == 0))
|
|
|
|
{
|
|
|
|
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);
|
|
|
|
_edje_emit(ed, "drag,step", rp->part->name);
|
|
|
|
if (_edje_block_break(ed)) goto break_prog;
|
|
|
|
}
|
2003-08-31 19:53:08 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
_edje_emit(ed, "program,stop", pr->name);
|
|
|
|
if (_edje_block_break(ed)) goto break_prog;
|
|
|
|
}
|
|
|
|
else if (pr->action == EDJE_ACTION_TYPE_DRAG_VAL_PAGE)
|
|
|
|
{
|
|
|
|
_edje_emit(ed, "program,start", pr->name);
|
|
|
|
if (_edje_block_break(ed)) goto break_prog;
|
|
|
|
for (l = pr->targets; l; l = l->next)
|
|
|
|
{
|
|
|
|
Edje_Real_Part *rp;
|
|
|
|
Edje_Program_Target *pt;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2003-08-31 19:53:08 -07:00
|
|
|
pt = l->data;
|
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];
|
|
|
|
if ((rp) && (rp->drag.down.count == 0))
|
|
|
|
{
|
|
|
|
rp->drag.val.x += pr->value * rp->drag.page.x * rp->part->dragable.x;
|
2004-11-20 19:52:28 -08:00
|
|
|
rp->drag.val.y += pr->value2 * rp->drag.page.y * rp->part->dragable.y;
|
2004-04-01 07:32:17 -08:00
|
|
|
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);
|
|
|
|
_edje_emit(ed, "drag,page", rp->part->name);
|
|
|
|
if (_edje_block_break(ed)) goto break_prog;
|
|
|
|
}
|
2003-08-31 19:53:08 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
_edje_emit(ed, "program,stop", pr->name);
|
|
|
|
if (_edje_block_break(ed)) goto break_prog;
|
|
|
|
}
|
2004-03-27 21:26:17 -08:00
|
|
|
else if (pr->action == EDJE_ACTION_TYPE_SCRIPT)
|
|
|
|
{
|
|
|
|
char fname[128];
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2004-03-27 21:26:17 -08:00
|
|
|
_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;
|
2004-06-19 09:24:21 -07:00
|
|
|
_edje_recalc(ed);
|
2004-03-27 21:26:17 -08:00
|
|
|
}
|
2004-08-17 18:09:14 -07:00
|
|
|
else
|
|
|
|
{
|
|
|
|
_edje_emit(ed, "program,start", pr->name);
|
|
|
|
_edje_emit(ed, "program,stop", pr->name);
|
|
|
|
}
|
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 */
|
|
|
|
/* && (pr->tween.time > 0.0) && (!ed->no_anim))) */
|
|
|
|
))
|
2003-08-05 04:51:28 -07:00
|
|
|
{
|
2004-03-07 18:43:48 -08:00
|
|
|
for (l= pr->after; l; l = l->next)
|
2003-08-05 04:51:28 -07:00
|
|
|
{
|
|
|
|
Edje_Program *pr2;
|
2004-03-07 18:43:48 -08:00
|
|
|
Edje_Program_After *pa = l->data;
|
2007-09-08 11:31:56 -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;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2004-06-30 20:46:05 -07:00
|
|
|
if (ed->delete_me) return;
|
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);
|
2004-02-04 11:41:27 -08:00
|
|
|
}
|
|
|
|
|
2008-01-17 22:34:04 -08:00
|
|
|
struct _Edje_Program_Data
|
|
|
|
{
|
|
|
|
#ifdef EDJE_PROGRAM_CACHE
|
|
|
|
Evas_List *matches;
|
|
|
|
int matched;
|
|
|
|
#endif
|
|
|
|
Edje *ed;
|
|
|
|
const char *signal;
|
|
|
|
const char *source;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int _edje_glob_callback(Edje_Program *pr, void *dt)
|
|
|
|
{
|
|
|
|
struct _Edje_Program_Data *data = dt;
|
|
|
|
|
|
|
|
#ifdef EDJE_PROGRAM_CACHE
|
|
|
|
data->matched++;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
_edje_program_run(data->ed, pr, 0, data->signal, data->source);
|
|
|
|
if (_edje_block_break(data->ed))
|
|
|
|
{
|
|
|
|
#ifdef EDJE_PROGRAM_CACHE
|
|
|
|
evas_list_free(data->matches);
|
|
|
|
data->matches = NULL;
|
|
|
|
#endif
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef EDJE_PROGRAM_CACHE
|
|
|
|
data->matches = evas_list_append(data->matches, pr);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-02-26 12:12:00 -08:00
|
|
|
|
|
|
|
void
|
|
|
|
_edje_callbacks_patterns_clean(Edje *ed)
|
|
|
|
{
|
|
|
|
_edje_signals_sources_patterns_clean(&ed->patterns.callbacks);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_edje_callbacks_patterns_init(Edje *ed)
|
|
|
|
{
|
|
|
|
Edje_Signals_Sources_Patterns *ssp = &ed->patterns.callbacks;
|
|
|
|
|
|
|
|
if (ssp->signals_patterns)
|
|
|
|
return;
|
|
|
|
|
|
|
|
ssp->signals_patterns = edje_match_callback_signal_init(ed->callbacks);
|
|
|
|
ssp->sources_patterns = edje_match_callback_source_init(ed->callbacks);
|
|
|
|
}
|
|
|
|
|
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 = "";
|
2003-08-25 21:15:07 -07:00
|
|
|
// printf("EDJE EMIT: signal: \"%s\" source: \"%s\"\n", sig, src);
|
2003-08-25 17:16:49 -07:00
|
|
|
_edje_block(ed);
|
|
|
|
_edje_ref(ed);
|
|
|
|
_edje_freeze(ed);
|
2004-06-30 20:46:05 -07:00
|
|
|
if (ed->collection)
|
2003-06-23 19:33:04 -07:00
|
|
|
{
|
2004-06-30 20:46:05 -07:00
|
|
|
Edje_Part_Collection *ec;
|
2004-03-26 01:10:05 -08:00
|
|
|
#ifdef EDJE_PROGRAM_CACHE
|
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-06-30 20:46:05 -07:00
|
|
|
ec = ed->collection;
|
2004-03-26 01:10:05 -08:00
|
|
|
#ifdef EDJE_PROGRAM_CACHE
|
2004-06-30 20:46:05 -07:00
|
|
|
l1 = strlen(sig);
|
|
|
|
l2 = strlen(src);
|
2005-11-30 07:36:34 -08:00
|
|
|
tmps = alloca(l1 + l2 + 2);
|
|
|
|
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
|
|
|
|
{
|
|
|
|
Evas_List *matches;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2004-06-30 20:46:05 -07:00
|
|
|
if (evas_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
|
|
|
}
|
2004-06-30 20:46:05 -07:00
|
|
|
else if ((matches = evas_hash_find(ec->prog_cache.matches, tmps)))
|
2003-07-19 19:08:47 -07:00
|
|
|
{
|
2004-06-30 20:46:05 -07:00
|
|
|
for (l = matches; l; l = l->next)
|
2003-07-19 19:08:47 -07:00
|
|
|
{
|
2004-06-30 20:46:05 -07:00
|
|
|
Edje_Program *pr;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
2004-06-30 20:46:05 -07:00
|
|
|
pr = l->data;
|
|
|
|
_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
|
2008-01-17 22:34:04 -08:00
|
|
|
if (ed->collection->programs)
|
|
|
|
{
|
2008-02-21 10:48:36 -08:00
|
|
|
if (edje_match_programs_exec(ed->patterns.programs.signals_patterns,
|
|
|
|
ed->patterns.programs.sources_patterns,
|
2008-01-17 22:34:04 -08:00
|
|
|
sig,
|
|
|
|
src,
|
|
|
|
ed->collection->programs,
|
|
|
|
_edje_glob_callback,
|
|
|
|
&data) == 0)
|
2008-02-21 10:48:36 -08:00
|
|
|
goto break_prog;
|
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)
|
|
|
|
{
|
|
|
|
if (matched == 0)
|
2007-09-08 11:31:56 -07:00
|
|
|
ec->prog_cache.no_matches =
|
2004-06-30 20:46:05 -07:00
|
|
|
evas_hash_add(ec->prog_cache.no_matches, tmps, ed);
|
|
|
|
else
|
|
|
|
ec->prog_cache.matches =
|
2008-01-17 22:34:04 -08:00
|
|
|
evas_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-01-17 22:34:04 -08:00
|
|
|
Evas_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)
|
|
|
|
{
|
|
|
|
int r;
|
|
|
|
|
2008-02-26 12:12:00 -08:00
|
|
|
_edje_callbacks_patterns_init(ed);
|
2008-02-21 10:48:36 -08:00
|
|
|
r = edje_match_callback_exec(ed->patterns.callbacks.signals_patterns,
|
|
|
|
ed->patterns.callbacks.sources_patterns,
|
2008-01-17 22:34:04 -08:00
|
|
|
sig,
|
|
|
|
src,
|
|
|
|
ed->callbacks,
|
|
|
|
ed);
|
|
|
|
|
|
|
|
if (!r)
|
2008-02-21 10:48:36 -08:00
|
|
|
goto break_prog;
|
2003-08-15 06:35:25 -07:00
|
|
|
}
|
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;
|
|
|
|
for (l = ed->callbacks; l;)
|
|
|
|
{
|
|
|
|
Edje_Signal_Callback *escb;
|
|
|
|
Evas_List *next_l;
|
2007-09-08 11:31:56 -07:00
|
|
|
|
|
|
|
escb = l->data;
|
2003-08-15 06:35:25 -07:00
|
|
|
next_l = l->next;
|
|
|
|
if (escb->just_added)
|
|
|
|
escb->just_added = 0;
|
|
|
|
if (escb->delete_me)
|
|
|
|
{
|
|
|
|
ed->callbacks = evas_list_remove_list(ed->callbacks, l);
|
2005-11-30 07:36:34 -08:00
|
|
|
if (escb->signal) evas_stringshare_del(escb->signal);
|
|
|
|
if (escb->source) evas_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
|
|
|
break_prog:
|
|
|
|
_edje_unblock(ed);
|
|
|
|
_edje_thaw(ed);
|
|
|
|
_edje_unref(ed);
|
2003-08-15 06:35:25 -07:00
|
|
|
}
|