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. #include <stdlib.h>
  10. #include <time.h>
  11.  
  12. #include "events/event.h"
  13.  
  14. #include "core/string.h"
  15. #include "core/node.h"
  16. #include "core/document.h"
  17. #include "utils/utils.h"
  18.  
  19. static void _virtual_dom_event_destroy(dom_event *evt);
  20.  
  21. static struct dom_event_private_vtable _event_vtable = {
  22.         _virtual_dom_event_destroy
  23. };
  24.  
  25. /* Constructor */
  26. dom_exception _dom_event_create(dom_document *doc, dom_event **evt)
  27. {
  28.         *evt = (dom_event *) malloc(sizeof(dom_event));
  29.         if (*evt == NULL)
  30.                 return DOM_NO_MEM_ERR;
  31.        
  32.         (*evt)->vtable = &_event_vtable;
  33.  
  34.         return _dom_event_initialise(doc, *evt);
  35. }
  36.  
  37. /* Destructor */
  38. void _dom_event_destroy(dom_event *evt)
  39. {
  40.         _dom_event_finalise(evt);
  41.  
  42.         free(evt);
  43. }
  44.  
  45. /* Initialise function */
  46. dom_exception _dom_event_initialise(dom_document *doc, dom_event *evt)
  47. {
  48.         assert(doc != NULL);
  49.  
  50.         evt->doc = doc;
  51.         evt->stop = false;
  52.         evt->stop_now = false;
  53.         evt->prevent_default = false;
  54.         evt->custom = false;
  55.  
  56.         evt->type = NULL;
  57.  
  58.         evt->namespace = NULL;
  59.  
  60.         evt->refcnt = 1;
  61.         evt->in_dispatch = false;
  62.  
  63.         return DOM_NO_ERR;
  64. }
  65.  
  66. /* Finalise function */
  67. void _dom_event_finalise(dom_event *evt)
  68. {
  69.         if (evt->type != NULL)
  70.                 dom_string_unref(evt->type);
  71.         if (evt->namespace != NULL)
  72.                 dom_string_unref(evt->namespace);
  73.        
  74.         evt->stop = false;
  75.         evt->stop_now = false;
  76.         evt->prevent_default = false;
  77.         evt->custom = false;
  78.  
  79.         evt->type = NULL;
  80.  
  81.         evt->namespace = NULL;
  82.  
  83.         evt->in_dispatch = false;
  84. }
  85.  
  86. /* The virtual destroy function */
  87. void _virtual_dom_event_destroy(dom_event *evt)
  88. {
  89.         _dom_event_destroy(evt);
  90. }
  91.  
  92. /*----------------------------------------------------------------------*/
  93. /* The public API */
  94.  
  95. /**
  96.  * Claim a reference on this event object
  97.  *
  98.  * \param evt  The Event object
  99.  */
  100. void _dom_event_ref(dom_event *evt)
  101. {
  102.         evt->refcnt++;
  103. }
  104.  
  105. /**
  106.  * Release a reference on this event object
  107.  *
  108.  * \param evt  The Event object
  109.  */
  110. void _dom_event_unref(dom_event *evt)
  111. {
  112.         if (evt->refcnt > 0)
  113.                 evt->refcnt--;
  114.  
  115.         if (evt->refcnt == 0)
  116.                 dom_event_destroy(evt);
  117. }
  118.  
  119.  
  120. /**
  121.  * Get the event type
  122.  *
  123.  * \param evt   The event object
  124.  * \parnm type  The returned event type
  125.  * \return DOM_NO_ERR on success, appropriate dom_exception on failure.
  126.  */
  127. dom_exception _dom_event_get_type(dom_event *evt, dom_string **type)
  128. {
  129.         *type = dom_string_ref(evt->type);
  130.        
  131.         return DOM_NO_ERR;
  132. }
  133.  
  134. /**
  135.  * Get the target node of this event
  136.  *
  137.  * \param evt     The event object
  138.  * \param target  The target node
  139.  * \return DOM_NO_ERR on success, appropriate dom_exception on failure.
  140.  */
  141. dom_exception _dom_event_get_target(dom_event *evt, dom_event_target **target)
  142. {
  143.         *target = evt->target;
  144.         dom_node_ref(*target);
  145.  
  146.         return DOM_NO_ERR;
  147. }
  148.  
  149. /**
  150.  * Get the current target of this event
  151.  *
  152.  * \param evt      The event object
  153.  * \param current  The current event target node
  154.  * \return DOM_NO_ERR on success, appropriate dom_exception on failure.
  155.  */
  156. dom_exception _dom_event_get_current_target(dom_event *evt,
  157.                 dom_event_target **current)
  158. {
  159.         *current = evt->current;
  160.         dom_node_ref(*current);
  161.  
  162.         return DOM_NO_ERR;
  163. }
  164.  
  165. /**
  166.  * Get whether this event can bubble
  167.  *
  168.  * \param evt      The Event object
  169.  * \param bubbles  The returned value
  170.  * \return DOM_NO_ERR.
  171.  */
  172. dom_exception _dom_event_get_bubbles(dom_event *evt, bool *bubbles)
  173. {
  174.         *bubbles = evt->bubble;
  175.         return DOM_NO_ERR;
  176. }
  177.  
  178. /**
  179.  * Get whether this event can be cancelable
  180.  *
  181.  * \param evt         The Event object
  182.  * \param cancelable  The returned value
  183.  * \return DOM_NO_ERR.
  184.  */
  185. dom_exception _dom_event_get_cancelable(dom_event *evt, bool *cancelable)
  186. {
  187.         *cancelable = evt->cancelable;
  188.         return DOM_NO_ERR;
  189. }
  190.  
  191. /**
  192.  * Get the event's generation timestamp
  193.  *
  194.  * \param evt        The Event object
  195.  * \param timestamp  The returned value
  196.  * \return DOM_NO_ERR.
  197.  */
  198. dom_exception _dom_event_get_timestamp(dom_event *evt, unsigned int *timestamp)
  199. {
  200.         *timestamp = evt->timestamp;
  201.         return DOM_NO_ERR;
  202. }
  203.  
  204. /**
  205.  * Stop propagation of the event
  206.  *
  207.  * \param evt  The Event object
  208.  * \return DOM_NO_ERR.
  209.  */
  210. dom_exception _dom_event_stop_propagation(dom_event *evt)
  211. {
  212.         evt->stop = true;
  213.  
  214.         return DOM_NO_ERR;
  215. }
  216.  
  217. /**
  218.  * Prevent the default action of this event
  219.  *
  220.  * \param evt  The Event object
  221.  * \return DOM_NO_ERR.
  222.  */
  223. dom_exception _dom_event_prevent_default(dom_event *evt)
  224. {
  225.         evt->prevent_default = true;
  226.         return DOM_NO_ERR;
  227. }
  228.  
  229. /**
  230.  * Initialise the event object
  231.  *
  232.  * \param evt         The event object
  233.  * \param type        The type of this event
  234.  * \param bubble      Whether this event can bubble
  235.  * \param cancelable  Whether this event is cancelable
  236.  * \return DOM_NO_ERR on success, appropriate dom_exception on failure.
  237.  */
  238. dom_exception _dom_event_init(dom_event *evt, dom_string *type,
  239.                 bool bubble, bool cancelable)
  240. {
  241.         assert(evt->doc != NULL);
  242.  
  243.         evt->type = dom_string_ref(type);
  244.         evt->bubble = bubble;
  245.         evt->cancelable = cancelable;
  246.  
  247.         evt->timestamp = time(NULL);
  248.  
  249.         return DOM_NO_ERR;
  250. }
  251.  
  252. /**
  253.  * Get the namespace of this event
  254.  *
  255.  * \param evt        The event object
  256.  * \param namespace  The returned namespace of this event
  257.  * \return DOM_NO_ERR on success, appropriate dom_exception on failure.
  258.  */
  259. dom_exception _dom_event_get_namespace(dom_event *evt,
  260.                 dom_string **namespace)
  261. {
  262.         *namespace = dom_string_ref(evt->namespace);
  263.        
  264.         return DOM_NO_ERR;
  265. }
  266.  
  267. /**
  268.  * Whether this is a custom event
  269.  *
  270.  * \param evt     The event object
  271.  * \param custom  The returned value
  272.  * \return DOM_NO_ERR.
  273.  */
  274. dom_exception _dom_event_is_custom(dom_event *evt, bool *custom)
  275. {
  276.         *custom = evt->custom;
  277.  
  278.         return DOM_NO_ERR;
  279. }
  280.        
  281. /**
  282.  * Stop the event propagation immediately
  283.  *
  284.  * \param evt  The event object
  285.  * \return DOM_NO_ERR.
  286.  */
  287. dom_exception _dom_event_stop_immediate_propagation(dom_event *evt)
  288. {
  289.         evt->stop_now = true;
  290.  
  291.         return DOM_NO_ERR;
  292. }
  293.  
  294. /**
  295.  * Whether the default action is prevented
  296.  *
  297.  * \param evt        The event object
  298.  * \param prevented  The returned value
  299.  * \return DOM_NO_ERR.
  300.  */
  301. dom_exception _dom_event_is_default_prevented(dom_event *evt, bool *prevented)
  302. {
  303.         *prevented = evt->prevent_default;
  304.  
  305.         return DOM_NO_ERR;
  306. }
  307.  
  308. /**
  309.  * Initialise the event with namespace
  310.  *
  311.  * \param evt         The event object
  312.  * \param namespace   The namespace of this event
  313.  * \param type        The event type
  314.  * \param bubble      Whether this event has a bubble phase
  315.  * \param cancelable  Whether this event is cancelable
  316.  * \return DOM_NO_ERR on success, appropriate dom_exception on failure.
  317.  */
  318. dom_exception _dom_event_init_ns(dom_event *evt, dom_string *namespace,
  319.                 dom_string *type, bool bubble, bool cancelable)
  320. {
  321.         assert(evt->doc != NULL);
  322.  
  323.         evt->type = dom_string_ref(type);
  324.  
  325.         evt->namespace = dom_string_ref(namespace);
  326.  
  327.         evt->bubble = bubble;
  328.         evt->cancelable = cancelable;
  329.  
  330.         return DOM_NO_ERR;
  331. }
  332.  
  333.