enlightenment/efl
enlightenment
/
efl
8
7
Fork 14
Code Issues 13 Pull Requests 3 Projects Releases Wiki Activity

werd up to ma homies yo... err - i mean - message queue now uses more 

standard structs for messages, and i allow the message queue to fee itsel for
up to 8 iterations before forcing us to rever to normal loop processing
again. this shoudl cover most soignal emit/respond cases in normal usage
without forcing more loop to run and possibly a render.


SVN revision: 10662
This commit is contained in:
Carsten Haitzler 2004-07-02 03:24:56 +00:00
parent 4c90cb8d2a
commit 6393094fb7
4 changed files with 326 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

107
legacy/edje/src/lib/Edje.h
View File

@ -32,19 +32,102 @@ typedef enum _Edje_Message_Type
EDJE_MESSAGE_STRING_FLOAT_SET = 11
} Edje_Message_Type;
#define EDJE_DRAG_DIR_NONE 0
#define EDJE_DRAG_DIR_X 1
#define EDJE_DRAG_DIR_Y 2
#define EDJE_DRAG_DIR_XY 3
typedef struct _Edje_Message_Signal Edje_Message_Signal;
typedef struct _Edje_Message_String Edje_Message_String;
typedef struct _Edje_Message_Int Edje_Message_Int;
typedef struct _Edje_Message_Float Edje_Message_Float;
typedef struct _Edje_Message_String_Set Edje_Message_String_Set;
typedef struct _Edje_Message_Int_Set Edje_Message_Int_Set;
typedef struct _Edje_Message_Float_Set Edje_Message_Float_Set;
typedef struct _Edje_Message_String_Int Edje_Message_String_Int;
typedef struct _Edje_Message_String_Float Edje_Message_String_Float;
typedef struct _Edje_Message_String_Int_Set Edje_Message_String_Int_Set;
typedef struct _Edje_Message_String_Float_Set Edje_Message_String_Float_Set;
#define EDJE_LOAD_ERROR_NONE 0
#define EDJE_LOAD_ERROR_GENERIC 1
#define EDJE_LOAD_ERROR_DOES_NOT_EXIST 2
#define EDJE_LOAD_ERROR_PERMISSION_DENIED 3
#define EDJE_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED 4
#define EDJE_LOAD_ERROR_CORRUPT_FILE 5
#define EDJE_LOAD_ERROR_UNKNOWN_FORMAT 6
#define EDJE_LOAD_ERROR_INCOMPATIBLE_FILE 7
struct _Edje_Message_Signal
{
char *sig;
char *src;
};
struct _Edje_Message_String
{
char *str;
};
struct _Edje_Message_Int
{
int val;
};
struct _Edje_Message_Float
{
double val;
};
struct _Edje_Message_String_Set
{
int count;
char *str[1];
};
struct _Edje_Message_Int_Set
{
int count;
int val[1];
};
struct _Edje_Message_Float_Set
{
int count;
double val[1];
};
struct _Edje_Message_String_Int
{
char *str;
int val;
};
struct _Edje_Message_String_Float
{
char *str;
double val;
};
struct _Edje_Message_String_Int_Set
{
char *str;
int count;
int val[1];
};
struct _Edje_Message_String_Float_Set
{
char *str;
int count;
double val[1];
};
enum
{
EDJE_DRAG_DIR_NONE = 0,
EDJE_DRAG_DIR_X = 1,
EDJE_DRAG_DIR_Y = 2,
EDJE_DRAG_DIR_XY = 3
};
enum
{
EDJE_LOAD_ERROR_NONE = 0,
EDJE_LOAD_ERROR_GENERIC = 1,
EDJE_LOAD_ERROR_DOES_NOT_EXIST = 2,
EDJE_LOAD_ERROR_PERMISSION_DENIED = 3,
EDJE_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED = 4,
EDJE_LOAD_ERROR_CORRUPT_FILE = 5,
EDJE_LOAD_ERROR_UNKNOWN_FORMAT = 6,
EDJE_LOAD_ERROR_INCOMPATIBLE_FILE = 7
};
#ifdef __cplusplus
extern "C" {

333
legacy/edje/src/lib/edje_message_queue.c
View File

@ -21,6 +21,7 @@ static Ecore_Idle_Enterer *idler = NULL;
static int
_edje_dummy_timer(void *data)
{
printf("DUMMY\n");
return 0;
}
@ -71,35 +72,94 @@ _edje_message_free(Edje_Message *em)
switch (em->type)
{
case EDJE_MESSAGE_STRING:
{
Edje_Message_String *emsg;
emsg = (Edje_Message_String *)em->msg;
free(emsg->str);
free(emsg);
}
case EDJE_MESSAGE_INT:
{
Edje_Message_Int *emsg;
emsg = (Edje_Message_Int *)em->msg;
free(emsg);
}
case EDJE_MESSAGE_FLOAT:
{
Edje_Message_Float *emsg;
emsg = (Edje_Message_Float *)em->msg;
free(emsg);
}
case EDJE_MESSAGE_INT_SET:
{
Edje_Message_Int_Set *emsg;
emsg = (Edje_Message_Int_Set *)em->msg;
free(emsg);
}
break;
case EDJE_MESSAGE_FLOAT_SET:
free(em->msg);
{
Edje_Message_Float_Set *emsg;
emsg = (Edje_Message_Float_Set *)em->msg;
free(emsg);
}
break;
case EDJE_MESSAGE_STRING_FLOAT:
{
Edje_Message_String_Float *emsg;
emsg = (Edje_Message_String_Float *)em->msg;
free(emsg->str);
free(emsg);
}
case EDJE_MESSAGE_STRING_INT:
{
Edje_Message_String_Int *emsg;
emsg = (Edje_Message_String_Int *)em->msg;
free(emsg->str);
free(emsg);
}
case EDJE_MESSAGE_STRING_FLOAT_SET:
{
Edje_Message_String_Float_Set *emsg;
emsg = (Edje_Message_String_Float_Set *)em->msg;
free(emsg->str);
free(emsg);
}
case EDJE_MESSAGE_STRING_INT_SET:
memcpy(&ptr, em->msg, sizeof(char *));
free(ptr);
free(em->msg);
break;
{
Edje_Message_String_Int_Set *emsg;
emsg = (Edje_Message_String_Int_Set *)em->msg;
free(emsg->str);
free(emsg);
}
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);
{
Edje_Message_Signal *emsg;
emsg = (Edje_Message_Signal *)em->msg;
free(emsg->sig);
free(emsg->src);
free(emsg);
}
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);
Edje_Message_String_Set *emsg;
emsg = (Edje_Message_String_Set *)em->msg;
for (i = 0; i < emsg->count; i++)
free(emsg->str[i]);
free(emsg);
}
free(em->msg);
break;
case EDJE_MESSAGE_NONE:
default:
@ -111,121 +171,142 @@ _edje_message_free(Edje_Message *em)
}
void
_edje_message_send(Edje *ed, Edje_Queue queue, Edje_Message_Type type, int id, ...)
_edje_message_send(Edje *ed, Edje_Queue queue, Edje_Message_Type type, int id, void *emsg)
{
/* FIXME: check all malloc fails and gracefully unroll and exit */
/* FIXME: check all malloc & strdup 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;
int i;
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 *));
{
Edje_Message_Signal *emsg2, *emsg3;
emsg2 = (Edje_Message_Signal *)emsg;
emsg3 = malloc(sizeof(Edje_Message_Signal));
emsg3->sig = strdup(emsg2->sig);
emsg3->src = strdup(emsg2->src);
msg = (unsigned char *)emsg3;
}
break;
case EDJE_MESSAGE_STRING:
str = va_arg(args, char *);
msg = strdup(str);
{
Edje_Message_String *emsg2, *emsg3;
emsg2 = (Edje_Message_String *)emsg;
emsg3 = malloc(sizeof(Edje_Message_String));
emsg3->str = strdup(emsg2->str);
msg = (unsigned char *)emsg3;
}
break;
case EDJE_MESSAGE_INT:
num = va_arg(args, int);
msg = malloc(sizeof(int));
memcpy(msg, &num, sizeof(int));
{
Edje_Message_Int *emsg2, *emsg3;
emsg2 = (Edje_Message_Int *)emsg;
emsg3 = malloc(sizeof(Edje_Message_Int));
emsg3->val = emsg2->val;
msg = (unsigned char *)emsg3;
}
break;
case EDJE_MESSAGE_FLOAT:
flt = va_arg(args, double);
msg = malloc(sizeof(double));
memcpy(msg, &flt, sizeof(double));
{
Edje_Message_Float *emsg2, *emsg3;
emsg2 = (Edje_Message_Float *)emsg;
emsg3 = malloc(sizeof(Edje_Message_Float));
emsg3->val = emsg2->val;
msg = (unsigned char *)emsg3;
}
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 *));
Edje_Message_String_Set *emsg2, *emsg3;
emsg2 = (Edje_Message_String_Set *)emsg;
emsg3 = malloc(sizeof(Edje_Message_String_Set) + ((emsg2->count - 1) * sizeof(char *)));
emsg3->count = emsg2->count;
for (i = 0; i < emsg3->count; i++)
emsg3->str[i] = strdup(emsg2->str[i]);
msg = (unsigned char *)emsg3;
}
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));
Edje_Message_Int_Set *emsg2, *emsg3;
emsg2 = (Edje_Message_Int_Set *)emsg;
emsg3 = malloc(sizeof(Edje_Message_Int_Set) + ((emsg2->count - 1) * sizeof(int)));
emsg3->count = emsg2->count;
for (i = 0; i < emsg3->count; i++)
emsg3->val[i] = emsg2->val[i];
msg = (unsigned char *)emsg3;
}
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));
Edje_Message_Float_Set *emsg2, *emsg3;
emsg2 = (Edje_Message_Float_Set *)emsg;
emsg3 = malloc(sizeof(Edje_Message_Float_Set) + ((emsg2->count - 1) * sizeof(double)));
emsg3->count = emsg2->count;
for (i = 0; i < emsg3->count; i++)
emsg3->val[i] = emsg2->val[i];
msg = (unsigned char *)emsg3;
}
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));
{
Edje_Message_String_Int *emsg2, *emsg3;
emsg2 = (Edje_Message_String_Int *)emsg;
emsg3 = malloc(sizeof(Edje_Message_String_Int));
emsg3->str = strdup(emsg2->str);
emsg3->val = emsg2->val;
msg = (unsigned char *)emsg3;
}
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));
{
Edje_Message_String_Float *emsg2, *emsg3;
emsg2 = (Edje_Message_String_Float *)emsg;
emsg3 = malloc(sizeof(Edje_Message_String_Float));
emsg3->str = strdup(emsg2->str);
emsg3->val = emsg2->val;
msg = (unsigned char *)emsg3;
}
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));
Edje_Message_String_Int_Set *emsg2, *emsg3;
emsg2 = (Edje_Message_String_Int_Set *)emsg;
emsg3 = malloc(sizeof(Edje_Message_String_Int_Set) + ((emsg2->count - 1) * sizeof(int)));
emsg3->str = strdup(emsg2->str);
emsg3->count = emsg2->count;
for (i = 0; i < emsg3->count; i++)
emsg3->val[i] = emsg2->val[i];
msg = (unsigned char *)emsg3;
}
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));
Edje_Message_String_Float_Set *emsg2, *emsg3;
emsg2 = (Edje_Message_String_Float_Set *)emsg;
emsg3 = malloc(sizeof(Edje_Message_String_Float_Set) + ((emsg2->count - 1) * sizeof(double)));
emsg3->str = strdup(emsg2->str);
emsg3->count = emsg2->count;
for (i = 0; i < emsg3->count; i++)
emsg3->val[i] = emsg2->val[i];
msg = (unsigned char *)emsg3;
}
break;
default:
@ -234,8 +315,6 @@ _edje_message_send(Edje *ed, Edje_Queue queue, Edje_Message_Type type, int id, .
em->msg = msg;
msgq = evas_list_append(msgq, em);
va_end(args);
}
void
@ -261,11 +340,10 @@ _edje_message_process(Edje_Message *em)
void *pdata;
Embryo_Cell cell;
// embryo_parameter_string_push(em->edje->collection->script, sig);
/* first param is the message type - always */
cell = em->type;
embryo_parameter_cell_push(em->edje->collection->script, cell);
/* first param is the integer of the event id - always there */
/* 2nd 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);
@ -274,7 +352,6 @@ _edje_message_process(Edje_Message *em)
embryo_program_data_set(em->edje->collection->script, pdata);
}
}
/* call script fn */
break;
default:
break;
@ -287,11 +364,45 @@ _edje_message_process(Edje_Message *em)
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:
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, "message");
if (fn != EMBRYO_FUNCTION_NONE)
{
void *pdata;
Embryo_Cell cell;
/* first param is the message type - always */
cell = em->type;
embryo_parameter_cell_push(em->edje->collection->script, cell);
/* 2nd param is the integer of the event id - always there */
cell = em->id;
embryo_parameter_cell_push(em->edje->collection->script, cell);
/* 3rd param is the string */
embryo_parameter_string_push(em->edje->collection->script, em->msg);
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);
}
}
break;
default:
break;
}
break;
case EDJE_MESSAGE_INT:
break;
@ -319,23 +430,29 @@ _edje_message_process(Edje_Message *em)
void
_edje_message_queue_process(void)
{
int i;
if (msgq == NULL) return;
// printf("PROCESS\n");
/* a temporary message queue */
tmp_msgq = msgq;
msgq = NULL;
while (tmp_msgq)
/* allow the message queue to feed itself up to 8 times before forcing */
/* us to go back to normal processing and let a 0 timeout deal with it */
for (i = 0; (i < 8) && (msgq); i++)
{
Edje_Message *em;
/* a temporary message queue */
tmp_msgq = msgq;
msgq = NULL;
em = tmp_msgq->data;
tmp_msgq = evas_list_remove_list(tmp_msgq, tmp_msgq);
_edje_message_process(em);
_edje_message_free(em);
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)

3
legacy/edje/src/lib/edje_private.h
View File

@ -15,7 +15,6 @@
#include <math.h>
#include <fnmatch.h>
#include <stdarg.h>
#ifdef HAVE_ALLOCA_H
#include <alloca.h>
@ -131,7 +130,7 @@ 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_send(Edje *ed, Edje_Queue queue, Edje_Message_Type type, int id, void *emsg);
void _edje_message_process(Edje_Message *em);
void _edje_message_queue_process(void);
void _edje_message_queue_clear(void);

6
legacy/edje/src/lib/edje_program.c
View File

@ -727,8 +727,12 @@ _edje_program_run(Edje *ed, Edje_Program *pr, int force, char *ssig, char *ssrc)
void
_edje_emit(Edje *ed, char *sig, char *src)
{
Edje_Message_Signal emsg;
if (ed->delete_me) return;
_edje_message_send(ed, EDJE_QUEUE_APP, EDJE_MESSAGE_SIGNAL, 0, sig, src);
emsg.sig = sig;
emsg.src = src;
_edje_message_send(ed, EDJE_QUEUE_APP, EDJE_MESSAGE_SIGNAL, 0, &emsg);
}
/* FIXME: what if we delete the evas object??? */