Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1. /*
  2.  * This file is part of libdom.
  3.  * Licensed under the MIT License,
  4.  *                http://www.opensource.org/licenses/mit-license.php
  5.  * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com>
  6.  */
  7.  
  8. #include <assert.h>
  9.  
  10. #include "core/document.h"
  11. #include "events/dispatch.h"
  12. #include "events/mutation_event.h"
  13.  
  14. #include "utils/utils.h"
  15.  
  16. /**
  17.  * Dispatch a DOMNodeInserted/DOMNodeRemoved event
  18.  *
  19.  * \param doc      The document object
  20.  * \param et       The EventTarget object
  21.  * \param type     "DOMNodeInserted" or "DOMNodeRemoved"
  22.  * \param related  The parent of the removed/inserted node
  23.  * \param success  Whether this event's default action get called
  24.  * \return DOM_NO_ERR on success, appropriate dom_exception on failure.
  25.  */
  26. dom_exception __dom_dispatch_node_change_event(dom_document *doc,
  27.                 dom_event_target *et, dom_event_target *related,
  28.                 dom_mutation_type change, bool *success)
  29. {
  30.         struct dom_mutation_event *evt;
  31.         dom_string *type = NULL;
  32.         dom_exception err;
  33.  
  34.         err = _dom_mutation_event_create(doc, &evt);
  35.         if (err != DOM_NO_ERR)
  36.                 return err;
  37.        
  38.         if (change == DOM_MUTATION_ADDITION) {
  39.                 type = dom_string_ref(doc->_memo_domnodeinserted);
  40.         } else if (change == DOM_MUTATION_REMOVAL) {
  41.                 type = dom_string_ref(doc->_memo_domnoderemoved);
  42.         } else {
  43.                 assert("Should never be here" == NULL);
  44.         }
  45.  
  46.         /* Initialise the event with corresponding parameters */
  47.         err = dom_mutation_event_init(evt, type, true, false,
  48.                         related, NULL, NULL, NULL, change);
  49.         dom_string_unref(type);
  50.         if (err != DOM_NO_ERR) {
  51.                 goto cleanup;
  52.         }
  53.  
  54.         err = dom_event_target_dispatch_event(et, evt, success);
  55.         if (err != DOM_NO_ERR)
  56.                 goto cleanup;
  57.        
  58. cleanup:
  59.         _dom_mutation_event_destroy(evt);
  60.  
  61.         return err;
  62. }
  63.  
  64. /**
  65.  * Dispatch a DOMNodeInsertedIntoDocument/DOMNodeRemovedFromDocument event
  66.  *
  67.  * \param doc      The document object
  68.  * \param et       The EventTarget object
  69.  * \param type     "DOMNodeInserted" or "DOMNodeRemoved"
  70.  * \param success  Whether this event's default action get called
  71.  * \return DOM_NO_ERR on success, appropriate dom_exception on failure.
  72.  */
  73. dom_exception __dom_dispatch_node_change_document_event(dom_document *doc,
  74.                 dom_event_target *et, dom_mutation_type change, bool *success)
  75. {
  76.         struct dom_mutation_event *evt;
  77.         dom_string *type = NULL;
  78.         dom_exception err;
  79.  
  80.         err = _dom_mutation_event_create(doc, &evt);
  81.         if (err != DOM_NO_ERR)
  82.                 return err;
  83.  
  84.         if (change == DOM_MUTATION_ADDITION) {
  85.                 type = dom_string_ref(doc->_memo_domnodeinsertedintodocument);
  86.         } else if (change == DOM_MUTATION_REMOVAL) {
  87.                 type = dom_string_ref(doc->_memo_domnoderemovedfromdocument);
  88.         } else {
  89.                 assert("Should never be here" == NULL);
  90.         }
  91.  
  92.         /* Initialise the event with corresponding parameters */
  93.         err = dom_mutation_event_init(evt, type, true, false, NULL,
  94.                         NULL, NULL, NULL, change);
  95.         dom_string_unref(type);
  96.         if (err != DOM_NO_ERR)
  97.                 goto cleanup;
  98.  
  99.         err = dom_event_target_dispatch_event(et, evt, success);
  100.         if (err != DOM_NO_ERR)
  101.                 goto cleanup;
  102.        
  103. cleanup:
  104.         _dom_mutation_event_destroy(evt);
  105.  
  106.         return err;
  107. }
  108.  
  109. /**
  110.  * Dispatch a DOMAttrModified event
  111.  *
  112.  * \param doc        The Document object
  113.  * \param et         The EventTarget
  114.  * \param prev       The previous value before change
  115.  * \param new        The new value after change
  116.  * \param related    The related EventTarget
  117.  * \param attr_name  The Attribute name
  118.  * \param change     How this attribute change
  119.  * \param success    Whether this event's default handler get called
  120.  * \return DOM_NO_ERR on success, appropirate dom_exception on failure.
  121.  */
  122. dom_exception __dom_dispatch_attr_modified_event(dom_document *doc,
  123.                 dom_event_target *et, dom_string *prev, dom_string *new,
  124.                 dom_event_target *related, dom_string *attr_name,
  125.                 dom_mutation_type change, bool *success)
  126. {
  127.         struct dom_mutation_event *evt;
  128.         dom_string *type = NULL;
  129.         dom_exception err;
  130.  
  131.         err = _dom_mutation_event_create(doc, &evt);
  132.         if (err != DOM_NO_ERR)
  133.                 return err;
  134.        
  135.         type = dom_string_ref(doc->_memo_domattrmodified);
  136.  
  137.         /* Initialise the event with corresponding parameters */
  138.         err = dom_mutation_event_init(evt, type, true, false, related,
  139.                         prev, new, attr_name, change);
  140.         dom_string_unref(type);
  141.         if (err != DOM_NO_ERR) {
  142.                 goto cleanup;
  143.         }
  144.  
  145.         err = dom_event_target_dispatch_event(et, evt, success);
  146.  
  147. cleanup:
  148.         _dom_mutation_event_destroy(evt);
  149.  
  150.         return err;
  151. }
  152.  
  153. /**
  154.  * Dispatch a DOMCharacterDataModified event
  155.  *
  156.  * \param et       The EventTarget object
  157.  * \param prev     The preValue of the DOMCharacterData
  158.  * \param new      The newValue of the DOMCharacterData
  159.  * \param success  Whether this event's default handler get called
  160.  * \return DOM_NO_ERR on success, appropirate dom_exception on failure.
  161.  *
  162.  * TODO:
  163.  * The character_data object may be a part of a Attr node, if so, another
  164.  * DOMAttrModified event should be dispatched, too. But for now, we did not
  165.  * support any XML feature, so just leave it as this.
  166.  */
  167. dom_exception __dom_dispatch_characterdata_modified_event(
  168.                 dom_document *doc, dom_event_target *et,
  169.                 dom_string *prev, dom_string *new, bool *success)
  170. {
  171.         struct dom_mutation_event *evt;
  172.         dom_string *type = NULL;
  173.         dom_exception err;
  174.  
  175.         err = _dom_mutation_event_create(doc, &evt);
  176.         if (err != DOM_NO_ERR)
  177.                 return err;
  178.        
  179.         type = dom_string_ref(doc->_memo_domcharacterdatamodified);
  180.  
  181.         err = dom_mutation_event_init(evt, type, true, false, et, prev,
  182.                         new, NULL, DOM_MUTATION_MODIFICATION);
  183.         dom_string_unref(type);
  184.         if (err != DOM_NO_ERR) {
  185.                 goto cleanup;
  186.         }
  187.  
  188.         err = dom_event_target_dispatch_event(et, evt, success);
  189.  
  190. cleanup:
  191.         _dom_mutation_event_destroy(evt);
  192.  
  193.         return err;
  194. }
  195.  
  196. /**
  197.  * Dispatch a DOMSubtreeModified event
  198.  *
  199.  * \param doc      The Document
  200.  * \param et       The EventTarget object
  201.  * \param success  Whether this event's default handler get called
  202.  * \return DOM_NO_ERR on success, appropriate dom_exception on failure.
  203.  */
  204. dom_exception __dom_dispatch_subtree_modified_event(dom_document *doc,
  205.                 dom_event_target *et, bool *success)
  206. {
  207.         struct dom_mutation_event *evt;
  208.         dom_string *type = NULL;
  209.         dom_exception err;
  210.  
  211.         err = _dom_mutation_event_create(doc, &evt);
  212.         if (err != DOM_NO_ERR)
  213.                 return err;
  214.        
  215.         type = dom_string_ref(doc->_memo_domsubtreemodified);
  216.  
  217.         err = dom_mutation_event_init(evt, type, true, false, et, NULL,
  218.                         NULL, NULL, DOM_MUTATION_MODIFICATION);
  219.         dom_string_unref(type);
  220.         if (err != DOM_NO_ERR) {
  221.                 goto cleanup;
  222.         }
  223.  
  224.         err = dom_event_target_dispatch_event(et, evt, success);
  225.  
  226. cleanup:
  227.         _dom_mutation_event_destroy(evt);
  228.  
  229.         return err;
  230. }
  231.  
  232. /**
  233.  * Dispatch a generic event
  234.  *
  235.  * \param doc         The Document
  236.  * \param et          The EventTarget object
  237.  * \param name        The name of the event
  238.  * \param len         The length of the name string
  239.  * \param bubble      Whether this event bubbles
  240.  * \param cancelable  Whether this event can be cancelable
  241.  * \param success     Whether this event's default handler get called
  242.  * \return DOM_NO_ERR on success, appropriate dom_exception on failure.
  243.  */
  244. dom_exception _dom_dispatch_generic_event(dom_document *doc,
  245.                 dom_event_target *et, dom_string *event_name,
  246.                 bool bubble, bool cancelable, bool *success)
  247. {
  248.         struct dom_event *evt;
  249.         dom_exception err;
  250.  
  251.         err = _dom_event_create(doc, &evt);
  252.         if (err != DOM_NO_ERR)
  253.                 return err;
  254.        
  255.         err = dom_event_init(evt, event_name, bubble, cancelable);
  256.  
  257.         if (err != DOM_NO_ERR) {
  258.                 goto cleanup;
  259.         }
  260.  
  261.         err = dom_event_target_dispatch_event(et, evt, success);
  262.  
  263. cleanup:
  264.         _dom_event_destroy(evt);
  265.  
  266.         return err;
  267. }
  268.  
  269.