Enlightenment CVS committal
Author : raster
Project : e17
Module : libs/edje
Dir : e17/libs/edje/src/lib
Modified Files:
Edje.h Edje_Edit.h edje_edit.c edje_embryo.c edje_load.c
edje_main.c edje_message_queue.c edje_private.h edje_program.c
edje_util.c
Log Message:
1. fix a leak. i was naughty. spank spank
2. message queue is in - i am currently not surer if i shoudl go with this
varags api internally ot move to a more manual "build a list" thing... but the
message queue does work - i've moved signals to use it.
===================================================================
RCS file: /cvsroot/enlightenment/e17/libs/edje/src/lib/Edje.h,v
retrieving revision 1.29
retrieving revision 1.30
diff -u -3 -r1.29 -r1.30
--- Edje.h 6 Jun 2004 04:42:17 -0000 1.29
+++ Edje.h 1 Jul 2004 03:46:05 -0000 1.30
@@ -5,6 +5,33 @@
/* FIXDOC: Define these? */
+typedef enum _Edje_Queue
+{
+ EDJE_QUEUE_APP,
+ EDJE_QUEUE_SCRIPT
+} Edje_Queue;
+
+typedef enum _Edje_Message_Type
+{
+ EDJE_MESSAGE_NONE,
+
+ EDJE_MESSAGE_SIGNAL,
+
+ EDJE_MESSAGE_STRING,
+ EDJE_MESSAGE_INT,
+ EDJE_MESSAGE_FLOAT,
+
+ EDJE_MESSAGE_STRING_SET,
+ EDJE_MESSAGE_INT_SET,
+ EDJE_MESSAGE_FLOAT_SET,
+
+ EDJE_MESSAGE_STRING_INT,
+ EDJE_MESSAGE_STRING_FLOAT,
+
+ EDJE_MESSAGE_STRING_INT_SET,
+ EDJE_MESSAGE_STRING_FLOAT_SET
+} Edje_Message_Type;
+
#define EDJE_DRAG_DIR_NONE 0
#define EDJE_DRAG_DIR_X 1
#define EDJE_DRAG_DIR_Y 2
===================================================================
RCS file: /cvsroot/enlightenment/e17/libs/edje/src/lib/Edje_Edit.h,v
retrieving revision 1.11
retrieving revision 1.12
diff -u -3 -r1.11 -r1.12
--- Edje_Edit.h 3 Jun 2004 09:14:55 -0000 1.11
+++ Edje_Edit.h 1 Jul 2004 03:46:05 -0000 1.12
@@ -380,7 +380,6 @@
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;
typedef struct _Edje_Text_Style Edje_Text_Style;
typedef struct _Edje_Color_Class Edje_Color_Class;
@@ -417,7 +416,6 @@
unsigned short walking_actions : 1;
unsigned short block_break : 1;
unsigned short delete_me : 1;
- unsigned short dont_clear_signals : 1;
double paused_at;
Evas *evas; /* the evas this edje belongs to */
Evas_Object *obj; /* the smart object */
@@ -432,7 +430,6 @@
Evas_List *text_classes;
int references;
int block;
- Evas_List *emissions;
int load_error;
int freeze;
/* variable pool for edje embryo scripts */
@@ -447,6 +444,8 @@
void (*func) (void *data, Evas_Object *obj, const char *part);
void *data;
} text_change;
+
+ int message_num;
};
struct _Edje_Real_Part
@@ -558,12 +557,6 @@
} text;
};
-struct _Edje_Emission
-{
- char *signal;
- char *source;
-};
-
struct _Edje_Pending_Program
{
Edje *edje;
@@ -693,6 +686,8 @@
Edje *_edje_add(Evas_Object *obj);
void _edje_del(Edje *ed);
+void _edje_ref(Edje *ed);
+void _edje_unref(Edje *ed);
void _edje_clean_objects(Edje *ed);
void _edje_ref(Edje *ed);
void _edje_unref(Edje *ed);
@@ -701,6 +696,7 @@
void _edje_program_end(Edje *ed, Edje_Running_Program *runp);
void _edje_program_run(Edje *ed, Edje_Program *pr, int force, char *ssig, char
*ssrc);
void _edje_emit(Edje *ed, char *sig, char *src);
+void _edje_emit_handle(Edje *ed, char *sig, char *src);
void _edje_text_init(void);
void _edje_text_part_on_add(Edje *ed, Edje_Real_Part *ep);
===================================================================
RCS file: /cvsroot/enlightenment/e17/libs/edje/src/lib/edje_edit.c,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -3 -r1.1 -r1.2
--- edje_edit.c 21 Feb 2004 05:24:10 -0000 1.1
+++ edje_edit.c 1 Jul 2004 03:46:05 -0000 1.2
@@ -1,3 +1,4 @@
+#include "Edje.h"
#include "edje_private.h"
int edje_edit_init()
===================================================================
RCS file: /cvsroot/enlightenment/e17/libs/edje/src/lib/edje_embryo.c,v
retrieving revision 1.16
retrieving revision 1.17
diff -u -3 -r1.16 -r1.17
--- edje_embryo.c 3 Jun 2004 09:14:55 -0000 1.16
+++ edje_embryo.c 1 Jul 2004 03:46:05 -0000 1.17
@@ -78,9 +78,29 @@
* get_strlen(id)
* get_str(id, dst[], maxlen)
* set_str(id, str[])
- * ** lists/arrays for stored variables
- * ** dynamic allocation (just use cell as index to dynamic block)
- * timer(Float:in, fname[], val);
+ * ######## lists/arrays for stored variables (to be implemented)
+ * # count(id)
+ * # remove(id, n)
+ * #
+ * # append_int(id, v)
+ * # prepend_int(id, v)
+ * # insert_int(id, v, n)
+ * # replace_int(id, v, n)
+ * # fetch_int(id, n)
+ * #
+ * # append_float(id, Float:v)
+ * # prepend_float(id, Float:v)
+ * # insert_float(id, Float:v, n)
+ * # replace_float(id, Float:v, n)
+ * # Float:fetch_float(id, n)
+ * #
+ * # append_str(id, str[])
+ * # prepend_str(id, str[])
+ * # insert_str(id, str[], n)
+ * # replace_str(id, str[], n)
+ * # fetch_str(id, n, dst[], maxlen)
+ * #
+ * timer(Float:in, fname[], val)
* cancel_timer(id)
* anim(Float:len, fname[], val)
* cancel_anim(id)
@@ -111,6 +131,12 @@
*
* still need to implement this:
*
+ * ##### post messages to the app via _edje_message_send();
+ * # message(id, type, ...);
+ * #
+ * ##### what about posting messages to OTHER edje objects (swallowed?)
+ * # ????
+ *
* ** part_id and program_id need to be able to be "found" from strings
*
* get_drag_count(part_id, &Float:dx, &Float:&dy)
@@ -964,17 +990,15 @@
fn = embryo_program_function_find(ed->collection->script, fname);
if (fn != EMBRYO_FUNCTION_NONE)
{
+ void *pdata;
+
printf("EDJE DEBUG: About to run script from program.\n");
embryo_parameter_string_push(ed->collection->script, sig);
embryo_parameter_string_push(ed->collection->script, src);
- {
- void *pdata;
-
- pdata = embryo_program_data_get(ed->collection->script);
- embryo_program_data_set(ed->collection->script, ed);
- embryo_program_run(ed->collection->script, fn);
- embryo_program_data_set(ed->collection->script, pdata);
- }
+ pdata = embryo_program_data_get(ed->collection->script);
+ embryo_program_data_set(ed->collection->script, ed);
+ embryo_program_run(ed->collection->script, fn);
+ embryo_program_data_set(ed->collection->script, pdata);
printf("EDJE DEBUG: Done.\n");
}
}
===================================================================
RCS file: /cvsroot/enlightenment/e17/libs/edje/src/lib/edje_load.c,v
retrieving revision 1.43
retrieving revision 1.44
diff -u -3 -r1.43 -r1.44
--- edje_load.c 6 Jun 2004 04:42:17 -0000 1.43
+++ edje_load.c 1 Jul 2004 03:46:05 -0000 1.44
@@ -526,8 +526,7 @@
void
_edje_file_del(Edje *ed)
{
- _edje_emit(ed, NULL, NULL); /* clear out signal emissions */
- ed->dont_clear_signals = 1;
+ _edje_message_del(ed);
_edje_block_violate(ed);
_edje_var_shutdown(ed);
if (ed->collection)
@@ -663,6 +662,19 @@
}
free(edf->collection_dir);
}
+ if (edf->data)
+ {
+ while (edf->data)
+ {
+ Edje_Data *edt;
+
+ edt = edf->data->data;
+ edf->data = evas_list_remove(edf->data, edt);
+ if (edt->key) free(edt->key);
+ if (edt->value) free(edt->value);
+ free(edt);
+ }
+ }
if (edf->collection_hash) evas_hash_free(edf->collection_hash);
free(edf);
}
@@ -723,6 +735,19 @@
}
free(ep);
}
+ if (ec->data)
+ {
+ while (ec->data)
+ {
+ Edje_Data *edt;
+
+ edt = ec->data->data;
+ ec->data = evas_list_remove(ec->data, edt);
+ if (edt->key) free(edt->key);
+ if (edt->value) free(edt->value);
+ free(edt);
+ }
+ }
#ifdef EDJE_PROGRAM_CACHE
if (ec->prog_cache.no_matches) evas_hash_free(ec->prog_cache.no_matches);
if (ec->prog_cache.matches)
===================================================================
RCS file: /cvsroot/enlightenment/e17/libs/edje/src/lib/edje_main.c,v
retrieving revision 1.37
retrieving revision 1.38
diff -u -3 -r1.37 -r1.38
--- edje_main.c 6 Jun 2004 04:42:17 -0000 1.37
+++ edje_main.c 1 Jul 2004 03:46:05 -0000 1.38
@@ -19,6 +19,7 @@
_edje_text_init();
embryo_init();
}
+ _edje_message_init();
return initted;
}
@@ -32,6 +33,7 @@
initted--;
if (initted > 0) return initted;
+ _edje_message_shutdown();
_edje_edd_free();
_edje_color_class_members_free();
_edje_text_class_members_free();
@@ -140,6 +142,5 @@
_edje_unref(Edje *ed)
{
ed->references--;
- if (ed->references <= 0)
- _edje_del(ed);
+ if (ed->references <= 0) _edje_del(ed);
}
===================================================================
RCS file: /cvsroot/enlightenment/e17/libs/edje/src/lib/edje_message_queue.c,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -3 -r1.1 -r1.2
--- edje_message_queue.c 29 Jun 2004 07:23:17 -0000 1.1
+++ edje_message_queue.c 1 Jul 2004 03:46:05 -0000 1.2
@@ -1,2 +1,393 @@
#include "Edje.h"
#include "edje_private.h"
+
+/* NB: global message que to be processed on idle enterer */
+
+/* NB: on deletion of an edje, remvoe all pending msg que items for it */
+
+/* NB: each edje needs a messagequeue cointer to knwo how many messages on the
+ * queue for that edje */
+
+/* NB: need to temporarly remove queue so messages added while processing the
+ * the queue so messages added as a result of processing dont loop. if the
+ * queue is not empty after processing scheduly 0.0 timeout to induce a
+ * new processing of the queue
+ */
+
+static Evas_List *msgq = NULL;
+static Evas_List *tmp_msgq = NULL;
+static Ecore_Idle_Enterer *idler = NULL;
+
+static int
+_edje_dummy_timer(void *data)
+{
+ return 0;
+}
+
+static int
+_edje_idler(void *data)
+{
+ _edje_message_queue_process();
+ return 1;
+}
+
+void
+_edje_message_init(void)
+{
+ idler = ecore_idle_enterer_add(_edje_idler, NULL);
+}
+
+void
+_edje_message_shutdown(void)
+{
+ _edje_message_queue_clear();
+ ecore_idle_enterer_del(idler);
+ idler = NULL;
+}
+
+Edje_Message *
+_edje_message_new(Edje *ed, Edje_Queue queue, Edje_Message_Type type, int id)
+{
+ Edje_Message *em;
+
+ em = calloc(1, sizeof(Edje_Message));
+ if (!em) return NULL;
+ em->edje = ed;
+ em->queue = queue;
+ em->type = type;
+ em->id = id;
+ em->edje->message_num++;
+ return em;
+}
+
+void
+_edje_message_free(Edje_Message *em)
+{
+ if (em->msg)
+ {
+ char *ptr;
+ int i, count;
+
+ switch (em->type)
+ {
+ case EDJE_MESSAGE_STRING:
+ case EDJE_MESSAGE_INT:
+ case EDJE_MESSAGE_FLOAT:
+ case EDJE_MESSAGE_INT_SET:
+ case EDJE_MESSAGE_FLOAT_SET:
+ free(em->msg);
+ break;
+ case EDJE_MESSAGE_STRING_FLOAT:
+ case EDJE_MESSAGE_STRING_INT:
+ case EDJE_MESSAGE_STRING_FLOAT_SET:
+ case EDJE_MESSAGE_STRING_INT_SET:
+ memcpy(&ptr, em->msg, sizeof(char *));
+ free(ptr);
+ free(em->msg);
+ break;
+ case EDJE_MESSAGE_SIGNAL:
+ memcpy(&ptr, em->msg, sizeof(char *));
+ free(ptr);
+ memcpy(&ptr, em->msg + sizeof(char *), sizeof(char *));
+ free(ptr);
+ free(em->msg);
+ break;
+ case EDJE_MESSAGE_STRING_SET:
+ memcpy(&count, em->msg, sizeof(int));
+ for (i = 0; i < count; i++)
+ {
+ memcpy(&ptr, em->msg + sizeof(int) + (i * sizeof(char *)),
sizeof(char *));
+ free(ptr);
+ }
+ free(em->msg);
+ break;
+ case EDJE_MESSAGE_NONE:
+ default:
+ break;
+ }
+ }
+ em->edje->message_num--;
+ free(em);
+}
+
+void
+_edje_message_send(Edje *ed, Edje_Queue queue, Edje_Message_Type type, int id, ...)
+{
+ /* FIXME: check all malloc fails and gracefully unroll and exit */
+ Edje_Message *em;
+ va_list args;
+ int count = 0, i;
+ char *str = NULL, *str2 = NULL, *s;
+ int num = 0;
+ double flt = 0.0;
+ unsigned char *msg = NULL;
+
+ em = _edje_message_new(ed, queue, type, id);
+ if (!em) return;
+ va_start(args, id);
+
+ /* this is evil code - but all we do is pack pointers, ints and doubles */
+ /* into the msg generic pointer one after the other */
+ switch (em->type)
+ {
+ case EDJE_MESSAGE_NONE:
+ break;
+ case EDJE_MESSAGE_SIGNAL:
+ str = va_arg(args, char *);
+ str2 = va_arg(args, char *);
+ msg = malloc(sizeof(char *) * 2);
+ s = strdup(str);
+ memcpy(msg + (0 * sizeof(char *)), &s, sizeof(char *));
+ s = strdup(str2);
+ memcpy(msg + (1 * sizeof(char *)), &s, sizeof(char *));
+ break;
+ case EDJE_MESSAGE_STRING:
+ str = va_arg(args, char *);
+ msg = strdup(str);
+ break;
+ case EDJE_MESSAGE_INT:
+ num = va_arg(args, int);
+ msg = malloc(sizeof(int));
+ memcpy(msg, &num, sizeof(int));
+ break;
+ case EDJE_MESSAGE_FLOAT:
+ flt = va_arg(args, double);
+ msg = malloc(sizeof(double));
+ memcpy(msg, &flt, sizeof(double));
+ break;
+ case EDJE_MESSAGE_STRING_SET:
+ count = va_arg(args, int);
+ msg = malloc(sizeof(int) + (count * sizeof(char *)));
+ memcpy(msg, &count, sizeof(int));
+ for (i = 0; i < count; i++)
+ {
+ str = va_arg(args, char *);
+ s = strdup(str);
+ memcpy(msg + sizeof(int) + (i * sizeof(char *)), &s, sizeof(char *));
+ }
+ break;
+ case EDJE_MESSAGE_INT_SET:
+ count = va_arg(args, int);
+ msg = malloc(sizeof(int) + (count * sizeof(int)));
+ memcpy(msg, &count, sizeof(int));
+ for (i = 0; i < count; i++)
+ {
+ num = va_arg(args, int);
+ memcpy(msg + sizeof(int) + (i * sizeof(int)), &num, sizeof(int));
+ }
+ break;
+ case EDJE_MESSAGE_FLOAT_SET:
+ count = va_arg(args, int);
+ msg = malloc(sizeof(int) + (count * sizeof(double)));
+ memcpy(msg, &count, sizeof(int));
+ for (i = 0; i < count; i++)
+ {
+ flt = va_arg(args, double);
+ memcpy(msg + sizeof(int) + (i * sizeof(double)), &flt, sizeof(double));
+ }
+ break;
+ case EDJE_MESSAGE_STRING_INT:
+ str = va_arg(args, char *);
+ num = va_arg(args, int);
+ msg = malloc(sizeof(char *) + sizeof(int));
+ s = strdup(str);
+ memcpy(msg, &s, sizeof(char *));
+ memcpy(msg + sizeof(char *), &num, sizeof(int));
+ break;
+ case EDJE_MESSAGE_STRING_FLOAT:
+ str = va_arg(args, char *);
+ flt = va_arg(args, double);
+ msg = malloc(sizeof(char *) + sizeof(double));
+ s = strdup(str);
+ memcpy(msg, &s, sizeof(char *));
+ memcpy(msg + sizeof(char *), &flt, sizeof(double));
+ break;
+ case EDJE_MESSAGE_STRING_INT_SET:
+ str = va_arg(args, char *);
+ count = va_arg(args, int);
+ msg = malloc(sizeof (char *) + sizeof(int) + (count * sizeof(int)));
+ s = strdup(str);
+ memcpy(msg, &s, sizeof(char *));
+ memcpy(msg + sizeof(char *), &count, sizeof(int));
+ for (i = 0; i < count; i++)
+ {
+ num = va_arg(args, int);
+ memcpy(msg + sizeof(char *) + sizeof(int) + (i * sizeof(int)), &num,
sizeof(int));
+ }
+ break;
+ case EDJE_MESSAGE_STRING_FLOAT_SET:
+ str = va_arg(args, char *);
+ count = va_arg(args, int);
+ msg = malloc(sizeof (char *) + sizeof(int) + (count * sizeof(double)));
+ s = strdup(str);
+ memcpy(msg, &s, sizeof(char *));
+ memcpy(msg + sizeof(char *), &count, sizeof(int));
+ for (i = 0; i < count; i++)
+ {
+ flt = va_arg(args, double);
+ memcpy(msg + sizeof(char *) + sizeof(int) + (i * sizeof(double)), &flt,
sizeof(double));
+ }
+ break;
+ default:
+ break;
+ }
+
+ em->msg = msg;
+ msgq = evas_list_append(msgq, em);
+
+ va_end(args);
+}
+
+void
+_edje_message_process(Edje_Message *em)
+{
+ switch (em->type)
+ {
+ case EDJE_MESSAGE_NONE:
+ switch (em->queue)
+ {
+ case EDJE_QUEUE_APP:
+ /* simply call app callback */
+ break;
+ case EDJE_QUEUE_SCRIPT:
+ if ((em->edje->collection) && (em->edje->collection->script))
+ {
+ Embryo_Function fn;
+
+ _edje_embryo_script_reset(em->edje);
+ fn = embryo_program_function_find(em->edje->collection->script,
"_msg");
+ if (fn != EMBRYO_FUNCTION_NONE)
+ {
+ void *pdata;
+ Embryo_Cell cell;
+
+// embryo_parameter_string_push(em->edje->collection->script, sig);
+ /* first param is the integer of the event id - always there */
+ cell = em->id;
+ embryo_parameter_cell_push(em->edje->collection->script, cell);
+ pdata = embryo_program_data_get(em->edje->collection->script);
+ embryo_program_data_set(em->edje->collection->script, em->edje);
+ embryo_program_run(em->edje->collection->script, fn);
+ embryo_program_data_set(em->edje->collection->script, pdata);
+ }
+ }
+ /* call script fn */
+ break;
+ default:
+ break;
+ }
+ break;
+ case EDJE_MESSAGE_SIGNAL:
+ {
+ char *str1;
+ char *str2;
+
+ memcpy(&str1, em->msg, sizeof(char *));
+ memcpy(&str2, em->msg + sizeof(char *), sizeof(char *));
+// printf("HANDLE SIG!\n");
+ _edje_emit_handle(em->edje, str1, str2);
+ }
+ break;
+ case EDJE_MESSAGE_STRING:
+ break;
+ case EDJE_MESSAGE_INT:
+ break;
+ case EDJE_MESSAGE_FLOAT:
+ break;
+ case EDJE_MESSAGE_STRING_SET:
+ break;
+ case EDJE_MESSAGE_INT_SET:
+ break;
+ case EDJE_MESSAGE_FLOAT_SET:
+ break;
+ case EDJE_MESSAGE_STRING_INT:
+ break;
+ case EDJE_MESSAGE_STRING_FLOAT:
+ break;
+ case EDJE_MESSAGE_STRING_INT_SET:
+ break;
+ case EDJE_MESSAGE_STRING_FLOAT_SET:
+ break;
+ default:
+ break;
+ }
+}
+
+void
+_edje_message_queue_process(void)
+{
+ if (msgq == NULL) return;
+
+// printf("PROCESS\n");
+ /* a temporary message queue */
+ tmp_msgq = msgq;
+ msgq = NULL;
+
+ while (tmp_msgq)
+ {
+ Edje_Message *em;
+
+ em = tmp_msgq->data;
+ tmp_msgq = evas_list_remove_list(tmp_msgq, tmp_msgq);
+ _edje_message_process(em);
+ _edje_message_free(em);
+ }
+
+ /* if the message queue filled again set a timer to expire in 0.0 sec */
+ /* to get the dle enterer to be run again */
+ if (msgq)
+ ecore_timer_add(0.0, _edje_dummy_timer, NULL);
+}
+
+void
+_edje_message_queue_clear(void)
+{
+ while (msgq)
+ {
+ Edje_Message *em;
+
+ em = msgq->data;
+ msgq = evas_list_remove_list(msgq, msgq);
+ _edje_message_free(em);
+ }
+}
+
+void
+_edje_message_del(Edje *ed)
+{
+ Evas_List *l;
+
+ if (ed->message_num <= 0) return;
+ /* delete any messages on the main queue for this edje object */
+ for (l = msgq; ; )
+ {
+ Edje_Message *em;
+ Evas_List *lp;
+
+ em = l->data;
+ lp = l;
+ l = l->next;
+ if (em->edje == ed)
+ {
+ msgq = evas_list_remove_list(msgq, lp);
+ _edje_message_free(em);
+ }
+ if (ed->message_num <= 0) return;
+ }
+ /* delete any on the processing queue */
+ for (l = tmp_msgq; ; )
+ {
+ Edje_Message *em;
+ Evas_List *lp;
+
+ em = l->data;
+ lp = l;
+ l = l->next;
+ if (em->edje == ed)
+ {
+ msgq = evas_list_remove_list(msgq, lp);
+ _edje_message_free(em);
+ }
+ if (ed->message_num <= 0) return;
+ }
+}
===================================================================
RCS file: /cvsroot/enlightenment/e17/libs/edje/src/lib/edje_private.h,v
retrieving revision 1.65
retrieving revision 1.66
diff -u -3 -r1.65 -r1.66
--- edje_private.h 3 Jun 2004 09:14:55 -0000 1.65
+++ edje_private.h 1 Jul 2004 03:46:05 -0000 1.66
@@ -15,6 +15,7 @@
#include <math.h>
#include <fnmatch.h>
+#include <stdarg.h>
#ifdef HAVE_ALLOCA_H
#include <alloca.h>
@@ -40,6 +41,16 @@
* ? all unsafe calls that may result in callbacks must be marked and dealt with
*/
+typedef struct _Edje_Message Edje_Message;
+
+struct _Edje_Message
+{
+ Edje *edje;
+ Edje_Queue queue;
+ Edje_Message_Type type;
+ int id;
+ unsigned char *msg;
+};
extern Eet_Data_Descriptor *_edje_edd_edje_file;
extern Eet_Data_Descriptor *_edje_edd_edje_data;
@@ -116,5 +127,14 @@
void _edje_var_anim_del (Edje *ed, int id);
void _edje_var_anim_frametime_reset(void);
-
+void _edje_message_init(void);
+void _edje_message_shutdown(void);
+Edje_Message *_edje_message_new(Edje *ed, Edje_Queue queue, Edje_Message_Type type,
int id);
+void _edje_message_free(Edje_Message *em);
+void _edje_message_send(Edje *ed, Edje_Queue queue, Edje_Message_Type type, int id,
...);
+void _edje_message_process(Edje_Message *em);
+void _edje_message_queue_process(void);
+void _edje_message_queue_clear(void);
+void _edje_message_del(Edje *ed);
+
#endif
===================================================================
RCS file: /cvsroot/enlightenment/e17/libs/edje/src/lib/edje_program.c,v
retrieving revision 1.35
retrieving revision 1.36
diff -u -3 -r1.35 -r1.36
--- edje_program.c 19 Jun 2004 16:24:20 -0000 1.35
+++ edje_program.c 1 Jul 2004 03:46:05 -0000 1.36
@@ -724,209 +724,141 @@
_edje_unblock(ed);
}
-static void _edje_emission_free(Edje_Emission *ee)
+void
+_edje_emit(Edje *ed, char *sig, char *src)
{
- if (!ee)
- return;
-
- if (ee->signal)
- free(ee->signal);
-
- if (ee->source)
- free(ee->source);
-
- free(ee);
+ if (ed->delete_me) return;
+ _edje_message_send(ed, EDJE_QUEUE_APP, EDJE_MESSAGE_SIGNAL, 0, sig, src);
}
+/* FIXME: what if we delete the evas object??? */
void
-_edje_emit(Edje *ed, char *sig, char *src)
+_edje_emit_handle(Edje *ed, char *sig, char *src)
{
Evas_List *l;
- Edje_Emission *ee = NULL;
- /* limit self-feeding loops in callbacks to 64 levels */
- static int recursions = 0;
- static int recursion_limit = 0;
-
- if ((!sig) && (!src))
- {
- while (ed->emissions)
- {
- ee = ed->emissions->data;
- ed->emissions = evas_list_remove(ed->emissions, ee);
- _edje_emission_free(ee);
- }
- return;
- }
if (ed->delete_me) return;
- if ((recursions >= 64) || (recursion_limit))
- {
- recursion_limit = 1;
- return;
- }
- recursions++;
// printf("EDJE EMIT: signal: \"%s\" source: \"%s\"\n", sig, src);
- if ((sig) && (src))
- {
- ee = calloc(1, sizeof(Edje_Emission));
- if (!ee)
- {
- recursions--;
- if (recursions == 0) recursion_limit = 0;
- return;
- }
- ee->signal = strdup(sig);
- ee->source = strdup(src);
- if ((ed->emissions) || (_edje_block_break(ed)))
- {
- ed->emissions = evas_list_append(ed->emissions, ee);
- recursions--;
- if (recursions == 0) recursion_limit = 0;
- return;
- }
- else
- ed->emissions = evas_list_append(ed->emissions, ee);
- }
- if (!ed->emissions) return;
_edje_block(ed);
_edje_ref(ed);
_edje_freeze(ed);
- while (ed->emissions)
+ if (ed->collection)
{
- ee = ed->emissions->data;
- ed->emissions = evas_list_remove(ed->emissions, ee);
- if (ed->collection)
- {
- Edje_Part_Collection *ec;
+ Edje_Part_Collection *ec;
#ifdef EDJE_PROGRAM_CACHE
- char *tmps;
+ char *tmps;
+ int l1, l2;
#endif
- int l1, l2;
- int done;
-
- ec = ed->collection;
+ int done;
+
+ ec = ed->collection;
+#ifdef EDJE_PROGRAM_CACHE
+ l1 = strlen(sig);
+ l2 = strlen(src);
+ tmps = malloc(l1 + l2 + 2);
+
+ if (tmps)
+ {
+ strcpy(tmps, sig);
+ tmps[l1] = '\377';
+ strcpy(&(tmps[l1 + 1]), src);
+ }
+#endif
+ done = 0;
+
#ifdef EDJE_PROGRAM_CACHE
- l1 = strlen(ee->signal);
- l2 = strlen(ee->source);
- tmps = malloc(l1 + l2 + 2);
+ if (tmps)
+ {
+ Evas_List *matches;
- if (tmps)
+ if (evas_hash_find(ec->prog_cache.no_matches, tmps))
{
- strcpy(tmps, ee->signal);
- tmps[l1] = '\377';
- strcpy(&(tmps[l1 + 1]), ee->source);
+ done = 1;
}
-#endif
- done = 0;
-
-#ifdef EDJE_PROGRAM_CACHE
- if (tmps)
+ else if ((matches = evas_hash_find(ec->prog_cache.matches, tmps)))
{
- Evas_List *matches;
-
- if (evas_hash_find(ec->prog_cache.no_matches, tmps))
+ for (l = matches; l; l = l->next)
{
- done = 1;
- }
- else if ((matches = evas_hash_find(ec->prog_cache.matches, tmps)))
- {
- for (l = matches; l; l = l->next)
+ Edje_Program *pr;
+
+ pr = l->data;
+ _edje_program_run(ed, pr, 0, sig, src);
+ if (_edje_block_break(ed))
{
- Edje_Program *pr;
-
- pr = l->data;
- _edje_program_run(ed, pr, 0, sig, src);
- if (_edje_block_break(ed))
- {
- if (tmps) free(tmps);
- if (!ed->dont_clear_signals)
- _edje_emit(ed, NULL, NULL);
- goto break_prog;
- }
+ if (tmps) free(tmps);
+ goto break_prog;
}
- done = 1;
}
+ done = 1;
}
+ }
#endif
- if (!done)
- {
+ if (!done)
+ {
#ifdef EDJE_PROGRAM_CACHE
- int matched = 0;
- Evas_List *matches = NULL;
+ int matched = 0;
+ Evas_List *matches = NULL;
#endif
+
+ for (l = ed->collection->programs; l; l = l->next)
+ {
+ Edje_Program *pr;
- for (l = ed->collection->programs; l; l = l->next)
+ pr = l->data;
+ if ((pr->signal) &&
+ (pr->source) &&
+ (_edje_glob_match(sig, pr->signal)) &&
+ (_edje_glob_match(src, pr->source)))
{
- Edje_Program *pr;
-
- pr = l->data;
- if ((pr->signal) &&
- (pr->source) &&
- (_edje_glob_match(ee->signal, pr->signal)) &&
- (_edje_glob_match(ee->source, pr->source)))
- {
#ifdef EDJE_PROGRAM_CACHE
- matched++;
+ matched++;
#endif
- _edje_program_run(ed, pr, 0, ee->signal, ee->source);
- if (_edje_block_break(ed))
- {
+ _edje_program_run(ed, pr, 0, sig, src);
+ if (_edje_block_break(ed))
+ {
#ifdef EDJE_PROGRAM_CACHE
- if (tmps) free(tmps);
- evas_list_free(matches);
+ if (tmps) free(tmps);
+ evas_list_free(matches);
#endif
- if (!ed->dont_clear_signals)
- _edje_emit(ed, NULL, NULL);
- goto break_prog;
- }
-#ifdef EDJE_PROGRAM_CACHE
- matches = evas_list_append(matches, pr);
-#endif
+ goto break_prog;
}
- }
#ifdef EDJE_PROGRAM_CACHE
- if (tmps)
- {
- if (matched == 0)
- ec->prog_cache.no_matches =
- evas_hash_add(ec->prog_cache.no_matches, tmps, ed);
- else
- ec->prog_cache.matches =
- evas_hash_add(ec->prog_cache.matches, tmps, matches);
+ matches = evas_list_append(matches, pr);
+#endif
}
-#endif
}
- _edje_emit_cb(ed, ee->signal, ee->source);
- if (_edje_block_break(ed))
- {
#ifdef EDJE_PROGRAM_CACHE
- if (tmps) free(tmps);
-#endif
- if (!ed->dont_clear_signals)
- _edje_emit(ed, NULL, NULL);
- goto break_prog;
+ if (tmps)
+ {
+ if (matched == 0)
+ ec->prog_cache.no_matches =
+ evas_hash_add(ec->prog_cache.no_matches, tmps, ed);
+ else
+ ec->prog_cache.matches =
+ evas_hash_add(ec->prog_cache.matches, tmps, matches);
}
+#endif
+ }
+ _edje_emit_cb(ed, sig, src);
+ if (_edje_block_break(ed))
+ {
#ifdef EDJE_PROGRAM_CACHE
if (tmps) free(tmps);
- tmps = NULL;
-#endif
+#endif
+ goto break_prog;
}
-
- _edje_emission_free(ee);
- ee = NULL;
+#ifdef EDJE_PROGRAM_CACHE
+ if (tmps) free(tmps);
+ tmps = NULL;
+#endif
}
break_prog:
-
- if (ee)
- _edje_emission_free(ee);
-
- recursions--;
- if (recursions == 0) recursion_limit = 0;
_edje_thaw(ed);
_edje_unref(ed);
_edje_unblock(ed);
}
+/* FIXME: what if we delete the evas object??? */
static void
_edje_emit_cb(Edje *ed, char *sig, char *src)
{
===================================================================
RCS file: /cvsroot/enlightenment/e17/libs/edje/src/lib/edje_util.c,v
retrieving revision 1.38
retrieving revision 1.39
diff -u -3 -r1.38 -r1.39
--- edje_util.c 6 Jun 2004 04:42:17 -0000 1.38
+++ edje_util.c 1 Jul 2004 03:46:05 -0000 1.39
@@ -1480,8 +1480,6 @@
if (ed->block == 0)
{
ed->block_break = 0;
- ed->dont_clear_signals = 0;
- if (ed->emissions) _edje_emit(ed, "", NULL);
}
return ed->block;
}
-------------------------------------------------------
This SF.Net email sponsored by Black Hat Briefings & Training.
Attend Black Hat Briefings & Training, Las Vegas July 24-29 -
digital self defense, top technical experts, no vendor pitches,
unmatched networking opportunities. Visit www.blackhat.com
_______________________________________________
enlightenment-cvs mailing list
[EMAIL PROTECTED]
https://lists.sourceforge.net/lists/listinfo/enlightenment-cvs
