gambas-source-code/main/gbx/gbx_event.c
Benoît Minisini cdcf6cdac9 [DEVELOPMENT ENVIRONMENT]
* BUG: Code indentation routine correctly handles structures now.

[INTERPRETER]
* NEW: Object.LastEventName has been deprecated, and replaced by 
  the Param.EventName property.
* BUG: IsFloat() is now a synonymous for IsNumber().
* BUG: Intrinsic functions description has been updated.

[COMPILER]
* NEW: "\e" is a new string escape sequence equivalent to "\x1B".

[GB.FORM]
* NEW: Use the new Control.Proxy property instead of internal observers
  inside compound controls (ValueBox, ButtonBox, MenuButton).

[GB.GTK]
* NEW: Control.Proxy is a new property that allows to define a control 
  proxy that will handle focus, key and mouse events in original control's 
  place.

[GB.QT4]
* NEW: Control.Proxy is a new property that allows to define a control 
  proxy that will handle focus, key and mouse events in original control's 
  place.


git-svn-id: svn://localhost/gambas/trunk@3387 867c0c6c-44f3-4631-809d-bfa615b0a4ec
2010-12-21 14:05:42 +00:00

257 lines
5.8 KiB
C

/***************************************************************************
gbx_event.c
(c) 2000-2009 Benoît Minisini <gambas@users.sourceforge.net>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
***************************************************************************/
#define __GBX_EVENT_C
#include "gb_common.h"
#include "gb_common_buffer.h"
#include "gbx_exec.h"
#include "gbx_api.h"
#include "gbx_event.h"
//#define DEBUG_ME 1
void *EVENT_Last = NULL;
char *EVENT_PreviousName = NULL;
char *EVENT_Name = NULL;
static EVENT_POST *_post_list = NULL;
static void check_event_method(CLASS *class, const char *name, CLASS_DESC_METHOD *desc, CLASS_EVENT *event)
{
if (event->n_param < desc->npmin)
{
/*printf("event->n_param = %d desc->npmin = %d desc->npmax = %d\n", event->n_param, desc->npmin, desc->npmax);*/
THROW(E_EVENT, class->name, name, "Too many arguments");
}
if (event->n_param > desc->npmax)
THROW(E_EVENT, class->name, name, "Not enough arguments");
if (TYPE_compare_signature(desc->signature, event->n_param, (TYPE *)event->param, event->n_param))
THROW(E_EVENT, class->name, name, "Type mismatch");
if (desc->type != T_VOID)
THROW(E_EVENT, class->name, name, "Not a procedure");
}
void EVENT_search(CLASS *class, ushort *event, const char *name, OBJECT *parent)
{
//ushort *event;
//ushort *self;
CLASS *class_parent;
int i, index;
const char *event_name;
CLASS_DESC *desc;
int kind;
char *func_name = COMMON_buffer;
#if DEBUG_ME
fprintf(stderr, "EVENT_search: class = %s name = %s parent = %p\n", class->name, name, parent);
#endif
//event = OBJECT_event(object)->event;
//self = OBJECT_event(object)->self;
if (class->n_event <= 0)
return;
if (!name)
{
memset(event, 0, class->n_event * sizeof(ushort));
return;
}
kind = parent->class == CLASS_Class ? CD_STATIC_METHOD : CD_METHOD;
if (kind == CD_STATIC_METHOD)
class_parent = (CLASS *)parent;
else
class_parent = parent->class;
for (i = 0; i < class->n_event; i++)
{
event[i] = 0;
event_name = class->event[i].name;
if (*event_name == ':')
event_name++;
snprintf(func_name, COMMON_BUF_MAX, "%s_%s", name, event_name);
index = CLASS_find_symbol(class_parent, func_name);
if (index != NO_SYMBOL)
{
desc = class_parent->table[index].desc;
if (CLASS_DESC_get_type(desc) == kind)
{
#if DEBUG_ME
fprintf(stderr, "EVENT_search: FOUND [%d] %s.%s index = %d parent = %s.%p\n", i, class_parent->name, func_name, index, parent->class->name, parent);
#endif
check_event_method(class_parent, func_name, &desc->method, &class->event[i]);
event[i] = index + 1;
}
}
#if 0
snprintf(func_name, COMMON_BUF_MAX, "ME_%s", event_name);
index = CLASS_find_symbol(class, func_name);
if (index != NO_SYMBOL)
{
desc = class->table[index].desc;
if (CLASS_DESC_get_type(desc) == CD_METHOD)
{
#if DEBUG_ME
printf("EVENT_search: FOUND [%d] %s.%s index = %d parent = %s.%p\n", i, class->name, func_name, index, parent->class->name, parent);
#endif
check_event_method(class, func_name, &desc->method, &class->event[i]);
if (!self)
{
ALLOC_ZERO(&self, sizeof(ushort) * class->n_event, "EVENT_search");
OBJECT_event(object)->self = self;
}
self[i] = index + 1;
}
}
#endif
}
}
void EVENT_exit()
{
EVENT_POST *ep;
while (_post_list)
{
ep = _post_list;
_post_list = _post_list->list.next;
FREE(&ep, "EVENT_exit");
}
STRING_free(&EVENT_Name);
}
static void post(void (*func)(), int nparam, intptr_t param, intptr_t param2)
{
EVENT_POST *ep;
/*printf("EVENT_post\n");
fflush(NULL);*/
ALLOC(&ep, sizeof(EVENT_POST), "EVENT_post");
ep->func = func;
ep->nparam = nparam;
ep->param = param;
ep->param2 = param2;
LIST_insert(&_post_list, ep, &ep->list);
HOOK(post)();
}
void EVENT_post(void (*func)(), intptr_t param)
{
post(func, 1, param, 0);
}
void EVENT_post2(void (*func)(), intptr_t param, intptr_t param2)
{
post(func, 2, param, param2);
}
static void post_event(void *object, int event)
{
GB_Raise(object, event, 0);
OBJECT_UNREF(object, "post_event");
}
void EVENT_post_event(void *object, int event)
{
/*if (!GB_CanRaise(object, event))
{
fprintf(stderr, "EVENT_post_event: cannot raise event\n");
return;
}*/
OBJECT_REF(object, "EVENT_post_event");
post((void (*)())post_event, 2, (intptr_t)object, (intptr_t)event);
}
bool EVENT_check_post(void)
{
EVENT_POST *ep;
EVENT_POST save;
bool ret = FALSE;
#ifdef DEBUG_POST
fprintf(stderr, "EVENT_check_post: START\n");
#endif
while (_post_list)
{
ret = TRUE;
ep = _post_list;
save = *ep;
LIST_remove(&_post_list, _post_list, &_post_list->list);
FREE(&ep, "EVENT_check_post");
if (save.nparam == 1)
(*save.func)(save.param);
else
(*save.func)(save.param, save.param2);
}
/*norec = FALSE;*/
#ifdef DEBUG_POST
fprintf(stderr, "EVENT_check_post: END\n");
#endif
return ret;
}
char *EVENT_enter_name(const char *name)
{
char *save = EVENT_PreviousName;
EVENT_PreviousName = EVENT_Name;
EVENT_Name = name;
return save;
}
void EVENT_leave_name(const char *save)
{
EVENT_Name = EVENT_PreviousName;
EVENT_PreviousName = save;
}