/*

 *          GPAC Multimedia Framework

 *

 *      Authors: Cyril Concolato, Jean Le Feuvre

 *      Copyright (c) Telecom ParisTech 2004-2022

 *          All rights reserved

 *

 *  This file is part of GPAC / SVG Loader module

 *

 *  GPAC is free software; you can redistribute it and/or modify

 *  it under the terms of the GNU Lesser General Public License as published by

 *  the Free Software Foundation; either version 2, or (at your option)

 *  any later version.

 *

 *  GPAC 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 Lesser General Public License for more details.

 *

 *  You should have received a copy of the GNU Lesser General Public

 *  License along with this library; see the file COPYING.  If not, write to

 *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.

 *

 */

#include <gpac/base_coding.h>

#include <gpac/color.h>

#include <gpac/events.h>

#include <gpac/nodes_svg.h>

#ifndef GPAC_DISABLE_SVG

#include <gpac/internal/scenegraph_dev.h>

#define DUMP_COORDINATES 1

static const struct dom_event_def {

  GF_EventType event;

  const char *name;

  GF_DOMEventCategory category;

} defined_dom_events [] =

{

  { GF_EVENT_ABORT, "abort", GF_DOM_EVENT_DOM },

  { GF_EVENT_ERROR, "error", GF_DOM_EVENT_DOM },

  { GF_EVENT_LOAD, "load", GF_DOM_EVENT_DOM },

  { GF_EVENT_UNLOAD, "unload", GF_DOM_EVENT_DOM },

  /*focus - we differentiate from UI/key events to avoid browing focus if no listener is on place*/

  { GF_EVENT_FOCUSIN, "DOMFocusIn", GF_DOM_EVENT_FOCUS },

  { GF_EVENT_FOCUSIN, "focusin", GF_DOM_EVENT_FOCUS },

  { GF_EVENT_FOCUSOUT, "DOMFocusOut", GF_DOM_EVENT_FOCUS },

  { GF_EVENT_FOCUSOUT, "focusout", GF_DOM_EVENT_FOCUS },

  { GF_EVENT_CHANGE, "change", GF_DOM_EVENT_FOCUS },

  { GF_EVENT_FOCUS, "focus", GF_DOM_EVENT_FOCUS },

  { GF_EVENT_BLUR, "blur", GF_DOM_EVENT_FOCUS },

  /*key events*/

  { GF_EVENT_KEYDOWN, "keydown", GF_DOM_EVENT_KEY },

  { GF_EVENT_KEYDOWN, "accesskey", GF_DOM_EVENT_KEY },

  { GF_EVENT_KEYDOWN, "keypress", GF_DOM_EVENT_KEY },

  { GF_EVENT_KEYUP, "keyup", GF_DOM_EVENT_KEY },

  { GF_EVENT_LONGKEYPRESS, "longaccesskey", GF_DOM_EVENT_KEY },

  { GF_EVENT_CLICK, "click", GF_DOM_EVENT_MOUSE },

  { GF_EVENT_DBLCLICK, "dblclick", GF_DOM_EVENT_MOUSE },

  { GF_EVENT_MOUSEDOWN, "mousedown", GF_DOM_EVENT_MOUSE },

  { GF_EVENT_MOUSEMOVE, "mousemove", GF_DOM_EVENT_MOUSE },

  { GF_EVENT_MOUSEOUT, "mouseout", GF_DOM_EVENT_MOUSE },

  { GF_EVENT_MOUSEOVER, "mouseover", GF_DOM_EVENT_MOUSE },

  { GF_EVENT_MOUSEUP, "mouseup", GF_DOM_EVENT_MOUSE },

  { GF_EVENT_MOUSEWHEEL, "wheel", GF_DOM_EVENT_MOUSE },

  { GF_EVENT_MOUSEWHEEL, "SVGMousewheel", GF_DOM_EVENT_MOUSE },

  /*activate is not a basic DOM but a MOUSE and KEY event*/

  { GF_EVENT_ACTIVATE, "activate", GF_DOM_EVENT_MOUSE | GF_DOM_EVENT_KEY },

  { GF_EVENT_ACTIVATE, "DOMActivate", GF_DOM_EVENT_MOUSE | GF_DOM_EVENT_KEY },

  /*text events*/

  { GF_EVENT_TEXTINPUT, "textInput", GF_DOM_EVENT_TEXT },

  { GF_EVENT_TEXTSELECT, "select", GF_DOM_EVENT_TEXT },

  /*SMIL events*/

  { GF_EVENT_BEGIN, "begin", GF_DOM_EVENT_FAKE },

  { GF_EVENT_BEGIN_EVENT, "beginEvent", GF_DOM_EVENT_SMIL },

  { GF_EVENT_END, "end", GF_DOM_EVENT_FAKE },

  { GF_EVENT_END_EVENT, "endEvent", GF_DOM_EVENT_SMIL },

  { GF_EVENT_REPEAT, "repeat", GF_DOM_EVENT_FAKE },

  { GF_EVENT_REPEAT_EVENT, "repeatEvent", GF_DOM_EVENT_SMIL },

  /*all SVG/HTML/... UI events*/

  { GF_EVENT_RESIZE, "resize", GF_DOM_EVENT_UI },

  { GF_EVENT_SCROLL, "scroll", GF_DOM_EVENT_UI },

  { GF_EVENT_ZOOM, "zoom", GF_DOM_EVENT_UI },

  { GF_EVENT_LOAD, "SVGLoad", GF_DOM_EVENT_DOM },

  { GF_EVENT_RESIZE, "SVGResize", GF_DOM_EVENT_UI },

  { GF_EVENT_SCROLL, "SVGScroll", GF_DOM_EVENT_UI },

  { GF_EVENT_ZOOM, "SVGZoom", GF_DOM_EVENT_UI },

  /*mutation events and DCCI*/

  { GF_EVENT_TREE_MODIFIED, "DOMSubtreeModified", GF_DOM_EVENT_MUTATION },

  { GF_EVENT_NODE_INSERTED, "DOMNodeInserted", GF_DOM_EVENT_MUTATION },

  { GF_EVENT_NODE_REMOVED, "DOMNodeRemoved", GF_DOM_EVENT_MUTATION },

  { GF_EVENT_NODE_REMOVED_DOC, "DOMNodeRemovedFromDocument", GF_DOM_EVENT_MUTATION },

  { GF_EVENT_NODE_INSERTED_DOC, "DOMNodeInsertedIntoDocument", GF_DOM_EVENT_MUTATION },

  { GF_EVENT_ATTR_MODIFIED, "DOMAttrModified", GF_DOM_EVENT_MUTATION },

  { GF_EVENT_CHAR_DATA_MODIFIED, "DOMCharacterDataModified", GF_DOM_EVENT_MUTATION },

  { GF_EVENT_NODE_NAME_CHANGED, "DOMElementNameChanged", GF_DOM_EVENT_MUTATION },

  { GF_EVENT_ATTR_NAME_CHANGED, "DOMAttributeNameChanged", GF_DOM_EVENT_MUTATION },

  { GF_EVENT_DCCI_PROP_CHANGE, "DCCI-prop-change", GF_DOM_EVENT_MUTATION },

  /*LASeR events - some events are attached to other categorues*/

  { GF_EVENT_ACTIVATED, "activatedEvent", GF_DOM_EVENT_LASER },

  { GF_EVENT_DEACTIVATED, "deactivatedEvent", GF_DOM_EVENT_LASER },

  { GF_EVENT_EXECUTION_TIME, "executionTime", GF_DOM_EVENT_FAKE },

  { GF_EVENT_PAUSE, "pause", GF_DOM_EVENT_SMIL },

  { GF_EVENT_PAUSED_EVENT, "pausedEvent", GF_DOM_EVENT_SMIL },

  { GF_EVENT_PLAY, "play", GF_DOM_EVENT_SMIL },

  { GF_EVENT_RESUME_EVENT, "resumedEvent", GF_DOM_EVENT_SMIL },

  { GF_EVENT_REPEAT_KEY, "repeatKey", GF_DOM_EVENT_KEY },

  { GF_EVENT_SHORT_ACCESSKEY, "shortAccessKey", GF_DOM_EVENT_KEY },

  /*LASeR unofficial events*/

  { GF_EVENT_BATTERY, "battery", GF_DOM_EVENT_LASER },

  { GF_EVENT_CPU, "cpu", GF_DOM_EVENT_LASER },

  { GF_EVENT_MEDIA_SETUP_BEGIN, "setupbegin", GF_DOM_EVENT_MEDIA},

  { GF_EVENT_MEDIA_SETUP_DONE, "setupdone", GF_DOM_EVENT_MEDIA},

  { GF_EVENT_MEDIA_LOAD_START, "loadstart", GF_DOM_EVENT_MEDIA },

  { GF_EVENT_MEDIA_LOAD_DONE, "loaddone", GF_DOM_EVENT_MEDIA },

  { GF_EVENT_MEDIA_PROGRESS, "progress", GF_DOM_EVENT_MEDIA },

  { GF_EVENT_MEDIA_SUSPEND, "suspend", GF_DOM_EVENT_MEDIA },

  { GF_EVENT_ABORT, "abort", GF_DOM_EVENT_MEDIA },

  { GF_EVENT_ERROR, "error", GF_DOM_EVENT_MEDIA },

  { GF_EVENT_MEDIA_EMPTIED, "emptied", GF_DOM_EVENT_MEDIA },

  { GF_EVENT_MEDIA_STALLED, "stalled", GF_DOM_EVENT_MEDIA },

  { GF_EVENT_MEDIA_LOADED_METADATA, "loadedmetadata", GF_DOM_EVENT_MEDIA },

  { GF_EVENT_MEDIA_LODADED_DATA, "loadeddata", GF_DOM_EVENT_MEDIA },

  { GF_EVENT_MEDIA_CANPLAY, "canplay", GF_DOM_EVENT_MEDIA },

  { GF_EVENT_MEDIA_CANPLAYTHROUGH, "canplaythrough", GF_DOM_EVENT_MEDIA },

  { GF_EVENT_MEDIA_PLAYING, "playing", GF_DOM_EVENT_MEDIA },

  { GF_EVENT_MEDIA_WAITING, "waiting", GF_DOM_EVENT_MEDIA },

  { GF_EVENT_MEDIA_SEEKING, "seeking", GF_DOM_EVENT_MEDIA },

  { GF_EVENT_MEDIA_SEEKED, "seeked", GF_DOM_EVENT_MEDIA },

  { GF_EVENT_MEDIA_ENDED, "ended", GF_DOM_EVENT_MEDIA },

  { GF_EVENT_MEDIA_DURATION_CHANGED, "durationchanged", GF_DOM_EVENT_MEDIA },

  { GF_EVENT_MEDIA_TIME_UPDATE, "timeupdate", GF_DOM_EVENT_MEDIA },

  { GF_EVENT_PLAY, "play", GF_DOM_EVENT_MEDIA },

  { GF_EVENT_PAUSE, "pause", GF_DOM_EVENT_MEDIA },

  { GF_EVENT_MEDIA_RATECHANGE, "ratechange", GF_DOM_EVENT_MEDIA },

  { GF_EVENT_MEDIA_VOLUME_CHANGED, "volumechange", GF_DOM_EVENT_MEDIA },

#if 0

  /* Media Source Events */

  { GF_EVENT_HTML_MSE_SOURCE_OPEN, "sourceopen", GF_DOM_EVENT_MEDIASOURCE },

  { GF_EVENT_HTML_MSE_SOURCE_ENDED, "sourceended", GF_DOM_EVENT_MEDIASOURCE },

  { GF_EVENT_HTML_MSE_SOURCE_CLOSE, "sourceclose", GF_DOM_EVENT_MEDIASOURCE },

  { GF_EVENT_HTML_MSE_UPDATE_START, "updatestart", GF_DOM_EVENT_MEDIASOURCE },

  { GF_EVENT_HTML_MSE_UPDATE, "update", GF_DOM_EVENT_MEDIASOURCE },

  { GF_EVENT_HTML_MSE_UPDATE_END, "updateend", GF_DOM_EVENT_MEDIASOURCE },

  { GF_EVENT_HTML_MSE_UPDATE_ERROR, "error", GF_DOM_EVENT_MEDIASOURCE },

  { GF_EVENT_HTML_MSE_UPDATE_ABORT, "abort", GF_DOM_EVENT_MEDIASOURCE },

  { GF_EVENT_HTML_MSE_ADD_SOURCE_BUFFER, "addsourcebuffer", GF_DOM_EVENT_MEDIASOURCE },

  { GF_EVENT_HTML_MSE_REMOVE_SOURCE_BUFFER, "removesourcebuffer", GF_DOM_EVENT_MEDIASOURCE },

#endif

  /*GPAC internals*/

  { GF_EVENT_SCENE_ATTACHED, "gpac_scene_attached", GF_DOM_EVENT_GPAC},

  { GF_EVENT_SCENE_SIZE, "gpac_scene_size", GF_DOM_EVENT_GPAC},

  { GF_EVENT_VP_RESIZE, "gpac_vp_changed", GF_DOM_EVENT_GPAC},

  { GF_EVENT_ADDON_DETECTED, "gpac_addon_found", GF_DOM_EVENT_GPAC},

  { GF_EVENT_MAIN_ADDON_STATE, "gpac_main_addon_state", GF_DOM_EVENT_GPAC},

  { GF_EVENT_STREAMLIST, "gpac_streamlist_changed", GF_DOM_EVENT_GPAC},

  { GF_EVENT_TIMESHIFT_DEPTH, "gpac_timeshift_depth_changed", GF_DOM_EVENT_GPAC},

  { GF_EVENT_CODEC_SLOW, "gpac_codec_slow", GF_DOM_EVENT_GPAC},

  { GF_EVENT_CODEC_OK, "gpac_codec_ok", GF_DOM_EVENT_GPAC},

#if 0

  { GF_EVENT_DBLCLICK, "gpac_dbl_click", GF_DOM_EVENT_GPAC},

  { GF_EVENT_SIZE, "gpac_size_changed", GF_DOM_EVENT_GPAC},

  { GF_EVENT_SHOWHIDE, "gpac_show_hide", GF_DOM_EVENT_GPAC},

  { GF_EVENT_SET_CURSOR, "gpac_set_cursor", GF_DOM_EVENT_GPAC},

  { GF_EVENT_SET_CAPTION, "gpac_set_caption", GF_DOM_EVENT_GPAC},

  { GF_EVENT_MOVE, "gpac_move", GF_DOM_EVENT_GPAC},

  { GF_EVENT_REFRESH, "gpac_refresh", GF_DOM_EVENT_GPAC},

  { GF_EVENT_QUIT, "gpac_quit", GF_DOM_EVENT_GPAC},

  { GF_EVENT_PASTE_TEXT, "gpac_paste", GF_DOM_EVENT_GPAC},

  { GF_EVENT_COPY_TEXT, "gpac_copy", GF_DOM_EVENT_GPAC},

  { GF_EVENT_CONNECT, "gpac_on_connect", GF_DOM_EVENT_GPAC},

  { GF_EVENT_DURATION, "gpac_on_duration", GF_DOM_EVENT_GPAC},

  { GF_EVENT_EOS, "gpac_eos", GF_DOM_EVENT_GPAC},

  { GF_EVENT_AUTHORIZATION, "gpac_authorization", GF_DOM_EVENT_GPAC},

  { GF_EVENT_NAVIGATE, "gpac_navigate", GF_DOM_EVENT_GPAC},

  { GF_EVENT_NAVIGATE_INFO, "gpac_navigate_info", GF_DOM_EVENT_GPAC},

  { GF_EVENT_MESSAGE, "gpac_on_message", GF_DOM_EVENT_GPAC},

  { GF_EVENT_PROGRESS, "gpac_on_progress", GF_DOM_EVENT_GPAC},

  { GF_EVENT_VIEWPOINTS, "gpac_viewpoints_changed", GF_DOM_EVENT_GPAC},

  { GF_EVENT_METADATA, "gpac_metadata_changed", GF_DOM_EVENT_GPAC},

  { GF_EVENT_MIGRATE, "gpac_session_migrate", GF_DOM_EVENT_GPAC},

  { GF_EVENT_DISCONNECT, "gpac_request_disconnect", GF_DOM_EVENT_GPAC},

  { GF_EVENT_RESOLUTION, "gpac_resolution_changed", GF_DOM_EVENT_GPAC},

  { GF_EVENT_DROPFILE, "gpac_dropfile", GF_DOM_EVENT_GPAC},

  { GF_EVENT_TEXT_EDITING_START, "gpac_textedit_start", GF_DOM_EVENT_GPAC},

  { GF_EVENT_TEXT_EDITING_END, "gpac_textedit_end", GF_DOM_EVENT_GPAC},

  { GF_EVENT_QUALITY_SWITCHED, "gpac_quality_switch", GF_DOM_EVENT_GPAC},

  { GF_EVENT_TIMESHIFT_OVERFLOW, "gpac_timeshift_overflow", GF_DOM_EVENT_GPAC},

  { GF_EVENT_TIMESHIFT_UPDATE, "gpac_timeshift_update", GF_DOM_EVENT_GPAC}

  { GF_EVENT_TIMESHIFT_UNDERRUN, "gpac_timeshift_underrun", GF_DOM_EVENT_GPAC}

#endif

};

#ifdef WIN32

/** In order to have the same representation of laser/svg media on unix and windows

  * we have to force windows to use the same rounding method as the glibc.

  * See: http://pubs.opengroup.org/onlinepubs/009695399/functions/fprintf.html

  * "The low-order digit shall be rounded in an implementation-defined manner."

  * glibc uses the IEEE-754 recommended half-to-even method while windows rounds half up.

  * When windows finally implements HTE rounding we'll be able to remove the convoluted functions below

 **/

int is_even(double d) {

  double int_part;

  modf(d / 2.0, &int_part);

  return 2.0 * int_part == d;

}

double round_ieee_754(double d) {

  double i = floor(d);

  d -= i;

  if (d < 0.5)

    return i;

  if (d > 0.5)

    return i + 1.0;

  if (is_even(i))

    return i;

  return i + 1.0;

}

double round_float_hte(double value, int digits)

{

  if (value) {

    int missing_digits = digits - (int)log10(fabs(value)) - (fabs(value) > 1.f);

    double exp = pow(10.f, missing_digits > 0 ? missing_digits : 0);

    value *= exp;

    value = round_ieee_754(value);

    value /= exp;

  }

  return value;

};

#define _FIX2FLT(x) (round_float_hte(FIX2FLT(x),6))

#else

#define _FIX2FLT(x) FIX2FLT(x)

#endif

GF_EXPORT

GF_EventType gf_dom_event_type_by_name(const char *name)

{

  u32 i, count;

  count = sizeof(defined_dom_events) / sizeof(struct dom_event_def);

  if (!name) return GF_EVENT_UNKNOWN;

  if ((name[0]=='o') && (name[1]=='n')) name += 2;

  for (i=0; i<count; i++) {

    if (!strcmp(name, defined_dom_events[i].name))

      return defined_dom_events[i].event;

  }

  return GF_EVENT_UNKNOWN;

}

GF_EXPORT

const char *gf_dom_event_get_name(GF_EventType type)

{

  u32 i, count;

  count = sizeof(defined_dom_events) / sizeof(struct dom_event_def);

  for (i=0; i<count; i++) {

    if (defined_dom_events[i].event == type)

      return defined_dom_events[i].name;

  }

  return "unknown";

}

GF_DOMEventCategory gf_dom_event_get_category(GF_EventType type)

{

  u32 i, count;

  count = sizeof(defined_dom_events) / sizeof(struct dom_event_def);

  for (i=0; i<count; i++) {

    if (defined_dom_events[i].event == type)

      return defined_dom_events[i].category;

  }

  return GF_DOM_EVENT_UNKNOWN_CATEGORY;

}

static const struct predef_keyid {

  GF_KeyCode key_code;

  const char *name;

  const char *friendly_name;

} predefined_key_identifiers[] =

{

  { GF_KEY_ACCEPT, "Accept" },

  { GF_KEY_AGAIN, "Again" },

  { GF_KEY_ALLCANDIDATES, "AllCandidates" },

  { GF_KEY_ALPHANUM, "Alphanumeric" },

  { GF_KEY_ALT, "Alt" },

  { GF_KEY_ALTGRAPH, "AltGraph" },

  { GF_KEY_APPS, "Apps" },

  { GF_KEY_ATTN, "Attn" },

  { GF_KEY_BROWSERBACK, "BrowserBack" },

  { GF_KEY_BROWSERFAVORITES, "BrowserFavorites" },

  { GF_KEY_BROWSERFORWARD, "BrowserForward" },

  { GF_KEY_BROWSERHOME, "BrowserHome" },

  { GF_KEY_BROWSERREFRESH, "BrowserRefresh" },

  { GF_KEY_BROWSERSEARCH, "BrowserSearch" },

  { GF_KEY_BROWSERSTOP, "BrowserStop" },

  { GF_KEY_CAPSLOCK, "CapsLock" },

  { GF_KEY_CLEAR, "Clear" },

  { GF_KEY_CODEINPUT, "CodeInput" },

  { GF_KEY_COMPOSE, "Compose" },

  { GF_KEY_CONTROL, "Control" },

  { GF_KEY_CRSEL, "Crsel" },

  { GF_KEY_CONVERT, "Convert" },

  { GF_KEY_COPY, "Copy"  },

  { GF_KEY_CUT, "Cut" },

  { GF_KEY_DOWN, "Down" },

  { GF_KEY_END, "End" },

  { GF_KEY_ENTER, "Enter" },

  { GF_KEY_ERASEEOF, "EraseEof" },

  { GF_KEY_EXECUTE, "Execute" },

  { GF_KEY_EXSEL, "Exsel" },

  { GF_KEY_F1, "F1" },

  { GF_KEY_F2, "F2" },

  { GF_KEY_F3, "F3" },

  { GF_KEY_F4, "F4" },

  { GF_KEY_F5, "F5" },

  { GF_KEY_F6, "F6" },

  { GF_KEY_F7, "F7" },

  { GF_KEY_F8, "F8" },

  { GF_KEY_F9, "F9" },

  { GF_KEY_F10, "F10" },

  { GF_KEY_F11, "F11" },

  { GF_KEY_F12, "F12" },

  { GF_KEY_F13, "F13" },

  { GF_KEY_F14, "F14" },

  { GF_KEY_F15, "F15" },

  { GF_KEY_F16, "F16" },

  { GF_KEY_F17, "F17" },

  { GF_KEY_F18, "F18" },

  { GF_KEY_F19, "F19" },

  { GF_KEY_F20, "F20" },

  { GF_KEY_F21, "F21" },

  { GF_KEY_F22, "F22" },

  { GF_KEY_F23, "F23" },

  { GF_KEY_F24, "F24" },

  { GF_KEY_FINALMODE, "FinalMode" },

  { GF_KEY_FIND, "Find" },

  { GF_KEY_FULLWIDTH, "FullWidth" },

  { GF_KEY_HALFWIDTH, "HalfWidth" },

  { GF_KEY_HANGULMODE, "HangulMode" },

  { GF_KEY_HANJAMODE, "HanjaMode"   },

  { GF_KEY_HELP, "Help" },

  { GF_KEY_HIRAGANA, "Hiragana" },

  { GF_KEY_HOME, "Home" },

  { GF_KEY_INSERT, "Insert" },

  { GF_KEY_JAPANESEHIRAGANA, "JapaneseHiragana" },

  { GF_KEY_JAPANESEKATAKANA, "JapaneseKatakana" },

  { GF_KEY_JAPANESEROMAJI, "JapaneseRomaji" },

  { GF_KEY_JUNJAMODE, "JunjaMode" },

  { GF_KEY_KANAMODE, "KanaMode"   },

  { GF_KEY_KANJIMODE, "KanjiMode" },

  { GF_KEY_KATAKANA, "Katakana"   },

  { GF_KEY_LAUNCHAPPLICATION1, "LaunchApplication1" },

  { GF_KEY_LAUNCHAPPLICATION2, "LaunchApplication2" },

  { GF_KEY_LAUNCHMAIL, "LaunchMail" },

  { GF_KEY_LEFT, "Left" },

  { GF_KEY_META, "Meta" },

  { GF_KEY_MEDIANEXTTRACK, "MediaNextTrack" },

  { GF_KEY_MEDIAPLAYPAUSE, "MediaPlayPause" },

  { GF_KEY_MEDIAPREVIOUSTRACK, "MediaPreviousTrack" },

  { GF_KEY_MEDIASTOP, "MediaStop" },

  { GF_KEY_MODECHANGE, "ModeChange" },

  { GF_KEY_NONCONVERT, "Nonconvert" },

  { GF_KEY_NUMLOCK, "NumLock" },

  { GF_KEY_PAGEDOWN, "PageDown" },

  { GF_KEY_PAGEUP, "PageUp" },

  { GF_KEY_PASTE, "Paste" },

  { GF_KEY_PAUSE, "Pause" },

  { GF_KEY_PLAY, "Play" },

  { GF_KEY_PREVIOUSCANDIDATE, "PreviousCandidate" },

  { GF_KEY_PRINTSCREEN, "PrintScreen" },

  { GF_KEY_PROCESS, "Process" },

  { GF_KEY_PROPS, "Props" },

  { GF_KEY_RIGHT, "Right" },

  { GF_KEY_ROMANCHARACTERS, "RomanCharacters" },

  { GF_KEY_SCROLL, "Scroll" },

  { GF_KEY_SELECT, "Select" },

  { GF_KEY_SELECTMEDIA, "SelectMedia" },

  { GF_KEY_SHIFT, "Shift" },

  { GF_KEY_STOP, "Stop" },

  { GF_KEY_UP, "Up" },

  { GF_KEY_UNDO, "Undo" },

  { GF_KEY_VOLUMEDOWN, "VolumeDown" },

  { GF_KEY_VOLUMEMUTE, "VolumeMute" },

  { GF_KEY_VOLUMEUP, "VolumeUp" },

  { GF_KEY_WIN, "Win" },

  { GF_KEY_ZOOM, "Zoom" },

  { GF_KEY_BACKSPACE, "U+0008", "backspace" },

  { GF_KEY_TAB, "U+0009", "tab" },

  { GF_KEY_CANCEL, "U+0018", "cancel" },

  { GF_KEY_ESCAPE, "U+001B", "esc" },

  { GF_KEY_SPACE, "U+0020", "space" },

  { GF_KEY_EXCLAMATION, "U+0021", "!" },

  { GF_KEY_QUOTATION, "U+0022", "\"" },

  { GF_KEY_NUMBER, "U+0023", "#" },

  { GF_KEY_DOLLAR, "U+0024", "$" },

  { GF_KEY_AMPERSAND, "U+0026", "&" },

  { GF_KEY_APOSTROPHE, "U+0027", "'" },

  { GF_KEY_LEFTPARENTHESIS, "U+0028", "(" },

  { GF_KEY_RIGHTPARENTHESIS, "U+0029", ")" },

  { GF_KEY_STAR, "U+002A", "*" },

  { GF_KEY_PLUS, "U+002B", "+" },

  { GF_KEY_COMMA, "U+002C", "," },

  { GF_KEY_HYPHEN, "U+002D", "-" },

  { GF_KEY_FULLSTOP, "U+002E", "." },

  { GF_KEY_SLASH, "U+002F", "/" },

  { GF_KEY_0, "U+0030", "0" },

  { GF_KEY_1, "U+0031", "1" },

  { GF_KEY_2, "U+0032", "2" },

  { GF_KEY_3, "U+0033", "3" },

  { GF_KEY_4, "U+0034", "4" },

  { GF_KEY_5, "U+0035", "5" },

  { GF_KEY_6, "U+0036", "6" },

  { GF_KEY_7, "U+0037", "7" },

  { GF_KEY_8, "U+0038", "8" },

  { GF_KEY_9, "U+0039", "9" },

  { GF_KEY_COLON, "U+003A", ":" },

  { GF_KEY_SEMICOLON, "U+003B", ";" },

  { GF_KEY_LESSTHAN, "U+003C", "<" },

  { GF_KEY_EQUALS, "U+003D", "=" },

  { GF_KEY_GREATERTHAN, "U+003E", ">" },

  { GF_KEY_QUESTION, "U+003F", "?" },

  { GF_KEY_AT, "U+0040", "@" },

  { GF_KEY_A, "U+0041", "A" },

  { GF_KEY_B, "U+0042", "B" },

  { GF_KEY_C, "U+0043", "C" },

  { GF_KEY_D, "U+0044", "D" },

  { GF_KEY_E, "U+0045", "E" },

  { GF_KEY_F, "U+0046", "F" },

  { GF_KEY_G, "U+0047", "G" },

  { GF_KEY_H, "U+0048", "H" },

  { GF_KEY_I, "U+0049", "I" },

  { GF_KEY_J, "U+004A", "J" },

  { GF_KEY_K, "U+004B", "K" },

  { GF_KEY_L, "U+004C", "L" },

  { GF_KEY_M, "U+004D", "M" },

  { GF_KEY_N, "U+004E", "N" },

  { GF_KEY_O, "U+004F", "O" },

  { GF_KEY_P, "U+0050", "P" },

  { GF_KEY_Q, "U+0051", "Q" },

  { GF_KEY_R, "U+0052", "R" },

  { GF_KEY_S, "U+0053", "S" },

  { GF_KEY_T, "U+0054", "T" },

  { GF_KEY_U, "U+0055", "U" },

  { GF_KEY_V, "U+0056", "V" },

  { GF_KEY_W, "U+0057", "W" },

  { GF_KEY_X, "U+0058", "X" },

  { GF_KEY_Y, "U+0059", "Y" },

  { GF_KEY_Z, "U+005A", "Z" },

  { GF_KEY_LEFTSQUAREBRACKET, "U+005B", "[" },

  { GF_KEY_BACKSLASH, "U+005C", "\\" },

  { GF_KEY_RIGHTSQUAREBRACKET, "U+005D", "]" },

  { GF_KEY_CIRCUM, "U+005E", "^" },

  { GF_KEY_UNDERSCORE, "U+005F", "_" },

  { GF_KEY_GRAVEACCENT, "U+0060", "`" },

  { GF_KEY_LEFTCURLYBRACKET, "U+007B", "{" },

  { GF_KEY_PIPE, "U+007C", "|" },

  { GF_KEY_RIGHTCURLYBRACKET, "U+007D", "}" },

  { GF_KEY_DEL, "U+007F", "del" },

  { GF_KEY_INVERTEXCLAMATION, "U+00A1" },

  { GF_KEY_DEADGRAVE, "U+0300" },

  { GF_KEY_DEADEACUTE, "U+0301" },

  { GF_KEY_DEADCIRCUM, "U+0302" },

  { GF_KEY_DEADTILDE, "U+0303" },

  { GF_KEY_DEADMACRON, "U+0304" },

  { GF_KEY_DEADBREVE, "U+0306" },

  { GF_KEY_DEADABOVEDOT, "U+0307" },

  { GF_KEY_DEADDIARESIS, "U+0308" },

  { GF_KEY_DEADRINGABOVE, "U+030A" },

  { GF_KEY_DEADDOUBLEACUTE, "U+030B" },

  { GF_KEY_DEADCARON, "U+030C" },

  { GF_KEY_DEADCEDILLA, "U+0327" },

  { GF_KEY_DEADOGONEK, "U+0328" },

  { GF_KEY_DEADIOTA, "U+0345" },

  { GF_KEY_EURO, "U+20AC"},

  { GF_KEY_DEADVOICESOUND, "U+3099" },

  { GF_KEY_DEADSEMIVOICESOUND, "U+309A" },

  { GF_KEY_CHANNELUP, "ChannelUp" },

  { GF_KEY_CHANNELDOWN, "ChannelDown" },

  { GF_KEY_TEXT, "Text" },

  { GF_KEY_INFO, "Info" },

  { GF_KEY_EPG, "EPG" },

  { GF_KEY_RECORD, "Record" },

  { GF_KEY_BEGINPAGE, "BeginPage" },

  { GF_KEY_CELL_SOFT1, "CELLSOFT1" },

  { GF_KEY_CELL_SOFT2, "CELLSOFT2" },

};

GF_EXPORT

const char *gf_dom_get_key_name(GF_KeyCode key_identifier)

{

  u32 count = sizeof(predefined_key_identifiers) / sizeof(struct predef_keyid);

  if (!key_identifier || count<= (u32) key_identifier) return "Unknown";

  return predefined_key_identifiers[key_identifier-1].name;

}

GF_EXPORT

const char *gf_dom_get_friendly_name(GF_KeyCode key_identifier)

{

  u32 count = sizeof(predefined_key_identifiers) / sizeof(struct predef_keyid);

  if (!key_identifier || count<= (u32) key_identifier) return "Unknown";

  if (predefined_key_identifiers[key_identifier-1].friendly_name)

    return predefined_key_identifiers[key_identifier-1].friendly_name;

  return predefined_key_identifiers[key_identifier-1].name;

}

GF_EXPORT

GF_KeyCode gf_dom_get_key_type(char *key_name)

{

  if (strlen(key_name) == 1) {

    char c[2];

    c[0] = key_name[0];

    c[1] = 0;

    strupr(c);

    if (c[0] >= 'A' && c[0] <= 'Z')

      return (GF_KEY_A + (c[0] - 'A') );

    if (c[0] >= '0' && c[0] <= '9')

      return ( GF_KEY_0 + (c[0] - '0') );

    switch ((u8) c[0]) {

    case '@':

      return GF_KEY_AT;

    case '*':

      return GF_KEY_STAR;

    case '#':

      return GF_KEY_NUMBER;

    case ' ':

      return GF_KEY_SPACE;

    case '!':

      return GF_KEY_EXCLAMATION;

    case '"':

      return GF_KEY_QUOTATION;

    case '$':

      return GF_KEY_DOLLAR;

    case '&':

      return GF_KEY_AMPERSAND;

    case '\'':

      return GF_KEY_APOSTROPHE;

    case '(':

      return GF_KEY_LEFTPARENTHESIS;

    case ')':

      return GF_KEY_RIGHTPARENTHESIS;

    case '+':

      return GF_KEY_PLUS;

    case ',':

      return GF_KEY_COMMA;

    case '-':

      return GF_KEY_HYPHEN;

    case '.':

      return GF_KEY_FULLSTOP;

    case '/':

      return GF_KEY_SLASH;

    case ':':

      return GF_KEY_COLON;

    case ';':

      return GF_KEY_SEMICOLON;

    case '<':

      return GF_KEY_LESSTHAN;

    case '=':

      return GF_KEY_EQUALS;

    case '>':

      return GF_KEY_GREATERTHAN;

    case '?':

      return GF_KEY_QUESTION;

    case '[':

      return GF_KEY_LEFTSQUAREBRACKET;

    case '\\':

      return GF_KEY_BACKSLASH;

    case ']':

      return GF_KEY_RIGHTSQUAREBRACKET;

    case '^':

      return GF_KEY_CIRCUM;

    case '_':

      return GF_KEY_UNDERSCORE;

    case '`':

      return GF_KEY_GRAVEACCENT;

    case '{':

      return GF_KEY_LEFTCURLYBRACKET;

    case '|':

      return GF_KEY_PIPE;

    case '}':

      return GF_KEY_RIGHTCURLYBRACKET;

    case 0xA1:

      return GF_KEY_INVERTEXCLAMATION;

    default:

      return GF_KEY_UNIDENTIFIED;

    }

  } else {

    u32 i, count;

    count = sizeof(predefined_key_identifiers) / sizeof(struct predef_keyid);

    for (i=0; i<count; i++) {

      if (!stricmp(key_name, predefined_key_identifiers[i].name)) {

        return predefined_key_identifiers[i].key_code;

      }

    }

    return GF_KEY_UNIDENTIFIED;

  }

}

/* Basic SVG datatype parsing functions */

/* Basic SVG datatype parsing functions */

static const struct sys_col {

  const char *name;

  u8 type;

} system_colors[] =

{

  {"ActiveBorder", SVG_COLOR_ACTIVE_BORDER},

  {"ActiveCaption", SVG_COLOR_ACTIVE_CAPTION},

  {"AppWorkspace", SVG_COLOR_APP_WORKSPACE},

  {"Background", SVG_COLOR_BACKGROUND},

  {"ButtonFace", SVG_COLOR_BUTTON_FACE},

  {"ButtonHighlight", SVG_COLOR_BUTTON_HIGHLIGHT},

  {"ButtonShadow", SVG_COLOR_BUTTON_SHADOW},

  {"ButtonText", SVG_COLOR_BUTTON_TEXT},

  {"CaptionText", SVG_COLOR_CAPTION_TEXT},

  {"GrayText", SVG_COLOR_GRAY_TEXT},

  {"Highlight", SVG_COLOR_HIGHLIGHT},

  {"HighlightText", SVG_COLOR_HIGHLIGHT_TEXT},

  {"InactiveBorder", SVG_COLOR_INACTIVE_BORDER},

  {"InactiveCaption", SVG_COLOR_INACTIVE_CAPTION},

  {"InactiveCaptionText", SVG_COLOR_INACTIVE_CAPTION_TEXT},

  {"InfoBackground", SVG_COLOR_INFO_BACKGROUND},

  {"InfoText", SVG_COLOR_INFO_TEXT},

  {"Menu", SVG_COLOR_MENU},

  {"MenuText", SVG_COLOR_MENU_TEXT},

  {"Scrollbar", SVG_COLOR_SCROLLBAR},

  {"ThreeDDarkShadow", SVG_COLOR_3D_DARK_SHADOW},

  {"ThreeDFace", SVG_COLOR_3D_FACE},

  {"ThreeDHighlight", SVG_COLOR_3D_HIGHLIGHT},

  {"ThreeDLightShadow", SVG_COLOR_3D_LIGHT_SHADOW},

  {"ThreeDShadow", SVG_COLOR_3D_SHADOW},

  {"Window", SVG_COLOR_WINDOW},

  {"WindowFrame", SVG_COLOR_WINDOW_FRAME},

  {"WindowText", SVG_COLOR_WINDOW_TEXT},

};

/* parses an color from a named color HTML or CSS 2 */

static void svg_parse_named_color(SVG_Color *col, char *attribute_content)

{

  u32 i, count, val;

  val = gf_color_parse(attribute_content);

  if (val) {

    col->red = INT2FIX((val>>16) & 0xFF) / 255;

    col->green = INT2FIX((val>>8) & 0xFF) / 255;

    col->blue = INT2FIX(val & 0xFF) / 255;

    col->type = SVG_COLOR_RGBCOLOR;

    return;

  }

  count = sizeof(system_colors) / sizeof(struct sys_col);

  for (i=0; i<count; i++) {

    if (!strcmp(attribute_content, system_colors[i].name)) {

      col->type = system_colors[i].type;

      return;

    }

  }

}

const char *gf_svg_get_system_paint_server_name(u32 paint_type)

{

  u32 i, count;

  count = sizeof(system_colors) / sizeof(struct sys_col);

  for (i=0; i<count; i++) {

    if (paint_type == system_colors[i].type) return system_colors[i].name;

  }

  return "undefined";

}

u32 gf_svg_get_system_paint_server_type(const char *name)

{

  u32 i, count;

  count = sizeof(system_colors) / sizeof(struct sys_col);

  for (i=0; i<count; i++) {

    if (!strcmp(name, system_colors[i].name)) return system_colors[i].type;

  }

  return 0;

}

/* Reads an SVG Color

   either #RRGGBB, #RGB, rgb(r,g,b) in [0,255] , colorname, or 'r g b' in [0,1]

   ignores any space, comma, semi-column before and any space after

   TODO:

  transform the char into char and duplicate the input, instead of modifying it

    be more robust to errors in color description ex rgb(0 0 0)

*/

static void svg_parse_color(SVG_Color *col, char *attribute_content, GF_Err *out_e)

{

  char *str = attribute_content;

  u32 len = (u32) strlen(attribute_content);

  while (len && (str[strlen(attribute_content)-1] == ' ')) {

    str[len-1] = 0;

    len--;

  }

  while (*str != 0 && (*str == ' ' || *str == ',' || *str == ';')) str++;

  if (!strcmp(str, "currentColor")) {

    col->type = SVG_COLOR_CURRENTCOLOR;

    return;

  } else if (!strcmp(str, "inherit")) {

    col->type = SVG_COLOR_INHERIT;

    return;

  } else if (str[0]=='#') {

    u32 val;

    sscanf(str+1, "%x", &val);

    if (strlen(str) == 7) {

      col->red = INT2FIX((val>>16) & 0xFF) / 255;

      col->green = INT2FIX((val>>8) & 0xFF) / 255;

      col->blue = INT2FIX(val & 0xFF) / 255;

    } else {

      col->red = INT2FIX((val>>8) & 0xF) / 15;

      col->green = INT2FIX((val>>4) & 0xF) / 15;

      col->blue = INT2FIX(val & 0xF) / 15;

    }

    col->type = SVG_COLOR_RGBCOLOR;

  } else if (strstr(str, "rgb(") || strstr(str, "RGB(")) {

    Float _val;

    u8 is_percentage= 0;

    if (strstr(str, "%")) is_percentage = 1;

    str = strstr(str, "(");

    str++;

    sscanf(str, "%f", &_val);

    col->red = FLT2FIX(_val);

    str = strstr(str, ",");

    if (!str) {

      /* space separated colors/percentages are not allowed neither in SVG 1.1 nor in SVG T1.2 */

      col->red = col->green = col->blue = 0;

      return;

    }

    str++;

    sscanf(str, "%f", &_val);

    col->green = FLT2FIX(_val);

    str = strstr(str, ",");

    if (!str) {

      /* space separated colors/percentages are not allowed neither in SVG 1.1 nor in SVG T1.2 */

      col->red = col->green = col->blue = 0;

      return;

    }

    str++;

    sscanf(str, "%f", &_val);

    col->blue = FLT2FIX(_val);

    if (is_percentage) {

      col->red /= 100;

      col->green /= 100;

      col->blue /= 100;

    } else {

      col->red /= 255;

      col->green /= 255;

      col->blue /= 255;

    }

    col->type = SVG_COLOR_RGBCOLOR;

  } else if ((str[0] >= 'a' && str[0] <= 'z')

             || (str[0] >= 'A' && str[0] <= 'Z')) {

    svg_parse_named_color(col, str);

  } else {

    Float _r, _g, _b;

    if (sscanf(str, "%f %f %f", &_r, &_g, &_b)==3) {

      col->red = FLT2FIX(_r);

      col->green = FLT2FIX(_g);

      col->blue = FLT2FIX(_b);

      col->type = SVG_COLOR_RGBCOLOR;

    } else {

      *out_e = GF_NON_COMPLIANT_BITSTREAM;

    }

  }

}

/*

  Reads a number (i.e. without unit) according to the CSS syntax (same as SVG paths and transforms)

    trims any space, comma, semi-column before or after (TODO: fix this)

    reads an optional + or -

    then reads a digit between 0 and 9

    optionally followed by an '.' and digits between 0 and 9

    optionally followed by e or E and digits between 0 and 9

  Returns the number of chars read in d

*/

static u32 svg_parse_number(char *d, Fixed *f, Bool is_angle, GF_Err *out_e)

{

  u32 nb_digit_before = 0;

  u32 nb_digit_after = 0;

  Bool has_fractional = 0;

  Bool is_negative = 0;

  Float _val = 0;

  u32 i = 0;

  /* warning the comma and semicolumn should not be there when parsing a number in a path */

  while ((d[i] != 0) && strchr(" ,;\r\n\t", d[i])) i++;

  if (!d[i]) {

    GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("[SVG Parsing] Parsing number with empty string or only spaces: %s\n", d));

    *out_e = GF_NON_COMPLIANT_BITSTREAM;

    return 0;

  }

  if (d[i] == '+') {

    i++;

  } else if (d[i] == '-') {

    is_negative = 1;

    i++;

  }

  /* Warning: this is not normal, should be detected somehow by checking the BNF */

  /* if ((d[i]=='N') && (d[i+1]=='a') && (d[i+2]=='N')) {

    i+= 3;

    _val = 0;

    goto end;

  }*/

  /* read the digit-sequence token of the BNF */

  while (d[i] >= '0' && d[i] <= '9' && d[i] != 0) {

    _val = _val*10 + (d[i]-'0');

    nb_digit_before++;

    i++;

  }

  if (d[i] == '.') {

    has_fractional = 1;

    i++;

    while (d[i] >= '0' && d[i] <= '9' && d[i] != 0) {

      _val = _val*10 + (d[i]-'0');

      nb_digit_after++;

      i++;

    }

    if (nb_digit_after) {

      _val /= (Float)pow(10,nb_digit_after);

    } else if (nb_digit_before == 0) {

      GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error in parsing number (expecting digits before or after a '.': %s\n", d));

      *out_e = GF_NON_COMPLIANT_BITSTREAM;

      return 0;

    } else {

      /* dangling '.' without digits after. This is allowed by the BNF */

    }

  }

  if ((nb_digit_before == 0) && (has_fractional == 0)) {

    GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error in parsing number (expecting digits):%s\n", d));

    *out_e = GF_NON_COMPLIANT_BITSTREAM;

    return 0;

  }

  /* reading the exponent */

  if (d[i] == 'e' || d[i] == 'E') {

    Bool neg_exp = 0;

    u32 nb_exp_digits = 0;

    s32 exp = 0;

    i++;

    if (d[i] == '+') i++;

    else if (d[i] == '-') {

      i++;

      neg_exp=1;

    }

    while (d[i] >= '0' && d[i] <= '9' && d[i] != 0) {

      exp = exp*10 + (d[i]-'0');

      nb_exp_digits++;

      i++;

    }

    if (nb_exp_digits) {

      _val *= (Float)pow(10, neg_exp ? -exp : exp);

    } else {

      GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error in parsing exponent, 'e' or 'E' should be followed by digits: %s\n", d));

      *out_e = GF_NON_COMPLIANT_BITSTREAM;

      return 0;

    }

  }

  /* We can now produce the final number */

  if (is_negative) _val *= -1;

  if (is_angle) {

    _val/=180;

    (*f) = gf_mulfix(FLT2FIX(_val), GF_PI);

  } else {

    (*f) = FLT2FIX(_val);

  }

  /* warning the comma and semicolumn should not be there when parsing a path number */

  while (d[i] != 0 && (d[i] == ' ' || d[i] == ',' || d[i] == ';')) i++;

  return i;

}

/*

   Parse an Offset Value, i.e +/- Clock Value

*/

static GF_Err svg_parse_clock_value(char *d, Double *clock_value)

{

  char *tmp;

  s32 sign = 1;

  if (!d) return GF_BAD_PARAM;

  if (!d[0]) return GF_BAD_PARAM;

  if (d[0] == '+') d++;

  else if (d[0] == '-') {

    sign = -1;

    d++;

  }

  if (!d[0]) return GF_BAD_PARAM;

  /* According to SVG, the following are invalid syntaxes (see animate-elem-225-t.svg)

    '+-2s'

    '1++s' even though sscanf returns the right values

  */

  if (strpbrk(d, "+-")) return GF_BAD_PARAM;

  /* No embedded white space is allowed in clock values,

     although leading and trailing white space characters will be ignored.*/

  while (*d == ' ') d++;

  if ((tmp = strchr(d, ':'))) {

    /* Full or Partial Clock value */

    tmp++;

    if ((tmp = strchr(tmp, ':'))) {

      /* Full Clock value : hh:mm:ss(.frac) */

      u32 hours;

      u32 minutes;

      Float seconds;

      if (sscanf(d, "%u:%u:%f", &hours, &minutes, &seconds) < 3) return GF_BAD_PARAM;

      *clock_value = hours*3600 + minutes*60 + seconds;

    } else {

      /* Partial Clock value : mm:ss(.frac) */

      s32 minutes;

      Float seconds;

      if (sscanf(d, "%d:%f", &minutes, &seconds) < 2) return GF_BAD_PARAM;

      *clock_value = minutes*60 + seconds;

    }

  } else if ((tmp = strstr(d, "h"))) {

    Float f;

    if (sscanf(d, "%fh", &f) == 0) return GF_BAD_PARAM;

    *clock_value = 3600*f;

  } else if (strstr(d, "min")) {

    Float f;

    if (sscanf(d, "%fmin", &f) == 0) return GF_BAD_PARAM;

    *clock_value = 60*f;

  } else if ((tmp = strstr(d, "ms"))) {

    Float f;

    if (sscanf(d, "%fms", &f) == 0) return GF_BAD_PARAM;

    *clock_value = f/1000;

  } else if (strchr(d, 's')) {

    Float f;

    if (sscanf(d, "%fs", &f) == 0) return GF_BAD_PARAM;

    *clock_value = f;

  } else {

    Float f;