Merge branches/jmb/dom-alloc-purge back to trunk

svn path=/trunk/libdom/; revision=13316

27 files changed, 615 insertions, 851 deletions

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 <struggleyb.nku@gmail.com>
  */
 
+#include <stdlib.h>
+
 #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 <struggleyb.nku@gmail.com>
+ */
+
+#include <assert.h>
+
+#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 <struggleyb.nku@gmail.com>
+ */
+
+#ifndef dom_internal_events_dispatch_h_
+#define dom_internal_events_dispatch_h_
+
+#include <dom/core/document.h>
+#include <dom/events/event.h>
+#include <dom/events/mutation_event.h>
+
+/* 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 <assert.h>
+#include <stdlib.h>
 #include <time.h>
 
 #include "events/event.h"
 
-#include <libwapcaplet/libwapcaplet.h>
-
 #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 <inttypes.h>
 
+#include <dom/core/document.h>
 #include <dom/events/event_target.h>
 #include <dom/events/event.h>
 
 #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 <struggleyb.nku@gmail.com>
  */
 
+#include <stdlib.h>
+
 #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 <assert.h>
-
-#include <libwapcaplet/libwapcaplet.h>
+#include <stdlib.h>
 
 #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;
@@ -198,185 +185,6 @@ dom_exception _dom_event_target_remove_event_listener(dom_event_target *et,
 }
 
 /**
- * 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
  *
  * \param et         The EventTarget object
@@ -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 <dom/core/document.h>
 #include <dom/events/event.h>
 #include <dom/events/mutation_event.h>
 #include <dom/events/event_target.h>
 #include <dom/events/event_listener.h>
 
+#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 <struggleyb.nku@gmail.com>
  */
 
+#include <stdlib.h>
 #include <string.h>
 
 #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 <struggleyb.nku@gmail.com>
  */
 
+#include <stdlib.h>
 #include <string.h>
 
 #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 <struggleyb.nku@gmail.com>
  */
 
+#include <stdlib.h>
+
 #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 <struggleyb.nku@gmail.com>
  */
 
+#include <stdlib.h>
+
 #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 <struggleyb.nku@gmail.com>
  */
 
+#include <stdlib.h>
+
 #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 <struggleyb.nku@gmail.com>
  */
 
+#include <stdlib.h>
+
 #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 <struggleyb.nku@gmail.com>
  */
 
+#include <stdlib.h>
+
 #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 <struggleyb.nku@gmail.com>
  */
 
+#include <stdlib.h>
+
 #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