* Copyright 2012 Vincent Sanders <firstname.lastname@example.org>
* This file is part of NetSurf, http://www.netsurf-browser.org/
* NetSurf is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; version 2 of the License.
* NetSurf is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
* In order to try and be moderately performant, we create a heap
* per browser window. This heap is shared by all browsing contexts
* we end up creating in that window.
typedef struct jsheap jsheap;
* When we create a browsing context itself (window+content) we have
* to create a JS thread to attach to the browsing context.
* JS threads are associated with heaps and will be destroyed when
* the heap is destroyed. They can be shut down manually though
* and should be for object lifetime safety reasons.
typedef struct jsthread jsthread;
* There is usually one heap per browser window.
* \param timeout elapsed wallclock time (in seconds) before \a callback is called
* \param heap Updated to the created JS heap
* \return NSERROR_OK on success, appropriate error otherwise.
nserror js_newheap(int timeout, jsheap **heap);
* Destroy a previously created heap.
* \param heap The heap to destroy
void js_destroyheap(jsheap *heap);
* it. It constructs a fresh global window object and prepares the JS
* browsing context. It's important that threads are shut down cleanly
* when the browsing context is going to be cleaned up.
* \param heap The heap to create the thread within
* \param win_priv The value to give to the Window constructor as the window
* \param doc_priv The value to give to the Document constructor as the document
* \param thread Updated to the created thread
* \return NSERROR_OK on success, appropriate error otherwise
nserror js_newthread(jsheap *heap, void *win_priv, void *doc_priv, jsthread **thread);
* This should be called when the browsing context is done with the thread.
* Essentially it should be called when the content is about to be destroyed
* but in reality it can be called when the browser window relinquishes its
* handle on the content since nominally the browser window itself owns
* the thread.
* \param thread The thread to be destroyed
void js_destroythread(jsthread *thread);
bool js_exec(jsthread *thread, const uint8_t *txt, size_t txtlen, const char *name);
* fire an event at a dom node
bool js_fire_event(jsthread *thread, const char *type, struct dom_document *doc, struct dom_node *target);
struct dom_document *document,
struct dom_node *node,
struct dom_string *event_type_dom,
/*** New Events ***/
* Handle a new element being created.
* This is called once an element is inserted into the DOM document handled
* by the context provided. The JS implementation must then scan the element
* for on* attributes and register appropriate listeners for those handlers.
void js_handle_new_element(jsthread *thread, struct dom_element *node);
* Handle an event propagation finished callback.
* This is called once an event finishes propagating, no matter how it
* finishes. The intent here is that the JS context can perform any cleanups
* it may need to perform before the DOM finishes and the event may end up
void js_event_cleanup(jsthread *thread, struct dom_event *evt);