From 99a601a856a2bd6c9974db589b0ef3f54e04aeca Mon Sep 17 00:00:00 2001 From: John Mark Bell Date: Wed, 21 Dec 2011 22:18:10 +0000 Subject: Merge branches/jmb/dom-alloc-purge back to trunk svn path=/trunk/libdom/; revision=13316 --- src/events/Makefile | 2 +- src/events/custom_event.c | 18 +- src/events/custom_event.h | 6 +- src/events/dispatch.c | 296 +++++++++++++++ src/events/dispatch.h | 77 ++++ src/events/document_event.c | 9 +- src/events/event.c | 70 +--- src/events/event.h | 29 +- src/events/event_listener.c | 8 +- src/events/event_target.c | 710 ++++------------------------------- src/events/event_target.h | 67 ++-- src/events/keyboard_event.c | 23 +- src/events/keyboard_event.h | 6 +- src/events/mouse_event.c | 14 +- src/events/mouse_event.h | 3 +- src/events/mouse_multi_wheel_event.c | 13 +- src/events/mouse_multi_wheel_event.h | 2 +- src/events/mouse_wheel_event.c | 13 +- src/events/mouse_wheel_event.h | 3 +- src/events/mutation_event.c | 18 +- src/events/mutation_event.h | 6 +- src/events/mutation_name_event.c | 19 +- src/events/mutation_name_event.h | 6 +- src/events/text_event.c | 18 +- src/events/text_event.h | 6 +- src/events/ui_event.c | 18 +- src/events/ui_event.h | 6 +- 27 files changed, 615 insertions(+), 851 deletions(-) create mode 100644 src/events/dispatch.c create mode 100644 src/events/dispatch.h (limited to 'src/events') diff --git a/src/events/Makefile b/src/events/Makefile index 5b881b7..a842e2f 100644 --- a/src/events/Makefile +++ b/src/events/Makefile @@ -1,5 +1,5 @@ # Sources -DIR_SOURCES := event.c event_target.c document_event.c \ +DIR_SOURCES := event.c dispatch.c event_target.c document_event.c \ custom_event.c keyboard_event.c mouse_wheel_event.c \ text_event.c event_listener.c mouse_event.c mutation_event.c \ ui_event.c mouse_multi_wheel_event.c mutation_name_event.c diff --git a/src/events/custom_event.c b/src/events/custom_event.c index 99b4120..76d09bf 100644 --- a/src/events/custom_event.c +++ b/src/events/custom_event.c @@ -5,6 +5,8 @@ * Copyright 2009 Bo Yang */ +#include + #include "events/custom_event.h" #include "core/document.h" @@ -19,7 +21,7 @@ static struct dom_event_private_vtable _event_vtable = { dom_exception _dom_custom_event_create(struct dom_document *doc, struct dom_custom_event **evt) { - *evt = _dom_document_alloc(doc, NULL, sizeof(dom_custom_event)); + *evt = malloc(sizeof(dom_custom_event)); if (*evt == NULL) return DOM_NO_MEM_ERR; @@ -29,12 +31,11 @@ dom_exception _dom_custom_event_create(struct dom_document *doc, } /* Destructor */ -void _dom_custom_event_destroy(struct dom_document *doc, - struct dom_custom_event *evt) +void _dom_custom_event_destroy(struct dom_custom_event *evt) { - _dom_custom_event_finalise(doc, evt); + _dom_custom_event_finalise(evt); - _dom_document_alloc(doc, evt, 0); + free(evt); } /* Initialise function */ @@ -46,17 +47,16 @@ dom_exception _dom_custom_event_initialise(struct dom_document *doc, } /* Finalise function */ -void _dom_custom_event_finalise(struct dom_document *doc, - struct dom_custom_event *evt) +void _dom_custom_event_finalise(struct dom_custom_event *evt) { evt->detail = NULL; - _dom_event_finalise(doc, &evt->base); + _dom_event_finalise(&evt->base); } /* The virtual destroy function */ void _virtual_dom_custom_event_destroy(struct dom_event *evt) { - _dom_custom_event_destroy(evt->doc, (dom_custom_event *) evt); + _dom_custom_event_destroy((dom_custom_event *) evt); } /*----------------------------------------------------------------------*/ diff --git a/src/events/custom_event.h b/src/events/custom_event.h index a50bc23..ed5d624 100644 --- a/src/events/custom_event.h +++ b/src/events/custom_event.h @@ -22,15 +22,13 @@ dom_exception _dom_custom_event_create(struct dom_document *doc, struct dom_custom_event **evt); /* Destructor */ -void _dom_custom_event_destroy(struct dom_document *doc, - struct dom_custom_event *evt); +void _dom_custom_event_destroy(struct dom_custom_event *evt); /* Initialise function */ dom_exception _dom_custom_event_initialise(struct dom_document *doc, struct dom_custom_event *evt); /* Finalise function */ -void _dom_custom_event_finalise(struct dom_document *doc, - struct dom_custom_event *evt); +void _dom_custom_event_finalise(struct dom_custom_event *evt); #endif diff --git a/src/events/dispatch.c b/src/events/dispatch.c new file mode 100644 index 0000000..743cddc --- /dev/null +++ b/src/events/dispatch.c @@ -0,0 +1,296 @@ +/* + * This file is part of libdom. + * Licensed under the MIT License, + * http://www.opensource.org/licenses/mit-license.php + * Copyright 2009 Bo Yang + */ + +#include + +#include "events/dispatch.h" +#include "events/mutation_event.h" + +#include "utils/utils.h" + +/** + * Dispatch a DOMNodeInserted/DOMNodeRemoved event + * + * \param doc The document object + * \param et The EventTarget object + * \param type "DOMNodeInserted" or "DOMNodeRemoved" + * \param related The parent of the removed/inserted node + * \param success Whether this event's default action get called + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception __dom_dispatch_node_change_event(dom_document *doc, + dom_event_target *et, dom_event_target *related, + dom_mutation_type change, bool *success) +{ + struct dom_mutation_event *evt; + dom_string *type = NULL; + dom_exception err; + + err = _dom_mutation_event_create(doc, &evt); + if (err != DOM_NO_ERR) + return err; + + if (change == DOM_MUTATION_ADDITION) { + err = dom_string_create((const uint8_t *) "DOMNodeInserted", + SLEN("DOMNodeInserted"), &type); + if (err != DOM_NO_ERR) + goto cleanup; + } else if (change == DOM_MUTATION_REMOVAL) { + err = dom_string_create((const uint8_t *) "DOMNodeRemoval", + SLEN("DOMNodeRemoved"), &type); + if (err != DOM_NO_ERR) + goto cleanup; + } else { + assert("Should never be here" == NULL); + } + + /* Initialise the event with corresponding parameters */ + err = dom_mutation_event_init(evt, type, true, false, + related, NULL, NULL, NULL, change); + dom_string_unref(type); + if (err != DOM_NO_ERR) { + goto cleanup; + } + + err = dom_event_target_dispatch_event(et, evt, success); + if (err != DOM_NO_ERR) + goto cleanup; + +cleanup: + _dom_mutation_event_destroy(evt); + + return err; +} + +/** + * Dispatch a DOMNodeInsertedIntoDocument/DOMNodeRemovedFromDocument event + * + * \param doc The document object + * \param et The EventTarget object + * \param type "DOMNodeInserted" or "DOMNodeRemoved" + * \param success Whether this event's default action get called + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception __dom_dispatch_node_change_document_event(dom_document *doc, + dom_event_target *et, dom_mutation_type change, bool *success) +{ + struct dom_mutation_event *evt; + dom_string *type = NULL; + dom_exception err; + + err = _dom_mutation_event_create(doc, &evt); + if (err != DOM_NO_ERR) + return err; + + if (change == DOM_MUTATION_ADDITION) { + err = dom_string_create( + (const uint8_t *) + "DOMNodeInsertedIntoDocument", + SLEN("DOMNodeInsertedIntoDocument"), &type); + if (err != DOM_NO_ERR) + goto cleanup; + } else if (change == DOM_MUTATION_REMOVAL) { + err = dom_string_create( + (const uint8_t *) "DOMNodeRemovedFromDocument", + SLEN("DOMNodeRemovedFromDocument"), &type); + if (err != DOM_NO_ERR) + goto cleanup; + } else { + assert("Should never be here" == NULL); + } + + /* Initialise the event with corresponding parameters */ + err = dom_mutation_event_init(evt, type, true, false, NULL, + NULL, NULL, NULL, change); + dom_string_unref(type); + if (err != DOM_NO_ERR) + goto cleanup; + + err = dom_event_target_dispatch_event(et, evt, success); + if (err != DOM_NO_ERR) + goto cleanup; + +cleanup: + _dom_mutation_event_destroy(evt); + + return err; +} + +/** + * Dispatch a DOMAttrModified event + * + * \param doc The Document object + * \param et The EventTarget + * \param prev The previous value before change + * \param new The new value after change + * \param related The related EventTarget + * \param attr_name The Attribute name + * \param change How this attribute change + * \param success Whether this event's default handler get called + * \return DOM_NO_ERR on success, appropirate dom_exception on failure. + */ +dom_exception __dom_dispatch_attr_modified_event(dom_document *doc, + dom_event_target *et, dom_string *prev, dom_string *new, + dom_event_target *related, dom_string *attr_name, + dom_mutation_type change, bool *success) +{ + struct dom_mutation_event *evt; + dom_string *type = NULL; + dom_exception err; + + err = _dom_mutation_event_create(doc, &evt); + if (err != DOM_NO_ERR) + return err; + + err = dom_string_create((const uint8_t *) "DOMAttrModified", + SLEN("DOMAttrModified"), &type); + if (err != DOM_NO_ERR) + goto cleanup; + + /* Initialise the event with corresponding parameters */ + err = dom_mutation_event_init(evt, type, true, false, related, + prev, new, attr_name, change); + dom_string_unref(type); + if (err != DOM_NO_ERR) { + goto cleanup; + } + + err = dom_event_target_dispatch_event(et, evt, success); + +cleanup: + _dom_mutation_event_destroy(evt); + + return err; +} + +/** + * Dispatch a DOMCharacterDataModified event + * + * \param et The EventTarget object + * \param prev The preValue of the DOMCharacterData + * \param new The newValue of the DOMCharacterData + * \param success Whether this event's default handler get called + * \return DOM_NO_ERR on success, appropirate dom_exception on failure. + * + * TODO: + * The character_data object may be a part of a Attr node, if so, another + * DOMAttrModified event should be dispatched, too. But for now, we did not + * support any XML feature, so just leave it as this. + */ +dom_exception __dom_dispatch_characterdata_modified_event( + dom_document *doc, dom_event_target *et, + dom_string *prev, dom_string *new, bool *success) +{ + struct dom_mutation_event *evt; + dom_string *type = NULL; + dom_exception err; + + err = _dom_mutation_event_create(doc, &evt); + if (err != DOM_NO_ERR) + return err; + + err = dom_string_create((const uint8_t *) "DOMCharacterDataModified", + SLEN("DOMCharacterDataModified"), &type); + if (err != DOM_NO_ERR) + goto cleanup; + + err = dom_mutation_event_init(evt, type, true, false, et, prev, + new, NULL, DOM_MUTATION_MODIFICATION); + dom_string_unref(type); + if (err != DOM_NO_ERR) { + goto cleanup; + } + + err = dom_event_target_dispatch_event(et, evt, success); + +cleanup: + _dom_mutation_event_destroy(evt); + + return err; +} + +/** + * Dispatch a DOMSubtreeModified event + * + * \param doc The Document + * \param et The EventTarget object + * \param success Whether this event's default handler get called + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception __dom_dispatch_subtree_modified_event(dom_document *doc, + dom_event_target *et, bool *success) +{ + struct dom_mutation_event *evt; + dom_string *type = NULL; + dom_exception err; + + err = _dom_mutation_event_create(doc, &evt); + if (err != DOM_NO_ERR) + return err; + + err = dom_string_create((const uint8_t *) "DOMSubtreeModified", + SLEN("DOMSubtreeModified"), &type); + if (err != DOM_NO_ERR) + goto cleanup; + + err = dom_mutation_event_init(evt, type, true, false, et, NULL, + NULL, NULL, DOM_MUTATION_MODIFICATION); + dom_string_unref(type); + if (err != DOM_NO_ERR) { + goto cleanup; + } + + err = dom_event_target_dispatch_event(et, evt, success); + +cleanup: + _dom_mutation_event_destroy(evt); + + return err; +} + +/** + * Dispatch a generic event + * + * \param doc The Document + * \param et The EventTarget object + * \param name The name of the event + * \param len The length of the name string + * \param bubble Whether this event bubbles + * \param cancelable Whether this event can be cancelable + * \param success Whether this event's default handler get called + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_dispatch_generic_event(dom_document *doc, + dom_event_target *et, const uint8_t *name, size_t len, + bool bubble, bool cancelable, bool *success) +{ + struct dom_event *evt; + dom_string *type = NULL; + dom_exception err; + + err = _dom_event_create(doc, &evt); + if (err != DOM_NO_ERR) + return err; + + err = dom_string_create(name, len, &type); + if (err != DOM_NO_ERR) + goto cleanup; + + err = dom_event_init(evt, type, bubble, cancelable); + dom_string_unref(type); + if (err != DOM_NO_ERR) { + goto cleanup; + } + + err = dom_event_target_dispatch_event(et, evt, success); + +cleanup: + _dom_event_destroy(evt); + + return err; +} + diff --git a/src/events/dispatch.h b/src/events/dispatch.h new file mode 100644 index 0000000..632fc98 --- /dev/null +++ b/src/events/dispatch.h @@ -0,0 +1,77 @@ +/* + * This file is part of libdom. + * Licensed under the MIT License, + * http://www.opensource.org/licenses/mit-license.php + * Copyright 2009 Bo Yang + */ + +#ifndef dom_internal_events_dispatch_h_ +#define dom_internal_events_dispatch_h_ + +#include +#include +#include + +/* Dispatch a DOMNodeInserted/DOMNodeRemoved event */ +dom_exception __dom_dispatch_node_change_event(dom_document *doc, + dom_event_target *et, dom_event_target *related, + dom_mutation_type change, bool *success); +#define _dom_dispatch_node_change_event(doc, et, related, change, success) \ + __dom_dispatch_node_change_event((dom_document *) (doc), \ + (dom_event_target *) (et), \ + (dom_event_target *) (related), \ + (dom_mutation_type) (change), \ + (bool *) (success)) + +/* Dispatch a DOMNodeInsertedIntoDocument/DOMNodeRemovedFromDocument event */ +dom_exception __dom_dispatch_node_change_document_event(dom_document *doc, + dom_event_target *et, dom_mutation_type change, bool *success); +#define _dom_dispatch_node_change_document_event(doc, et, change, success) \ + __dom_dispatch_node_change_document_event((dom_document *) (doc), \ + (dom_event_target *) (et), \ + (dom_mutation_type) (change), \ + (bool *) (success)) + +/* Dispatch a DOMCharacterDataModified event */ +dom_exception __dom_dispatch_characterdata_modified_event( + dom_document *doc, dom_event_target *et, + dom_string *prev, dom_string *new, bool *success); +#define _dom_dispatch_characterdata_modified_event(doc, et, \ + prev, new, success) \ + __dom_dispatch_characterdata_modified_event((dom_document *) (doc), \ + (dom_event_target *) (et), \ + (dom_string *) (prev), \ + (dom_string *) (new), \ + (bool *) (success)) + +/* Dispatch a DOMAttrModified event */ +dom_exception __dom_dispatch_attr_modified_event(dom_document *doc, + dom_event_target *et, dom_string *prev, + dom_string *new, dom_event_target *related, + dom_string *attr_name, dom_mutation_type change, + bool *success); +#define _dom_dispatch_attr_modified_event(doc, et, prev, new, \ + related, attr_name, change, success) \ + __dom_dispatch_attr_modified_event((dom_document *) (doc), \ + (dom_event_target *) (et), \ + (dom_string *) (prev), \ + (dom_string *) (new), \ + (dom_event_target *) (related), \ + (dom_string *) (attr_name), \ + (dom_mutation_type) (change), \ + (bool *) (success)) + +/* Dispatch a DOMSubtreeModified event */ +dom_exception __dom_dispatch_subtree_modified_event(dom_document *doc, + dom_event_target *et, bool *success); +#define _dom_dispatch_subtree_modified_event(doc, et, success) \ + __dom_dispatch_subtree_modified_event((dom_document *) (doc), \ + (dom_event_target *) (et), \ + (bool *) (success)) + +/* Dispatch a generic event */ +dom_exception _dom_dispatch_generic_event(dom_document *doc, + dom_event_target *et, const uint8_t *name, size_t len, + bool bubble, bool cancelable, bool *success); + +#endif diff --git a/src/events/document_event.c b/src/events/document_event.c index 2b89152..a6f7081 100644 --- a/src/events/document_event.c +++ b/src/events/document_event.c @@ -97,12 +97,9 @@ dom_exception _dom_document_event_create_event(dom_document_event *de, dom_exception err; struct dom_document *doc = de; - dom_string_get_intern(type, &t); - if (t == NULL) { - err = _dom_string_intern(type, &t); - if (err != DOM_NO_ERR) - return err; - } + err = dom_string_intern(type, &t); + if (err != DOM_NO_ERR) + return err; assert(t != NULL); diff --git a/src/events/event.c b/src/events/event.c index 98bb0d5..8af111b 100644 --- a/src/events/event.c +++ b/src/events/event.c @@ -6,28 +6,26 @@ */ #include +#include #include #include "events/event.h" -#include - #include "core/string.h" #include "core/node.h" #include "core/document.h" #include "utils/utils.h" -static void _virtual_dom_event_destroy(struct dom_event *evt); +static void _virtual_dom_event_destroy(dom_event *evt); static struct dom_event_private_vtable _event_vtable = { _virtual_dom_event_destroy }; /* Constructor */ -dom_exception _dom_event_create(struct dom_document *doc, - struct dom_event **evt) +dom_exception _dom_event_create(dom_document *doc, dom_event **evt) { - *evt = (dom_event *) _dom_document_alloc(doc, NULL, sizeof(dom_event)); + *evt = (dom_event *) malloc(sizeof(dom_event)); if (*evt == NULL) return DOM_NO_MEM_ERR; @@ -37,16 +35,15 @@ dom_exception _dom_event_create(struct dom_document *doc, } /* Destructor */ -void _dom_event_destroy(struct dom_document *doc, struct dom_event *evt) +void _dom_event_destroy(dom_event *evt) { - _dom_event_finalise(doc, evt); + _dom_event_finalise(evt); - _dom_document_alloc(doc, evt, sizeof(dom_event)); + free(evt); } /* Initialise function */ -dom_exception _dom_event_initialise(struct dom_document *doc, - struct dom_event *evt) +dom_exception _dom_event_initialise(dom_document *doc, dom_event *evt) { assert(doc != NULL); @@ -67,14 +64,12 @@ dom_exception _dom_event_initialise(struct dom_document *doc, } /* Finalise function */ -void _dom_event_finalise(struct dom_document *doc, struct dom_event *evt) +void _dom_event_finalise(dom_event *evt) { - UNUSED(doc); - if (evt->type != NULL) - lwc_string_unref(evt->type); + dom_string_unref(evt->type); if (evt->namespace != NULL) - lwc_string_unref(evt->namespace); + dom_string_unref(evt->namespace); evt->stop = false; evt->stop_now = false; @@ -89,9 +84,9 @@ void _dom_event_finalise(struct dom_document *doc, struct dom_event *evt) } /* The virtual destroy function */ -void _virtual_dom_event_destroy(struct dom_event *evt) +void _virtual_dom_event_destroy(dom_event *evt) { - _dom_event_destroy(evt->doc, evt); + _dom_event_destroy(evt); } /*----------------------------------------------------------------------*/ @@ -131,12 +126,7 @@ void _dom_event_unref(dom_event *evt) */ dom_exception _dom_event_get_type(dom_event *evt, dom_string **type) { - struct dom_document *doc = evt->doc; - dom_exception err; - - err = _dom_document_create_string_from_lwcstring(doc, evt->type, type); - if (err != DOM_NO_ERR) - return err; + *type = dom_string_ref(evt->type); return DOM_NO_ERR; } @@ -249,14 +239,8 @@ dom_exception _dom_event_init(dom_event *evt, dom_string *type, bool bubble, bool cancelable) { assert(evt->doc != NULL); - lwc_string *str = NULL; - dom_exception err; - - err = _dom_string_intern(type, &str); - if (err != DOM_NO_ERR) - return err; - evt->type = str; + evt->type = dom_string_ref(type); evt->bubble = bubble; evt->cancelable = cancelable; @@ -275,13 +259,7 @@ dom_exception _dom_event_init(dom_event *evt, dom_string *type, dom_exception _dom_event_get_namespace(dom_event *evt, dom_string **namespace) { - struct dom_document *doc = evt->doc; - dom_exception err; - - err = _dom_document_create_string_from_lwcstring(doc, evt->namespace, - namespace); - if (err != DOM_NO_ERR) - return err; + *namespace = dom_string_ref(evt->namespace); return DOM_NO_ERR; } @@ -341,18 +319,10 @@ dom_exception _dom_event_init_ns(dom_event *evt, dom_string *namespace, dom_string *type, bool bubble, bool cancelable) { assert(evt->doc != NULL); - lwc_string *str = NULL; - dom_exception err; - - err = _dom_string_intern(type, &str); - if (err != DOM_NO_ERR) - return err; - evt->type = str; - - err = _dom_string_intern(namespace, &str); - if (err != DOM_NO_ERR) - return err; - evt->namespace = str; + + evt->type = dom_string_ref(type); + + evt->namespace = dom_string_ref(namespace); evt->bubble = bubble; evt->cancelable = cancelable; diff --git a/src/events/event.h b/src/events/event.h index 4d094e9..fa3d6b9 100644 --- a/src/events/event.h +++ b/src/events/event.h @@ -10,24 +10,22 @@ #include +#include #include #include #include "utils/list.h" -struct lwc_string_s; -struct dom_document; - /* The private virtual table */ struct dom_event_private_vtable { void (*destroy)(dom_event *evt); }; /** - * The Event Ojbect + * The Event Object */ struct dom_event { - struct lwc_string_s *type; /**< The type of the event */ + dom_string *type; /**< The type of the event */ dom_event_target *target; /**< The event target */ dom_event_target *current; /**< The current event target */ dom_event_flow_phase phase; /**< The event phase */ @@ -36,11 +34,10 @@ struct dom_event { unsigned int timestamp; /**< The timestamp this event is created */ - struct lwc_string_s *namespace; - /**< The namespace of this event */ + dom_string *namespace; /**< The namespace of this event */ - struct dom_document *doc; - /**< The document which create this event */ + dom_document *doc; + /**< The document which created this event */ bool stop; /**< Whether stopPropagation is called */ bool stop_now; /**< Whether stopImmediatePropagation is called */ @@ -57,25 +54,23 @@ struct dom_event { }; /* Constructor */ -dom_exception _dom_event_create(struct dom_document *doc, - struct dom_event **evt); +dom_exception _dom_event_create(dom_document *doc, dom_event **evt); /* Destructor */ -void _dom_event_destroy(struct dom_document *doc, struct dom_event *evt); +void _dom_event_destroy(dom_event *evt); /* Initialise function */ -dom_exception _dom_event_initialise(struct dom_document *doc, - struct dom_event *evt); +dom_exception _dom_event_initialise(dom_document *doc, dom_event *evt); /* Finalise function */ -void _dom_event_finalise(struct dom_document *doc, struct dom_event *evt); +void _dom_event_finalise(dom_event *evt); -static inline void dom_event_destroy(struct dom_event *evt) +static inline void dom_event_destroy(dom_event *evt) { evt->vtable->destroy(evt); } -#define dom_event_destroy(e) dom_event_destroy((struct dom_event *) (e)) +#define dom_event_destroy(e) dom_event_destroy((dom_event *) (e)) #endif diff --git a/src/events/event_listener.c b/src/events/event_listener.c index 3c3c14c..cbb12f0 100644 --- a/src/events/event_listener.c +++ b/src/events/event_listener.c @@ -5,6 +5,8 @@ * Copyright 2009 Bo Yang */ +#include + #include "events/event_listener.h" #include "core/document.h" @@ -20,8 +22,7 @@ dom_exception dom_event_listener_create(struct dom_document *doc, handle_event handler, void *pw, dom_event_listener **listener) { - dom_event_listener *ret = (dom_event_listener *) _dom_document_alloc( - doc, NULL, sizeof(dom_event_listener)); + dom_event_listener *ret = malloc(sizeof(dom_event_listener)); if (ret == NULL) return DOM_NO_MEM_ERR; @@ -56,7 +57,6 @@ void dom_event_listener_unref(dom_event_listener *listener) listener->refcnt--; if (listener->refcnt == 0) - _dom_document_alloc(listener->doc, listener, - sizeof(dom_event_listener)); + free(listener); } diff --git a/src/events/event_target.c b/src/events/event_target.c index 6bf5458..c4a2f90 100644 --- a/src/events/event_target.c +++ b/src/events/event_target.c @@ -6,8 +6,7 @@ */ #include - -#include +#include #include "events/event.h" #include "events/event_listener.h" @@ -23,36 +22,74 @@ /* The number of chains in the hash table used for hash event types */ #define CHAINS 11 -/* Entry for a EventTarget, used to record the bubbling list */ -typedef struct dom_event_target_entry { - struct list_entry entry; /**< The list entry */ - dom_event_target *et; /**< The node */ -} dom_event_target_entry; +static uint32_t event_target_hash(void *key, void *pw) +{ + UNUSED(pw); + + return dom_string_hash(key); +} + +static void event_target_destroy_key(void *key, void *pw) +{ + UNUSED(pw); + + dom_string_unref(key); +} + +static void event_target_destroy_value(void *value, void *pw) +{ + struct listener_entry *le = NULL; + struct list_entry *i = (struct list_entry *) value; + + UNUSED(pw); + + while (i != i->next) { + le = (struct listener_entry *) i->next; + list_del(i->next); + dom_event_listener_unref(le->listener); + free(le); + } + + le = (struct listener_entry *) i; + list_del(i); + dom_event_listener_unref(le->listener); + free(le); +} + +static bool event_target_key_isequal(void *key1, void *key2, void *pw) +{ + UNUSED(pw); -/* Hash key/value functions */ -static void *_key(void *key, void *key_pw, dom_alloc alloc, void *pw, - bool clone); -static void *_value(void *value, void *value_pw, dom_alloc alloc, - void *pw, bool clone); + return dom_string_isequal(key1, key2); +} +static const dom_hash_vtable event_target_vtable = { + event_target_hash, + NULL, + event_target_destroy_key, + NULL, + event_target_destroy_value, + event_target_key_isequal +}; /* Initialise this EventTarget */ -dom_exception _dom_event_target_internal_initialise(struct dom_document *doc, +dom_exception _dom_event_target_internal_initialise( dom_event_target_internal *eti) { - UNUSED(doc); - eti->listeners = NULL; + eti->listeners = _dom_hash_create(CHAINS, &event_target_vtable, NULL); + if (eti->listeners == NULL) + return DOM_NO_MEM_ERR; + eti->ns_listeners = NULL; return DOM_NO_ERR; } /* Finalise this EventTarget */ -void _dom_event_target_internal_finalise(struct dom_document *doc, - dom_event_target_internal *eti) +void _dom_event_target_internal_finalise(dom_event_target_internal *eti) { - if (eti->listeners != NULL) - _dom_hash_destroy(eti->listeners, _key, NULL, _value, doc); + _dom_hash_destroy(eti->listeners); + /* TODO: Now, we did not support the EventListener with namespace, * when we support it, we should deal with the ns_listeners hash * table, too. @@ -71,42 +108,15 @@ void _dom_event_target_internal_finalise(struct dom_document *doc, * \param capture Whether add this listener in the capturing phase * \return DOM_NO_ERR on success, appropriate dom_exception on failure. */ -dom_exception _dom_event_target_add_event_listener(dom_event_target *et, +dom_exception _dom_event_target_add_event_listener( + dom_event_target_internal *eti, dom_string *type, struct dom_event_listener *listener, bool capture) { struct listener_entry *le = NULL; - struct dom_document *doc = dom_node_get_owner(et); - assert(doc != NULL); - - struct dom_event_target_internal *eti = &et->eti; - lwc_string *t = NULL; - dom_exception err; - - /* If there is no hash table, we should create one firstly */ - if (eti->listeners == NULL) { - err = _dom_document_create_hashtable(doc, CHAINS, - _dom_hash_hash_lwcstring, &eti->listeners); - if (err != DOM_NO_ERR) - return err; - } - - err = dom_string_get_intern(type, &t); - if (err != DOM_NO_ERR) - return err; - - if (t == NULL) { - err = _dom_string_intern(type, &t); - if (err != DOM_NO_ERR) - return err; - } else { - lwc_string_ref(t); - } - - assert(t != NULL); + dom_string *t = NULL; - le = (struct listener_entry *) _dom_document_alloc(doc, NULL, - sizeof(struct listener_entry)); + le = malloc(sizeof(struct listener_entry)); if (le == NULL) return DOM_NO_MEM_ERR; @@ -116,6 +126,8 @@ dom_exception _dom_event_target_add_event_listener(dom_event_target *et, dom_event_listener_ref(listener); le->capture = capture; + t = dom_string_ref(type); + /* Find the type of this event */ struct list_entry *item = (struct list_entry *) _dom_hash_get( eti->listeners, t); @@ -140,42 +152,18 @@ dom_exception _dom_event_target_add_event_listener(dom_event_target *et, * \param capture Whether the listener is registered at the capturing phase * \return DOM_NO_ERR on success, appropriate dom_exception on failure. */ -dom_exception _dom_event_target_remove_event_listener(dom_event_target *et, +dom_exception _dom_event_target_remove_event_listener( + dom_event_target_internal *eti, dom_string *type, struct dom_event_listener *listener, bool capture) { struct listener_entry *le = NULL; - struct dom_document *doc = dom_node_get_owner(et); - if (doc == NULL) { - /* TODO: In the progress of parsing, many Nodes in the DTD - * has no document at all, do nothing for this kind of node */ - return DOM_NO_ERR; - } - - struct dom_event_target_internal *eti = &et->eti; - lwc_string *t = NULL; - dom_exception err; - - err = dom_string_get_intern(type, &t); - if (err != DOM_NO_ERR) - return err; - - if (t == NULL) { - err = _dom_string_intern(type, &t); - if (err != DOM_NO_ERR) - return err; - } else { - lwc_string_ref(t); - } - - assert(t != NULL); /* Find the type of this event */ struct list_entry *item = (struct list_entry *) _dom_hash_get( - eti->listeners, t); + eti->listeners, type); if (item == NULL) { /* There is no such event listener */ - lwc_string_unref(t); return DOM_NO_ERR; } else { struct list_entry *i = item; @@ -186,8 +174,7 @@ dom_exception _dom_event_target_remove_event_listener(dom_event_target *et, /* We found the listener */ list_del(i); dom_event_listener_unref(le->listener); - _dom_document_alloc(doc, le, - sizeof(struct listener_entry)); + free(le); break; } i = i->next; @@ -197,185 +184,6 @@ dom_exception _dom_event_target_remove_event_listener(dom_event_target *et, return DOM_NO_ERR; } -/** - * Dispatch an event into the implementation's event model - * - * \param et The EventTarget object - * \param evt The event object - * \param success Indicates whether any of the listeners which handled the - * event called Event.preventDefault(). If - * Event.preventDefault() was called the returned value is - * false, else it is true. - * \return DOM_NO_ERR on success - * DOM_DISPATCH_REQUEST_ERR If the event is already in dispatch - * DOM_UNSPECIFIED_EVENT_TYPE_ERR If the type of the event is Null or - * empty string. - * DOM_NOT_SUPPORTED_ERR If the event is not created by - * Document.createEvent - * DOM_INVALID_CHARACTER_ERR If the type of this event is not a - * valid NCName. - */ -dom_exception _dom_event_target_dispatch_event(dom_event_target *et, - struct dom_event *evt, bool *success) -{ - assert(et != NULL); - assert(evt != NULL); - - dom_exception err, ret = DOM_NO_ERR; - - /* To test whether this event is in dispatch */ - if (evt->in_dispatch == true) { - return DOM_DISPATCH_REQUEST_ERR; - } else { - evt->in_dispatch = true; - } - - if (evt->type == NULL || lwc_string_length(evt->type) == 0) { - return DOM_UNSPECIFIED_EVENT_TYPE_ERR; - } - - if (evt->doc == NULL) - return DOM_NOT_SUPPORTED_ERR; - - struct dom_document *doc = dom_node_get_owner(et); - if (doc == NULL) { - /* TODO: In the progress of parsing, many Nodes in the DTD has - * no document at all, do nothing for this kind of node */ - return DOM_NO_ERR; - } - - dom_string *type = NULL; - err = _dom_document_create_string_from_lwcstring(doc, evt->type, &type); - if (err != DOM_NO_ERR) - return err; - - if (_dom_validate_ncname(type) == false) { - dom_string_unref(type); - return DOM_INVALID_CHARACTER_ERR; - } - dom_string_unref(type); - - dom_event_target_entry list; - dom_event_target *target = et; - - *success = true; - - /* Compose the event target list */ - list_init(&list.entry); - list.et = et; - dom_node_ref(et); - target = target->parent; - - while (target != NULL) { - dom_event_target_entry *l = (dom_event_target_entry *) - _dom_document_alloc(doc, NULL, - sizeof(dom_event_target_entry)); - if (l == NULL) { - ret = DOM_NO_MEM_ERR; - goto cleanup; - } - list_append(&list.entry, &l->entry); - l->et = target; - dom_node_ref(target); - target = target->parent; - } - - /* Fill the target of the event */ - evt->target = et; - evt->phase = DOM_CAPTURING_PHASE; - - /* The started callback of default action */ - struct dom_document_event_internal *dei = &doc->dei; - void *pw = NULL; - if (dei->actions != NULL) { - dom_default_action_callback cb = dei->actions(evt->type, - DOM_DEFAULT_ACTION_STARTED, &pw); - if (cb != NULL) { - cb(evt, pw); - } - } - - /* The capture phase */ - struct list_entry *e = list.entry.prev; - for (; e != &list.entry; e = e->prev) { - dom_event_target_entry *l = (dom_event_target_entry *) e; - err = _dom_event_target_dispatch(l->et, evt, - DOM_CAPTURING_PHASE, success); - if (err != DOM_NO_ERR) { - ret = err; - goto cleanup; - } - /* If the stopImmediatePropagation or stopPropagation is - * called, we should break */ - if (evt->stop_now == true || evt->stop == true) - goto cleanup; - } - - /* Target phase */ - evt->phase = DOM_AT_TARGET; - evt->current = et; - err = _dom_event_target_dispatch(et, evt, DOM_AT_TARGET, - success); - if (evt->stop_now == true || evt->stop == true) - goto cleanup; - - /* Bubbling phase */ - evt->phase = DOM_BUBBLING_PHASE; - - e = list.entry.next; - for (; e != &list.entry; e = e->next) { - dom_event_target_entry *l = (dom_event_target_entry *) e; - err = _dom_event_target_dispatch(l->et, evt, - DOM_BUBBLING_PHASE, success); - if (err != DOM_NO_ERR) { - ret = err; - goto cleanup; - } - /* If the stopImmediatePropagation or stopPropagation is - * called, we should break */ - if (evt->stop_now == true || evt->stop == true) - goto cleanup; - } - - if (dei->actions == NULL) - goto cleanup; - - /* The end callback of default action */ - if (evt->prevent_default != true) { - dom_default_action_callback cb = dei->actions(evt->type, - DOM_DEFAULT_ACTION_END, &pw); - if (cb != NULL) { - cb(evt, pw); - } - } - - /* The prevented callback of default action */ - if (evt->prevent_default != true) { - dom_default_action_callback cb = dei->actions(evt->type, - DOM_DEFAULT_ACTION_PREVENTED, &pw); - if (cb != NULL) { - cb(evt, pw); - } - } - -cleanup: - if (evt->prevent_default == true) { - *success = false; - } - - while (list.entry.next != &list.entry) { - dom_event_target_entry *e = (dom_event_target_entry *) - list.entry.next; - dom_node_unref(e->et); - list_del(list.entry.next); - _dom_document_alloc(doc, e, 0); - } - - dom_node_unref(et); - - return ret; -} - /** * Add an EventListener * @@ -388,11 +196,12 @@ cleanup: * * We don't support this API now, so it always return DOM_NOT_SUPPORTED_ERR. */ -dom_exception _dom_event_target_add_event_listener_ns(dom_event_target *et, +dom_exception _dom_event_target_add_event_listener_ns( + dom_event_target_internal *eti, dom_string *namespace, dom_string *type, struct dom_event_listener *listener, bool capture) { - UNUSED(et); + UNUSED(eti); UNUSED(namespace); UNUSED(type); UNUSED(listener); @@ -413,11 +222,12 @@ dom_exception _dom_event_target_add_event_listener_ns(dom_event_target *et, * * We don't support this API now, so it always return DOM_NOT_SUPPORTED_ERR. */ -dom_exception _dom_event_target_remove_event_listener_ns(dom_event_target *et, +dom_exception _dom_event_target_remove_event_listener_ns( + dom_event_target_internal *eti, dom_string *namespace, dom_string *type, struct dom_event_listener *listener, bool capture) { - UNUSED(et); + UNUSED(eti); UNUSED(namespace); UNUSED(type); UNUSED(listener); @@ -428,61 +238,11 @@ dom_exception _dom_event_target_remove_event_listener_ns(dom_event_target *et, /*-------------------------------------------------------------------------*/ -/* The key process function of the hash table, see utils/hash_table.h for - * detail */ -static void *_key(void *key, void *key_pw, dom_alloc alloc, void *pw, - bool clone) -{ - UNUSED(key_pw); - UNUSED(alloc); - UNUSED(pw); - /* There should never be the requirement of clone the event listener - * list */ - assert(clone == false); - UNUSED(clone); - - lwc_string_unref((lwc_string *) key); - - return NULL; -} - -/* The value process function of the hash table, see utils/hash_table.h for - * detail */ -static void *_value(void *value, void *value_pw, dom_alloc alloc, - void *pw, bool clone) -{ - UNUSED(alloc); - UNUSED(pw); - /* There should never be the requirement of clone the event listener - * list */ - assert(clone == false); - UNUSED(clone); - - struct listener_entry *le = NULL; - struct dom_document *doc = (struct dom_document *) value_pw; - struct list_entry *i = (struct list_entry *) value; - - while(i != i->next) { - le = (struct listener_entry *) i->next; - list_del(i->next); - dom_event_listener_unref(le->listener); - _dom_document_alloc(doc, le, sizeof(struct listener_entry)); - } - - le = (struct listener_entry *) i; - list_del(i); - dom_event_listener_unref(le->listener); - _dom_document_alloc(doc, le, sizeof(struct listener_entry)); - - return NULL; -} - -/*-------------------------------------------------------------------------*/ - /** * Dispatch an event on certain EventTarget * * \param et The EventTarget object + * \param eti Internal EventTarget object * \param evt The event object * \param success Indicates whether any of the listeners which handled the * event called Event.preventDefault(). If @@ -490,12 +250,12 @@ static void *_value(void *value, void *value_pw, dom_alloc alloc, * false, else it is true. * \return DOM_NO_ERR on success, appropriate dom_exception on failure. */ -dom_exception _dom_event_target_dispatch(dom_event_target *et, +dom_exception _dom_event_target_dispatch(dom_event_target *et, + dom_event_target_internal *eti, struct dom_event *evt, dom_event_flow_phase phase, bool *success) { - struct dom_event_target_internal *eti = &et->eti; - lwc_string *t = evt->type; + dom_string *t = evt->type; struct list_entry *item = (struct list_entry *) _dom_hash_get( eti->listeners, t); @@ -535,321 +295,3 @@ dom_exception _dom_event_target_dispatch(dom_event_target *et, return DOM_NO_ERR; } -/** - * Dispatch a DOMNodeInserted/DOMNodeRemoved event - * - * \param doc The document object - * \param et The EventTarget object - * \param type "DOMNodeInserted" or "DOMNodeRemoved" - * \param related The parent of the removed/inserted node - * \param success Whether this event's default action get called - * \return DOM_NO_ERR on success, appropriate dom_exception on failure. - */ -dom_exception _dom_dispatch_node_change_event(struct dom_document *doc, - dom_event_target *et, dom_event_target *related, - dom_mutation_type change, bool *success) -{ - struct dom_mutation_event *evt; - dom_exception err; - - err = _dom_mutation_event_create(doc, &evt); - if (err != DOM_NO_ERR) - return err; - - lwc_string *type = NULL; - if (change == DOM_MUTATION_ADDITION) { - err = _dom_document_create_lwcstring(doc, - (const uint8_t *) "DOMNodeInserted", - SLEN("DOMNodeInserted"), &type); - if (err != DOM_NO_ERR) - goto cleanup; - } else if (change == DOM_MUTATION_REMOVAL) { - err = _dom_document_create_lwcstring(doc, - (const uint8_t *) "DOMNodeRemoval", - SLEN("DOMNodeRemoved"), &type); - if (err != DOM_NO_ERR) - goto cleanup; - } else { - assert("Should never be here" == NULL); - } - - dom_string *t = NULL; - err = _dom_document_create_string_from_lwcstring(doc, type, &t); - _dom_document_unref_lwcstring(doc, type); - if (err != DOM_NO_ERR) - goto cleanup; - - /* Initiliase the event with corresponding parameters */ - err = dom_mutation_event_init(evt, t, true, false, related, NULL, NULL, - NULL, change); - dom_string_unref(t); - if (err != DOM_NO_ERR) { - goto cleanup; - } - - err = dom_event_target_dispatch_event(et, evt, success); - if (err != DOM_NO_ERR) - goto cleanup; - - /* Finalise the evt, and reuse it */ - _dom_mutation_event_finalise(doc, evt); - /* Dispatch the DOMNodeInsertedIntoDocument/DOMNodeRemovedFromDocument - * event */ - if (change == DOM_MUTATION_ADDITION) { - err = _dom_document_create_lwcstring(doc, - (const uint8_t *) - "DOMNodeInsertedIntoDocument", - SLEN("DOMNodeInsertedIntoDocument"), &type); - if (err != DOM_NO_ERR) - goto cleanup; - } else if (change == DOM_MUTATION_REMOVAL) { - err = _dom_document_create_lwcstring(doc, - (const uint8_t *) "DOMNodeRemovedFromDocument", - SLEN("DOMNodeRemovedFromDocument"), &type); - if (err != DOM_NO_ERR) - goto cleanup; - } else { - assert("Should never be here" == NULL); - } - - err = _dom_document_create_string_from_lwcstring(doc, type, &t); - _dom_document_unref_lwcstring(doc, type); - if (err != DOM_NO_ERR) - goto cleanup; - - /* Dispatch the events for its children */ - dom_event_target *target = et->first_child; - while (target != NULL) { - err = dom_mutation_event_init(evt, t, true, false, NULL, - NULL, NULL, NULL, change); - if (err != DOM_NO_ERR) - goto cleanup; - - err = dom_event_target_dispatch_event(target, evt, success); - if (err != DOM_NO_ERR) - goto cleanup; - - dom_event_target *p = dom_node_get_parent(target); - if (target->first_child != NULL) { - target = target->first_child; - } else if (target->next != NULL) { - target = target->next; - } else { - while (p != et && target == p->last_child) { - target = p; - p = dom_node_get_parent(p); - } - - target = target->next; - } - /* Finalise the event for reuse in next iteration */ - _dom_mutation_event_finalise(doc, evt); - } - -cleanup: - _dom_mutation_event_destroy(doc, evt); - - return err; -} - -/** - * Dispatch a DOMAttrModified event - * - * \param doc The Document object - * \param et The EventTarget - * \param prev The previous value before change - * \param new The new value after change - * \param related The related EventTarget - * \param attr_name The Attribute name - * \param change How this attribute change - * \param success Whether this event's default handler get called - * \return DOM_NO_ERR on success, appropirate dom_exception on failure. - */ -dom_exception _dom_dispatch_attr_modified_event(struct dom_document *doc, - dom_event_target *et, dom_string *prev, dom_string *new, - dom_event_target *related, dom_string *attr_name, - dom_mutation_type change, bool *success) -{ - struct dom_mutation_event *evt; - dom_exception err; - - err = _dom_mutation_event_create(doc, &evt); - if (err != DOM_NO_ERR) - return err; - - lwc_string *type = NULL; - err = _dom_document_create_lwcstring(doc, - (const uint8_t *) "DOMAttrModified", - SLEN("DOMAttrModified"), &type); - if (err != DOM_NO_ERR) - goto cleanup; - - dom_string *t = NULL; - err = _dom_document_create_string_from_lwcstring(doc, type, &t); - _dom_document_unref_lwcstring(doc, type); - if (err != DOM_NO_ERR) - goto cleanup; - - /* Initiliase the event with corresponding parameters */ - err = dom_mutation_event_init(evt, t, true, false, related, prev, new, - attr_name, change); - dom_string_unref(t); - if (err != DOM_NO_ERR) { - goto cleanup; - } - - err = dom_event_target_dispatch_event(et, evt, success); - -cleanup: - _dom_mutation_event_destroy(doc, evt); - - return err; -} - -/** - * Dispatch a DOMCharacterDataModified event - * - * \param et The EventTarget object - * \param prev The preValue of the DOMCharacterData - * \param new The newValue of the DOMCharacterData - * \param success Whether this event's default handler get called - * \return DOM_NO_ERR on success, appropirate dom_exception on failure. - * - * TODO: - * The character_data object may be a part of a Attr node, if so, another - * DOMAttrModified event should be dispatched, too. But for now, we did not - * support any XML feature, so just leave it as this. - */ -dom_exception _dom_dispatch_characterdata_modified_event( - struct dom_document *doc, dom_event_target *et, - dom_string *prev, dom_string *new, bool *success) -{ - struct dom_mutation_event *evt; - dom_exception err; - - err = _dom_mutation_event_create(doc, &evt); - if (err != DOM_NO_ERR) - return err; - - lwc_string *type = NULL; - err = _dom_document_create_lwcstring(doc, - (const uint8_t *) "DOMCharacterDataModified", - SLEN("DOMCharacterDataModified"), &type); - if (err != DOM_NO_ERR) - goto cleanup; - - dom_string *t = NULL; - err = _dom_document_create_string_from_lwcstring(doc, type, &t); - _dom_document_unref_lwcstring(doc, type); - if (err != DOM_NO_ERR) - goto cleanup; - - err = dom_mutation_event_init(evt, t, true, false, et, prev, new, NULL, - DOM_MUTATION_MODIFICATION); - dom_string_unref(t); - if (err != DOM_NO_ERR) { - goto cleanup; - } - - err = dom_event_target_dispatch_event(et, evt, success); - -cleanup: - _dom_mutation_event_destroy(doc, evt); - - return err; -} - -/** - * Dispatch a DOMSubtreeModified event - * - * \param doc The Document - * \param et The EventTarget object - * \param success Whether this event's default handler get called - * \return DOM_NO_ERR on success, appropriate dom_exception on failure. - */ -dom_exception _dom_dispatch_subtree_modified_event(struct dom_document *doc, - dom_event_target *et, bool *success) -{ - struct dom_mutation_event *evt; - dom_exception err; - - err = _dom_mutation_event_create(doc, &evt); - if (err != DOM_NO_ERR) - return err; - - lwc_string *type = NULL; - err = _dom_document_create_lwcstring(doc, - (const uint8_t *) "DOMSubtreeModified", - SLEN("DOMSubtreeModified"), &type); - if (err != DOM_NO_ERR) - goto cleanup; - - dom_string *t = NULL; - err = _dom_document_create_string_from_lwcstring(doc, type, &t); - _dom_document_unref_lwcstring(doc, type); - if (err != DOM_NO_ERR) - goto cleanup; - - err = dom_mutation_event_init(evt, t, true, false, et, NULL, NULL, NULL, - DOM_MUTATION_MODIFICATION); - dom_string_unref(t); - if (err != DOM_NO_ERR) { - goto cleanup; - } - - err = dom_event_target_dispatch_event(et, evt, success); - -cleanup: - _dom_mutation_event_destroy(doc, evt); - - return err; -} - -/** - * Dispatch a generic event - * - * \param doc The Document - * \param et The EventTarget object - * \param name The name of the event - * \param len The length of the name string - * \param bubble Whether this event bubbles - * \param cancelable Whether this event can be cancelable - * \param success Whether this event's default handler get called - * \return DOM_NO_ERR on success, appropriate dom_exception on failure. - */ -dom_exception _dom_dispatch_generic_event(struct dom_document *doc, - dom_event_target *et, const uint8_t *name, size_t len, - bool bubble, bool cancelable, bool *success) -{ - struct dom_event *evt; - dom_exception err; - - err = _dom_event_create(doc, &evt); - if (err != DOM_NO_ERR) - return err; - - lwc_string *type = NULL; - err = _dom_document_create_lwcstring(doc, name, len, &type); - if (err != DOM_NO_ERR) - goto cleanup; - - dom_string *t = NULL; - err = _dom_document_create_string_from_lwcstring(doc, type, &t); - _dom_document_unref_lwcstring(doc, type); - if (err != DOM_NO_ERR) - goto cleanup; - - err = dom_event_init(evt, t, bubble, cancelable); - dom_string_unref(t); - if (err != DOM_NO_ERR) { - goto cleanup; - } - - err = dom_event_target_dispatch_event(et, evt, success); - -cleanup: - _dom_event_destroy(doc, evt); - - return err; -} - diff --git a/src/events/event_target.h b/src/events/event_target.h index 78808e3..fad39d6 100644 --- a/src/events/event_target.h +++ b/src/events/event_target.h @@ -8,16 +8,17 @@ #ifndef dom_internal_events_event_target_h_ #define dom_internal_events_event_target_h_ +#include #include #include #include #include +#include "events/dispatch.h" + #include "utils/list.h" #include "utils/hashtable.h" -struct dom_document; - /** * Listener Entry */ @@ -44,6 +45,12 @@ struct dom_event_target_internal { typedef struct dom_event_target_internal dom_event_target_internal; +/* Entry for a EventTarget, used to record the bubbling list */ +typedef struct dom_event_target_entry { + struct list_entry entry; /**< The list entry */ + dom_event_target *et; /**< The node */ +} dom_event_target_entry; + /** * Constructor and destructor: Since this object is not intended to be * allocated alone, it should be embedded into the Node object, there is @@ -51,41 +58,35 @@ typedef struct dom_event_target_internal dom_event_target_internal; */ /* Initialise this EventTarget */ -dom_exception _dom_event_target_internal_initialise(struct dom_document *doc, +dom_exception _dom_event_target_internal_initialise( dom_event_target_internal *eti); /* Finalise this EventTarget */ -void _dom_event_target_internal_finalise(struct dom_document *doc, - dom_event_target_internal *eti); - -/* Dispatch the event on this node */ -dom_exception _dom_event_target_dispatch(dom_event_target *et, +void _dom_event_target_internal_finalise(dom_event_target_internal *eti); + +dom_exception _dom_event_target_add_event_listener( + dom_event_target_internal *eti, + dom_string *type, struct dom_event_listener *listener, + bool capture); + +dom_exception _dom_event_target_remove_event_listener( + dom_event_target_internal *eti, + dom_string *type, struct dom_event_listener *listener, + bool capture); + +dom_exception _dom_event_target_add_event_listener_ns( + dom_event_target_internal *eti, + dom_string *namespace, dom_string *type, + struct dom_event_listener *listener, bool capture); + +dom_exception _dom_event_target_remove_event_listener_ns( + dom_event_target_internal *eti, + dom_string *namespace, dom_string *type, + struct dom_event_listener *listener, bool capture); + +dom_exception _dom_event_target_dispatch(dom_event_target *et, + dom_event_target_internal *eti, struct dom_event *evt, dom_event_flow_phase phase, bool *success); -/* Dispatch a DOMNodeInserted/DOMNodeRemoved event */ -dom_exception _dom_dispatch_node_change_event(struct dom_document *doc, - dom_event_target *et, dom_event_target *related, - dom_mutation_type change, bool *success); - -/* Dispatch a DOMCharacterDataModified event */ -dom_exception _dom_dispatch_characterdata_modified_event( - struct dom_document *doc, dom_event_target *et, - dom_string *prev, dom_string *new, bool *success); - -/* Dispatch a DOMAttrModified event */ -dom_exception _dom_dispatch_attr_modified_event(struct dom_document *doc, - dom_event_target *et, dom_string *prev, - dom_string *new, dom_event_target *related, - dom_string *attr_name, dom_mutation_type change, - bool *success); - -/* Dispatch a DOMSubtreeModified event */ -dom_exception _dom_dispatch_subtree_modified_event(struct dom_document *doc, - dom_event_target *et, bool *success); - -/* Dispatch a generic event */ -dom_exception _dom_dispatch_generic_event(struct dom_document *doc, - dom_event_target *et, const uint8_t *name, size_t len, - bool bubble, bool cancelable, bool *success); #endif diff --git a/src/events/keyboard_event.c b/src/events/keyboard_event.c index 3e3b141..72b6215 100644 --- a/src/events/keyboard_event.c +++ b/src/events/keyboard_event.c @@ -5,6 +5,7 @@ * Copyright 2009 Bo Yang */ +#include #include #include "events/keyboard_event.h" @@ -22,7 +23,7 @@ static struct dom_event_private_vtable _event_vtable = { dom_exception _dom_keyboard_event_create(struct dom_document *doc, struct dom_keyboard_event **evt) { - *evt = _dom_document_alloc(doc, NULL, sizeof(dom_keyboard_event)); + *evt = malloc(sizeof(dom_keyboard_event)); if (*evt == NULL) return DOM_NO_MEM_ERR; @@ -32,12 +33,11 @@ dom_exception _dom_keyboard_event_create(struct dom_document *doc, } /* Destructor */ -void _dom_keyboard_event_destroy(struct dom_document *doc, - struct dom_keyboard_event *evt) +void _dom_keyboard_event_destroy(struct dom_keyboard_event *evt) { - _dom_keyboard_event_finalise(doc, evt); + _dom_keyboard_event_finalise(evt); - _dom_document_alloc(doc, evt, 0); + free(evt); } /* Initialise function */ @@ -51,16 +51,15 @@ dom_exception _dom_keyboard_event_initialise(struct dom_document *doc, } /* Finalise function */ -void _dom_keyboard_event_finalise(struct dom_document *doc, - struct dom_keyboard_event *evt) +void _dom_keyboard_event_finalise(struct dom_keyboard_event *evt) { - _dom_ui_event_finalise(doc, &evt->base); + _dom_ui_event_finalise(&evt->base); } /* The virtual destroy function */ void _virtual_dom_keyboard_event_destroy(struct dom_event *evt) { - _dom_keyboard_event_destroy(evt->doc, (dom_keyboard_event *) evt); + _dom_keyboard_event_destroy((dom_keyboard_event *) evt); } /*----------------------------------------------------------------------*/ @@ -179,7 +178,7 @@ dom_exception _dom_keyboard_event_get_modifier_state(dom_keyboard_event *evt, } const char *data = _dom_string_data(m); - size_t len = _dom_string_length(m); + size_t len = _dom_string_byte_length(m); if (len == SLEN("AltGraph") && strncmp(data, "AltGraph", len) == 0) { *state = ((evt->modifier_state & DOM_MOD_ALT_GRAPH) != 0); @@ -292,8 +291,8 @@ dom_exception _dom_parse_modifier_list(dom_string *modifier_list, if (modifier_list == NULL) return DOM_NO_ERR; - char *data = _dom_string_data(modifier_list); - char *m = data; + const char *data = _dom_string_data(modifier_list); + const char *m = data; size_t len = 0; while (true) { diff --git a/src/events/keyboard_event.h b/src/events/keyboard_event.h index a988efc..b51518f 100644 --- a/src/events/keyboard_event.h +++ b/src/events/keyboard_event.h @@ -36,16 +36,14 @@ dom_exception _dom_keyboard_event_create(struct dom_document *doc, struct dom_keyboard_event **evt); /* Destructor */ -void _dom_keyboard_event_destroy(struct dom_document *doc, - struct dom_keyboard_event *evt); +void _dom_keyboard_event_destroy(struct dom_keyboard_event *evt); /* Initialise function */ dom_exception _dom_keyboard_event_initialise(struct dom_document *doc, struct dom_keyboard_event *evt); /* Finalise function */ -void _dom_keyboard_event_finalise(struct dom_document *doc, - struct dom_keyboard_event *evt); +void _dom_keyboard_event_finalise(struct dom_keyboard_event *evt); /* Parse the modifier list string to corresponding bool variable state */ diff --git a/src/events/mouse_event.c b/src/events/mouse_event.c index 7f61343..501ef69 100644 --- a/src/events/mouse_event.c +++ b/src/events/mouse_event.c @@ -5,6 +5,7 @@ * Copyright 2009 Bo Yang */ +#include #include #include "events/mouse_event.h" @@ -22,7 +23,7 @@ static struct dom_event_private_vtable _event_vtable = { dom_exception _dom_mouse_event_create(struct dom_document *doc, struct dom_mouse_event **evt) { - *evt = _dom_document_alloc(doc, NULL, sizeof(dom_mouse_event)); + *evt = malloc(sizeof(dom_mouse_event)); if (*evt == NULL) return DOM_NO_MEM_ERR; @@ -32,12 +33,11 @@ dom_exception _dom_mouse_event_create(struct dom_document *doc, } /* Destructor */ -void _dom_mouse_event_destroy(struct dom_document *doc, - struct dom_mouse_event *evt) +void _dom_mouse_event_destroy(struct dom_mouse_event *evt) { - _dom_mouse_event_finalise(doc, (dom_ui_event *) evt); + _dom_mouse_event_finalise((dom_ui_event *) evt); - _dom_document_alloc(doc, evt, 0); + free(evt); } /* Initialise function */ @@ -52,7 +52,7 @@ dom_exception _dom_mouse_event_initialise(struct dom_document *doc, /* The virtual destroy function */ void _virtual_dom_mouse_event_destroy(struct dom_event *evt) { - _dom_mouse_event_destroy(evt->doc, (dom_mouse_event *) evt); + _dom_mouse_event_destroy((dom_mouse_event *) evt); } /*----------------------------------------------------------------------*/ @@ -230,7 +230,7 @@ dom_exception _dom_mouse_event_get_modifier_state(dom_mouse_event *evt, } const char *data = _dom_string_data(m); - size_t len = _dom_string_length(m); + size_t len = _dom_string_byte_length(m); if (len == SLEN("AltGraph") && strncmp(data, "AltGraph", len) == 0) { *state = ((evt->modifier_state & DOM_MOD_ALT_GRAPH) != 0); diff --git a/src/events/mouse_event.h b/src/events/mouse_event.h index f5117a1..85246e7 100644 --- a/src/events/mouse_event.h +++ b/src/events/mouse_event.h @@ -34,8 +34,7 @@ dom_exception _dom_mouse_event_create(struct dom_document *doc, struct dom_mouse_event **evt); /* Destructor */ -void _dom_mouse_event_destroy(struct dom_document *doc, - struct dom_mouse_event *evt); +void _dom_mouse_event_destroy(struct dom_mouse_event *evt); /* Initialise function */ dom_exception _dom_mouse_event_initialise(struct dom_document *doc, diff --git a/src/events/mouse_multi_wheel_event.c b/src/events/mouse_multi_wheel_event.c index 6eccdab..2923a4c 100644 --- a/src/events/mouse_multi_wheel_event.c +++ b/src/events/mouse_multi_wheel_event.c @@ -5,6 +5,8 @@ * Copyright 2009 Bo Yang */ +#include + #include "events/mouse_multi_wheel_event.h" #include "events/keyboard_event.h" #include "core/document.h" @@ -22,8 +24,7 @@ static struct dom_event_private_vtable _event_vtable = { dom_exception _dom_mouse_multi_wheel_event_create(struct dom_document *doc, struct dom_mouse_multi_wheel_event **evt) { - *evt = _dom_document_alloc(doc, NULL, - sizeof(dom_mouse_multi_wheel_event)); + *evt = malloc(sizeof(dom_mouse_multi_wheel_event)); if (*evt == NULL) return DOM_NO_MEM_ERR; @@ -33,12 +34,12 @@ dom_exception _dom_mouse_multi_wheel_event_create(struct dom_document *doc, } /* Destructor */ -void _dom_mouse_multi_wheel_event_destroy(struct dom_document *doc, +void _dom_mouse_multi_wheel_event_destroy( struct dom_mouse_multi_wheel_event *evt) { - _dom_mouse_multi_wheel_event_finalise(doc, (dom_ui_event *) evt); + _dom_mouse_multi_wheel_event_finalise((dom_ui_event *) evt); - _dom_document_alloc(doc, evt, 0); + free(evt); } /* Initialise function */ @@ -51,7 +52,7 @@ dom_exception _dom_mouse_multi_wheel_event_initialise(struct dom_document *doc, /* The virtual destroy function */ void _virtual_dom_mouse_multi_wheel_event_destroy(struct dom_event *evt) { - _dom_mouse_multi_wheel_event_destroy(evt->doc, + _dom_mouse_multi_wheel_event_destroy( (dom_mouse_multi_wheel_event *) evt); } diff --git a/src/events/mouse_multi_wheel_event.h b/src/events/mouse_multi_wheel_event.h index 043efb8..9b854c9 100644 --- a/src/events/mouse_multi_wheel_event.h +++ b/src/events/mouse_multi_wheel_event.h @@ -28,7 +28,7 @@ dom_exception _dom_mouse_multi_wheel_event_create(struct dom_document *doc, struct dom_mouse_multi_wheel_event **evt); /* Destructor */ -void _dom_mouse_multi_wheel_event_destroy(struct dom_document *doc, +void _dom_mouse_multi_wheel_event_destroy( struct dom_mouse_multi_wheel_event *evt); /* Initialise function */ diff --git a/src/events/mouse_wheel_event.c b/src/events/mouse_wheel_event.c index c2ae111..acc65cf 100644 --- a/src/events/mouse_wheel_event.c +++ b/src/events/mouse_wheel_event.c @@ -5,6 +5,8 @@ * Copyright 2009 Bo Yang */ +#include + #include "events/mouse_wheel_event.h" #include "events/keyboard_event.h" #include "core/document.h" @@ -21,7 +23,7 @@ static struct dom_event_private_vtable _event_vtable = { dom_exception _dom_mouse_wheel_event_create(struct dom_document *doc, struct dom_mouse_wheel_event **evt) { - *evt = _dom_document_alloc(doc, NULL, sizeof(dom_mouse_wheel_event)); + *evt = malloc(sizeof(dom_mouse_wheel_event)); if (*evt == NULL) return DOM_NO_MEM_ERR; @@ -32,12 +34,11 @@ dom_exception _dom_mouse_wheel_event_create(struct dom_document *doc, } /* Destructor */ -void _dom_mouse_wheel_event_destroy(struct dom_document *doc, - struct dom_mouse_wheel_event *evt) +void _dom_mouse_wheel_event_destroy(struct dom_mouse_wheel_event *evt) { - _dom_mouse_wheel_event_finalise(doc, (dom_ui_event *) evt); + _dom_mouse_wheel_event_finalise((dom_ui_event *) evt); - _dom_document_alloc(doc, evt, 0); + free(evt); } /* Initialise function */ @@ -50,7 +51,7 @@ dom_exception _dom_mouse_wheel_event_initialise(struct dom_document *doc, /* The virtual destroy function */ void _virtual_dom_mouse_wheel_event_destroy(struct dom_event *evt) { - _dom_mouse_wheel_event_destroy(evt->doc, (dom_mouse_wheel_event *) evt); + _dom_mouse_wheel_event_destroy((dom_mouse_wheel_event *) evt); } /*----------------------------------------------------------------------*/ diff --git a/src/events/mouse_wheel_event.h b/src/events/mouse_wheel_event.h index ba613e5..9247d4a 100644 --- a/src/events/mouse_wheel_event.h +++ b/src/events/mouse_wheel_event.h @@ -26,8 +26,7 @@ dom_exception _dom_mouse_wheel_event_create(struct dom_document *doc, struct dom_mouse_wheel_event **evt); /* Destructor */ -void _dom_mouse_wheel_event_destroy(struct dom_document *doc, - struct dom_mouse_wheel_event *evt); +void _dom_mouse_wheel_event_destroy(struct dom_mouse_wheel_event *evt); /* Initialise function */ dom_exception _dom_mouse_wheel_event_initialise(struct dom_document *doc, diff --git a/src/events/mutation_event.c b/src/events/mutation_event.c index ecc9794..aeeefe7 100644 --- a/src/events/mutation_event.c +++ b/src/events/mutation_event.c @@ -5,6 +5,8 @@ * Copyright 2009 Bo Yang */ +#include + #include "events/mutation_event.h" #include "core/document.h" @@ -18,7 +20,7 @@ static struct dom_event_private_vtable _event_vtable = { dom_exception _dom_mutation_event_create(struct dom_document *doc, struct dom_mutation_event **evt) { - *evt = _dom_document_alloc(doc, NULL, sizeof(dom_mutation_event)); + *evt = malloc(sizeof(dom_mutation_event)); if (*evt == NULL) return DOM_NO_MEM_ERR; @@ -28,12 +30,11 @@ dom_exception _dom_mutation_event_create(struct dom_document *doc, } /* Destructor */ -void _dom_mutation_event_destroy(struct dom_document *doc, - struct dom_mutation_event *evt) +void _dom_mutation_event_destroy(struct dom_mutation_event *evt) { - _dom_mutation_event_finalise(doc, evt); + _dom_mutation_event_finalise(evt); - _dom_document_alloc(doc, evt, 0); + free(evt); } /* Initialise function */ @@ -49,8 +50,7 @@ dom_exception _dom_mutation_event_initialise(struct dom_document *doc, } /* Finalise function */ -void _dom_mutation_event_finalise(struct dom_document *doc, - struct dom_mutation_event *evt) +void _dom_mutation_event_finalise(struct dom_mutation_event *evt) { dom_node_unref(evt->related_node); dom_string_unref(evt->prev_value); @@ -62,13 +62,13 @@ void _dom_mutation_event_finalise(struct dom_document *doc, evt->new_value = NULL; evt->attr_name = NULL; - _dom_event_finalise(doc, &evt->base); + _dom_event_finalise(&evt->base); } /* The virtual destroy function */ void _virtual_dom_mutation_event_destroy(struct dom_event *evt) { - _dom_mutation_event_destroy(evt->doc, (dom_mutation_event *) evt); + _dom_mutation_event_destroy((dom_mutation_event *) evt); } /*----------------------------------------------------------------------*/ diff --git a/src/events/mutation_event.h b/src/events/mutation_event.h index 58ae9fb..142e18c 100644 --- a/src/events/mutation_event.h +++ b/src/events/mutation_event.h @@ -30,16 +30,14 @@ dom_exception _dom_mutation_event_create(struct dom_document *doc, struct dom_mutation_event **evt); /* Destructor */ -void _dom_mutation_event_destroy(struct dom_document *doc, - struct dom_mutation_event *evt); +void _dom_mutation_event_destroy(struct dom_mutation_event *evt); /* Initialise function */ dom_exception _dom_mutation_event_initialise(struct dom_document *doc, struct dom_mutation_event *evt); /* Finalise function */ -void _dom_mutation_event_finalise(struct dom_document *doc, - struct dom_mutation_event *evt); +void _dom_mutation_event_finalise(struct dom_mutation_event *evt); #endif diff --git a/src/events/mutation_name_event.c b/src/events/mutation_name_event.c index d7c14e4..c5c9345 100644 --- a/src/events/mutation_name_event.c +++ b/src/events/mutation_name_event.c @@ -5,6 +5,8 @@ * Copyright 2009 Bo Yang */ +#include + #include "events/mutation_name_event.h" #include "core/document.h" @@ -20,7 +22,7 @@ static struct dom_event_private_vtable _event_vtable = { dom_exception _dom_mutation_name_event_create(struct dom_document *doc, struct dom_mutation_name_event **evt) { - *evt = _dom_document_alloc(doc, NULL, sizeof(dom_mutation_name_event)); + *evt = malloc(sizeof(dom_mutation_name_event)); if (*evt == NULL) return DOM_NO_MEM_ERR; @@ -30,12 +32,11 @@ dom_exception _dom_mutation_name_event_create(struct dom_document *doc, } /* Destructor */ -void _dom_mutation_name_event_destroy(struct dom_document *doc, - struct dom_mutation_name_event *evt) +void _dom_mutation_name_event_destroy(struct dom_mutation_name_event *evt) { - _dom_mutation_name_event_finalise(doc, evt); + _dom_mutation_name_event_finalise(evt); - _dom_document_alloc(doc, evt, 0); + free(evt); } /* Initialise function */ @@ -49,20 +50,18 @@ dom_exception _dom_mutation_name_event_initialise(struct dom_document *doc, } /* Finalise function */ -void _dom_mutation_name_event_finalise(struct dom_document *doc, - struct dom_mutation_name_event *evt) +void _dom_mutation_name_event_finalise(struct dom_mutation_name_event *evt) { dom_string_unref(evt->prev_namespace); dom_string_unref(evt->prev_nodename); - _dom_event_finalise(doc, (dom_event *) evt); + _dom_event_finalise((dom_event *) evt); } /* The virtual destroy function */ void _virtual_dom_mutation_name_event_destroy(struct dom_event *evt) { - _dom_mutation_name_event_destroy(evt->doc, - (dom_mutation_name_event *) evt); + _dom_mutation_name_event_destroy((dom_mutation_name_event *) evt); } /*----------------------------------------------------------------------*/ diff --git a/src/events/mutation_name_event.h b/src/events/mutation_name_event.h index 94b35a2..8849059 100644 --- a/src/events/mutation_name_event.h +++ b/src/events/mutation_name_event.h @@ -27,16 +27,14 @@ dom_exception _dom_mutation_name_event_create(struct dom_document *doc, struct dom_mutation_name_event **evt); /* Destructor */ -void _dom_mutation_name_event_destroy(struct dom_document *doc, - struct dom_mutation_name_event *evt); +void _dom_mutation_name_event_destroy(struct dom_mutation_name_event *evt); /* Initialise function */ dom_exception _dom_mutation_name_event_initialise(struct dom_document *doc, struct dom_mutation_name_event *evt); /* Finalise function */ -void _dom_mutation_name_event_finalise(struct dom_document *doc, - struct dom_mutation_name_event *evt); +void _dom_mutation_name_event_finalise(struct dom_mutation_name_event *evt); #endif diff --git a/src/events/text_event.c b/src/events/text_event.c index 591da57..67b5c99 100644 --- a/src/events/text_event.c +++ b/src/events/text_event.c @@ -5,6 +5,8 @@ * Copyright 2009 Bo Yang */ +#include + #include "events/text_event.h" #include "core/document.h" @@ -18,7 +20,7 @@ static struct dom_event_private_vtable _event_vtable = { dom_exception _dom_text_event_create(struct dom_document *doc, struct dom_text_event **evt) { - *evt = _dom_document_alloc(doc, NULL, sizeof(dom_text_event)); + *evt = malloc(sizeof(dom_text_event)); if (*evt == NULL) return DOM_NO_MEM_ERR; @@ -28,12 +30,11 @@ dom_exception _dom_text_event_create(struct dom_document *doc, } /* Destructor */ -void _dom_text_event_destroy(struct dom_document *doc, - struct dom_text_event *evt) +void _dom_text_event_destroy(struct dom_text_event *evt) { - _dom_text_event_finalise(doc, evt); + _dom_text_event_finalise(evt); - _dom_document_alloc(doc, evt, 0); + free(evt); } /* Initialise function */ @@ -45,17 +46,16 @@ dom_exception _dom_text_event_initialise(struct dom_document *doc, } /* Finalise function */ -void _dom_text_event_finalise(struct dom_document *doc, - struct dom_text_event *evt) +void _dom_text_event_finalise(struct dom_text_event *evt) { dom_string_unref(evt->data); - _dom_ui_event_finalise(doc, &evt->base); + _dom_ui_event_finalise(&evt->base); } /* The virtual destroy function */ void _virtual_dom_text_event_destroy(struct dom_event *evt) { - _dom_text_event_destroy(evt->doc, (dom_text_event *) evt); + _dom_text_event_destroy((dom_text_event *) evt); } /*----------------------------------------------------------------------*/ diff --git a/src/events/text_event.h b/src/events/text_event.h index a50bf32..8d9f063 100644 --- a/src/events/text_event.h +++ b/src/events/text_event.h @@ -25,16 +25,14 @@ dom_exception _dom_text_event_create(struct dom_document *doc, struct dom_text_event **evt); /* Destructor */ -void _dom_text_event_destroy(struct dom_document *doc, - struct dom_text_event *evt); +void _dom_text_event_destroy(struct dom_text_event *evt); /* Initialise function */ dom_exception _dom_text_event_initialise(struct dom_document *doc, struct dom_text_event *evt); /* Finalise function */ -void _dom_text_event_finalise(struct dom_document *doc, - struct dom_text_event *evt); +void _dom_text_event_finalise(struct dom_text_event *evt); #endif diff --git a/src/events/ui_event.c b/src/events/ui_event.c index 0be2980..0082332 100644 --- a/src/events/ui_event.c +++ b/src/events/ui_event.c @@ -5,6 +5,8 @@ * Copyright 2009 Bo Yang */ +#include + #include "events/ui_event.h" #include "core/document.h" @@ -18,7 +20,7 @@ static struct dom_event_private_vtable _event_vtable = { dom_exception _dom_ui_event_create(struct dom_document *doc, struct dom_ui_event **evt) { - *evt = _dom_document_alloc(doc, NULL, sizeof(dom_ui_event)); + *evt = malloc(sizeof(dom_ui_event)); if (*evt == NULL) return DOM_NO_MEM_ERR; @@ -28,12 +30,11 @@ dom_exception _dom_ui_event_create(struct dom_document *doc, } /* Destructor */ -void _dom_ui_event_destroy(struct dom_document *doc, - struct dom_ui_event *evt) +void _dom_ui_event_destroy(struct dom_ui_event *evt) { - _dom_ui_event_finalise(doc, evt); + _dom_ui_event_finalise(evt); - _dom_document_alloc(doc, evt, 0); + free(evt); } /* Initialise function */ @@ -45,17 +46,16 @@ dom_exception _dom_ui_event_initialise(struct dom_document *doc, } /* Finalise function */ -void _dom_ui_event_finalise(struct dom_document *doc, - struct dom_ui_event *evt) +void _dom_ui_event_finalise(struct dom_ui_event *evt) { evt->view = NULL; - _dom_event_finalise(doc, &evt->base); + _dom_event_finalise(&evt->base); } /* The virtual destroy function */ void _virtual_dom_ui_event_destroy(struct dom_event *evt) { - _dom_ui_event_destroy(evt->doc, (dom_ui_event *) evt); + _dom_ui_event_destroy((dom_ui_event *) evt); } /*----------------------------------------------------------------------*/ diff --git a/src/events/ui_event.h b/src/events/ui_event.h index 3a245ab..d90f6d7 100644 --- a/src/events/ui_event.h +++ b/src/events/ui_event.h @@ -40,15 +40,13 @@ dom_exception _dom_ui_event_create(struct dom_document *doc, struct dom_ui_event **evt); /* Destructor */ -void _dom_ui_event_destroy(struct dom_document *doc, - struct dom_ui_event *evt); +void _dom_ui_event_destroy(struct dom_ui_event *evt); /* Initialise function */ dom_exception _dom_ui_event_initialise(struct dom_document *doc, struct dom_ui_event *evt); /* Finalise function */ -void _dom_ui_event_finalise(struct dom_document *doc, - struct dom_ui_event *evt); +void _dom_ui_event_finalise(struct dom_ui_event *evt); #endif -- cgit v1.2.3