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 <string.h>
  10.  
  11. #include <libwapcaplet/libwapcaplet.h>
  12.  
  13. #include "core/string.h"
  14. #include "core/node.h"
  15. #include "core/document.h"
  16. #include "events/document_event.h"
  17. #include "events/event.h"
  18. #include "events/ui_event.h"
  19. #include "events/custom_event.h"
  20. #include "events/text_event.h"
  21. #include "events/keyboard_event.h"
  22. #include "events/mouse_event.h"
  23. #include "events/mouse_multi_wheel_event.h"
  24. #include "events/mouse_wheel_event.h"
  25. #include "events/mutation_event.h"
  26. #include "events/mutation_name_event.h"
  27.  
  28. #include "utils/utils.h"
  29.  
  30. static const char *__event_types[] = {
  31.         "Event",
  32.         "CustomEvent",
  33.         "UIEvent",
  34.         "TextEvent",
  35.         "KeyboardEvent",
  36.         "MouseEvent",
  37.         "MouseMultiWheelEvent",
  38.         "MouseWheelEvent",
  39.         "MutationEvent",
  40.         "MutationNameEvent"
  41. };
  42.  
  43. /**
  44.  * Initialise this DocumentEvent
  45.  *
  46.  * \param doc      The document object
  47.  * \param dei      The DocumentEvent internal object
  48.  * \param actions  The default action fetcher, the browser should provide such
  49.  *                 a function to Event module.
  50.  * \return DOM_NO_ERR on success, appropriate dom_exception on failure.
  51.  */
  52. dom_exception _dom_document_event_internal_initialise(struct dom_document *doc,
  53.                 dom_document_event_internal *dei,
  54.                 dom_events_default_action_fetcher actions,
  55.                 void *actions_ctx)
  56. {
  57.         lwc_error err;
  58.         int i;
  59.  
  60.         UNUSED(doc);
  61.  
  62.         for (i = 0; i < DOM_EVENT_COUNT; i++) {
  63.                 err = lwc_intern_string(__event_types[i],
  64.                                 strlen(__event_types[i]), &dei->event_types[i]);
  65.                 if (err != lwc_error_ok)
  66.                         return _dom_exception_from_lwc_error(err);
  67.         }
  68.  
  69.         dei->actions = actions;
  70.         dei->actions_ctx = actions_ctx;
  71.  
  72.         return DOM_NO_ERR;
  73. }
  74.  
  75. /* Finalise this DocumentEvent */
  76. void _dom_document_event_internal_finalise(struct dom_document *doc,
  77.                 dom_document_event_internal *dei)
  78. {
  79.         int i;
  80.  
  81.         UNUSED(doc);
  82.  
  83.         for (i = 0; i < DOM_EVENT_COUNT; i++) {
  84.                 if (dei->event_types[i] != NULL)
  85.                         lwc_string_unref(dei->event_types[i]);
  86.         }
  87.  
  88.         return;
  89. }
  90.  
  91. /*-------------------------------------------------------------------------*/
  92. /* Public API */
  93.  
  94. /**
  95.  * Create an Event object
  96.  *
  97.  * \param de    The DocumentEvent object
  98.  * \param type  The Event type
  99.  * \param evt   The returned Event object
  100.  * \return DOM_NO_ERR on success, appropriate dom_exception on failure.
  101.  */
  102. dom_exception _dom_document_event_create_event(dom_document_event *de,
  103.                 dom_string *type, struct dom_event **evt)
  104. {
  105.         lwc_string *t = NULL;
  106.         dom_exception err;
  107.         struct dom_document *doc = de;
  108.         int i, et = 0;
  109.         dom_document_event_internal *dei;
  110.  
  111.         err = dom_string_intern(type, &t);
  112.         if (err != DOM_NO_ERR)
  113.                 return err;
  114.  
  115.         assert(t != NULL);
  116.        
  117.         dei = &de->dei;
  118.         for (i = 0; i < DOM_EVENT_COUNT; i++) {
  119.                 if (dei->event_types[i] == t) {
  120.                         et = i;
  121.                         break;
  122.                 }
  123.         }
  124.         lwc_string_unref(t);
  125.  
  126.         switch (et) {
  127.                 case DOM_EVENT:
  128.                         err = _dom_event_create(doc, evt);
  129.                         break;
  130.                 case DOM_CUSTOM_EVENT:
  131.                         err = _dom_custom_event_create(doc,
  132.                                         (dom_custom_event **) evt);
  133.                         break;
  134.                 case DOM_UI_EVENT:
  135.                         err = _dom_ui_event_create(doc, (dom_ui_event **) evt);
  136.                         break;
  137.                 case DOM_TEXT_EVENT:
  138.                         err = _dom_text_event_create(doc,
  139.                                         (dom_text_event **) evt);
  140.                         break;
  141.                 case DOM_KEYBOARD_EVENT:
  142.                         err = _dom_keyboard_event_create(doc,
  143.                                         (dom_keyboard_event **) evt);
  144.                         break;
  145.                 case DOM_MOUSE_EVENT:
  146.                         err = _dom_mouse_event_create(doc,
  147.                                         (dom_mouse_event **) evt);
  148.                         break;
  149.                 case DOM_MOUSE_MULTI_WHEEL_EVENT:
  150.                         err = _dom_mouse_multi_wheel_event_create(doc,
  151.                                         (dom_mouse_multi_wheel_event **) evt);
  152.                         break;
  153.                 case DOM_MOUSE_WHEEL_EVENT:
  154.                         err = _dom_mouse_wheel_event_create(doc,
  155.                                         (dom_mouse_wheel_event **) evt);
  156.                         break;
  157.                 case DOM_MUTATION_EVENT:
  158.                         err = _dom_mutation_event_create(doc,
  159.                                         (dom_mutation_event **) evt);
  160.                         break;
  161.                 case DOM_MUTATION_NAME_EVENT:
  162.                         err = _dom_mutation_name_event_create(doc,
  163.                                         (dom_mutation_name_event **) evt);
  164.                         break;
  165.                 default:
  166.                         assert("Should never be here" == NULL);
  167.         }
  168.  
  169.         return err;
  170. }
  171.  
  172. /**
  173.  * Tests if the implementation can generate events of a specified type
  174.  *
  175.  * \param de         The DocumentEvent
  176.  * \param namespace  The namespace of the event
  177.  * \param type       The type of the event
  178.  * \param can        True if we can generate such an event, false otherwise
  179.  * \return DOM_NO_ERR on success, appropriate dom_exception on failure.
  180.  *
  181.  * We don't support this API now, so the return value should always
  182.  * DOM_NO_SUPPORTED_ERR.
  183.  */
  184. dom_exception _dom_document_event_can_dispatch(dom_document_event *de,
  185.                 dom_string *namespace, dom_string *type,
  186.                 bool *can)
  187. {
  188.         UNUSED(de);
  189.         UNUSED(namespace);
  190.         UNUSED(type);
  191.         UNUSED(can);
  192.  
  193.         return DOM_NOT_SUPPORTED_ERR;
  194. }
  195.