From 1bf1f933a9762f83f5dffa303d846ff4723936e6 Mon Sep 17 00:00:00 2001 From: Carsten Haitzler Date: Sat, 28 Jun 2003 04:20:41 +0000 Subject: [PATCH] "random" ranged delays are now allowed before a program starts... in fact any program. just provide an "in, 10.0 5.0;" line in the progrma to say "start thew program in (10.0 + (random value from 0.0 - 5.0)_ seconds from the time it is triggered. you can simply delay the program with a constant by making the range 0.0. SVN revision: 7104 --- legacy/edje/data/src/e_logo.edc | 14 ++++++++++++ legacy/edje/src/bin/edje_cc_handlers.c | 15 +++++++++++++ legacy/edje/src/lib/edje_callbacks.c | 12 +++++++++++ legacy/edje/src/lib/edje_data.c | 2 ++ legacy/edje/src/lib/edje_load.c | 16 ++++++++++++-- legacy/edje/src/lib/edje_private.h | 18 ++++++++++++++-- legacy/edje/src/lib/edje_program.c | 30 ++++++++++++++++++++++---- 7 files changed, 99 insertions(+), 8 deletions(-) diff --git a/legacy/edje/data/src/e_logo.edc b/legacy/edje/data/src/e_logo.edc index ab2b3a32b5..1521a925fd 100644 --- a/legacy/edje/data/src/e_logo.edc +++ b/legacy/edje/data/src/e_logo.edc @@ -390,6 +390,20 @@ collections { source, "logo_anim"; action, SIGNAL_EMIT "do_it" "the_source"; } + program { + name, "random_signal"; + signal, "show"; + source, ""; + in, 1.0 5.0; + action, SIGNAL_EMIT "do_random" "the_source"; + } + program { + name, "random_signal"; + signal, "do_random"; + source, "the_source"; + in, 1.0 5.0; + action, SIGNAL_EMIT "do_random" "the_source"; + } } } } diff --git a/legacy/edje/src/bin/edje_cc_handlers.c b/legacy/edje/src/bin/edje_cc_handlers.c index bd1872c263..2b38aed1a3 100644 --- a/legacy/edje/src/bin/edje_cc_handlers.c +++ b/legacy/edje/src/bin/edje_cc_handlers.c @@ -62,6 +62,7 @@ static void ob_collections_group_programs_program(void); static void st_collections_group_programs_program_name(void); static void st_collections_group_programs_program_signal(void); static void st_collections_group_programs_program_source(void); +static void st_collections_group_programs_program_in(void); static void st_collections_group_programs_program_action(void); static void st_collections_group_programs_program_transition(void); static void st_collections_group_programs_program_target(void); @@ -116,6 +117,7 @@ New_Statement_Handler statement_handlers[] = {"collections.group.programs.program.name", st_collections_group_programs_program_name}, {"collections.group.programs.program.signal", st_collections_group_programs_program_signal}, {"collections.group.programs.program.source", st_collections_group_programs_program_source}, + {"collections.group.programs.program.in", st_collections_group_programs_program_in}, {"collections.group.programs.program.action", st_collections_group_programs_program_action}, {"collections.group.programs.program.transition", st_collections_group_programs_program_transition}, {"collections.group.programs.program.target", st_collections_group_programs_program_target}, @@ -185,6 +187,7 @@ New_Object_Handler object_handlers[] = {"collections.group.programs.program.name", NULL}, {"collections.group.programs.program.signal", NULL}, {"collections.group.programs.program.source", NULL}, + {"collections.group.programs.program.in", NULL}, {"collections.group.programs.program.action", NULL}, {"collections.group.programs.program.transition", NULL}, {"collections.group.programs.program.target", NULL}, @@ -1045,6 +1048,18 @@ st_collections_group_programs_program_source(void) ep->source = parse_str(0); } +static void +st_collections_group_programs_program_in(void) +{ + Edje_Part_Collection *pc; + Edje_Program *ep; + + pc = evas_list_data(evas_list_last(edje_collections)); + ep = evas_list_data(evas_list_last(pc->programs)); + ep->in.from = parse_float_range(0, 0.0, 999999999.0); + ep->in.range = parse_float_range(1, 0.0, 999999999.0); +} + static void st_collections_group_programs_program_action(void) { diff --git a/legacy/edje/src/lib/edje_callbacks.c b/legacy/edje/src/lib/edje_callbacks.c index 3c235b3708..9a02d27eb3 100644 --- a/legacy/edje/src/lib/edje_callbacks.c +++ b/legacy/edje/src/lib/edje_callbacks.c @@ -161,3 +161,15 @@ _edje_timer_cb(void *data) _edje_timer = NULL; return 0; } + +int +_edje_pending_timer_cb(void *data) +{ + Edje_Pending_Program *pp; + + pp = data; + pp->edje->pending_actions = evas_list_remove(pp->edje->pending_actions, pp); + _edje_program_run(pp->edje, pp->program, 1); + free(pp); + return 0; +} diff --git a/legacy/edje/src/lib/edje_data.c b/legacy/edje/src/lib/edje_data.c index 59c6e09036..d9ea400d65 100644 --- a/legacy/edje/src/lib/edje_data.c +++ b/legacy/edje/src/lib/edje_data.c @@ -97,6 +97,8 @@ _edje_edd_setup(void) EET_DATA_DESCRIPTOR_ADD_BASIC(_edje_edd_edje_program, Edje_Program, "name", name, EET_T_STRING); EET_DATA_DESCRIPTOR_ADD_BASIC(_edje_edd_edje_program, Edje_Program, "signal", signal, EET_T_STRING); EET_DATA_DESCRIPTOR_ADD_BASIC(_edje_edd_edje_program, Edje_Program, "source", source, EET_T_STRING); + EET_DATA_DESCRIPTOR_ADD_BASIC(_edje_edd_edje_program, Edje_Program, "in.from", in.from, EET_T_DOUBLE); + EET_DATA_DESCRIPTOR_ADD_BASIC(_edje_edd_edje_program, Edje_Program, "in.range", in.range, EET_T_DOUBLE); EET_DATA_DESCRIPTOR_ADD_BASIC(_edje_edd_edje_program, Edje_Program, "action", action, EET_T_INT); EET_DATA_DESCRIPTOR_ADD_BASIC(_edje_edd_edje_program, Edje_Program, "state", state, EET_T_STRING); EET_DATA_DESCRIPTOR_ADD_BASIC(_edje_edd_edje_program, Edje_Program, "state2", state2, EET_T_STRING); diff --git a/legacy/edje/src/lib/edje_load.c b/legacy/edje/src/lib/edje_load.c index 17d0346519..78e69d147c 100644 --- a/legacy/edje/src/lib/edje_load.c +++ b/legacy/edje/src/lib/edje_load.c @@ -228,16 +228,28 @@ _edje_file_del(Edje *ed) } _edje_animators = evas_list_remove(_edje_animators, ed); } + if (ed->pending_actions) + { + while (ed->pending_actions) + { + Edje_Pending_Program *pp; + + pp = ed->pending_actions->data; + ed->pending_actions = evas_list_remove(ed->pending_actions, pp); + ecore_timer_del(pp->timer); + free(pp); + } + } } void _edje_file_free(Edje_File *edf) { - printf("FIXME: leak!\n"); + printf("FIXME: leak Edje_File!\n"); } void _edje_collection_free(Edje_Part_Collection *ec) { - printf("FIXME: leak!\n"); + printf("FIXME: leak Edje_Part_Collection!\n"); } diff --git a/legacy/edje/src/lib/edje_private.h b/legacy/edje/src/lib/edje_private.h index 8d4fa32e18..c966065bd7 100644 --- a/legacy/edje/src/lib/edje_private.h +++ b/legacy/edje/src/lib/edje_private.h @@ -11,7 +11,6 @@ #include /* FIXME: - * need "random" signals and events for hooking to, and "random" durations * free stuff - no more leaks * dragables have to work * drag start/top signals etc. @@ -162,6 +161,11 @@ struct _Edje_Program /* a conditional program to be run */ char *signal; /* if signal emission name matches the glob here... */ char *source; /* if part that emitted this (name) matches this glob */ + struct { + double from; + double range; + } in; + int action; /* type - set state, stop action, set drag pos etc. */ char *state; /* what state of alternates to apply, NULL = default */ char *state2; /* what other state to use - for signal emit action */ @@ -329,6 +333,7 @@ typedef struct _Edje_Running_Program Edje_Running_Program; typedef struct _Edje_Signal_Callback Edje_Signal_Callback; typedef struct _Edje_Calc_Params Edje_Calc_Params; typedef struct _Edje_Emission Edje_Emission; +typedef struct _Edje_Pending_Program Edje_Pending_Program; struct _Edje { @@ -351,6 +356,7 @@ struct _Edje Evas_List *parts; /* private list of parts */ Evas_List *actions; /* currently running actions */ Evas_List *callbacks; + Evas_List *pending_actions; int freeze; int references; }; @@ -424,6 +430,13 @@ struct _Edje_Emission char *source; }; +struct _Edje_Pending_Program +{ + Edje *edje; + Edje_Program *program; + Ecore_Timer *timer; +}; + void _edje_part_pos_set(Edje *ed, Edje_Real_Part *ep, int mode, double pos); void _edje_part_description_apply(Edje *ed, Edje_Real_Part *ep, char *d1, double v1, char *d2, double v2); void _edje_recalc(Edje *ed); @@ -435,6 +448,7 @@ void _edje_mouse_up_cb(void *data, Evas * e, Evas_Object * obj, void *event_inf void _edje_mouse_move_cb(void *data, Evas * e, Evas_Object * obj, void *event_info); void _edje_mouse_wheel_cb(void *data, Evas * e, Evas_Object * obj, void *event_info); int _edje_timer_cb(void *data); +int _edje_pending_timer_cb(void *data); void _edje_edd_setup(void); @@ -452,7 +466,7 @@ void _edje_unref(Edje *ed); int _edje_program_run_iterate(Edje_Running_Program *runp, double tim); void _edje_program_end(Edje *ed, Edje_Running_Program *runp); -void _edje_program_run(Edje *ed, Edje_Program *pr); +void _edje_program_run(Edje *ed, Edje_Program *pr, int force); void _edje_emit(Edje *ed, char *sig, char *src); Edje *_edje_fetch(Evas_Object *obj); diff --git a/legacy/edje/src/lib/edje_program.c b/legacy/edje/src/lib/edje_program.c index eeaddc2804..96d2c32071 100644 --- a/legacy/edje/src/lib/edje_program.c +++ b/legacy/edje/src/lib/edje_program.c @@ -155,7 +155,7 @@ _edje_program_run_iterate(Edje_Running_Program *runp, double tim) pr = evas_list_nth(runp->edje->collection->programs, runp->program->after); - if (pr) _edje_program_run(runp->edje, pr); + if (pr) _edje_program_run(runp->edje, pr, 0); } _edje_thaw(runp->edje); _edje_unref(runp->edje); @@ -206,13 +206,33 @@ _edje_program_end(Edje *ed, Edje_Running_Program *runp) } void -_edje_program_run(Edje *ed, Edje_Program *pr) +_edje_program_run(Edje *ed, Edje_Program *pr, int force) { Evas_List *l; /* limit self-feeding loops in programs to 64 levels */ static int recursions = 0; static int recursion_limit = 0; + if ((pr->in.from != 0.0) && (pr->in.range != 0.0) && (!force)) + { + Edje_Pending_Program *pp; + double r; + + pp = calloc(1, sizeof(Edje_Pending_Program)); + if (!pp) return; + if (pr->in.range > 0.0) r = ((double)rand() / RAND_MAX); + pp->timer = ecore_timer_add(pr->in.from + (pr->in.range * r), + _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; + } if ((recursions >= 64) || (recursion_limit)) { recursion_limit = 1; @@ -365,9 +385,11 @@ _edje_emit(Edje *ed, char *sig, char *src) Edje_Program *pr; pr = l->data; - if ((_edje_glob_match(ee->signal, pr->signal)) && + if ((pr->signal) && + (pr->source) && + (_edje_glob_match(ee->signal, pr->signal)) && (_edje_glob_match(ee->source, pr->source))) - _edje_program_run(ed, pr); + _edje_program_run(ed, pr, 0); } ed->walking_callbacks = 1; for (l = ed->callbacks; l; l = l->next)