PageRenderTime 83ms CodeModel.GetById 16ms RepoModel.GetById 1ms app.codeStats 0ms

/src/scenegraph/svg_attributes.c

https://github.com/svettom/gpac
C | 6454 lines | 5969 code | 326 blank | 159 comment | 1469 complexity | 18d4b2816d8a3b02f0d6947c3f58ec2a MD5 | raw file
Possible License(s): LGPL-2.1, GPL-2.0 
    

  1. /*
    2. 

  2.  *					GPAC Multimedia Framework
    3. 

  3.  *
    4. 

  4.  *			Authors: Cyril Concolato, Jean Le Feuvre
    5. 

  5.  *			Copyright (c) Telecom ParisTech 2004-2012
    6. 

  6.  *					All rights reserved
    7. 

  7.  *
    8. 

  8.  *  This file is part of GPAC / SVG Loader module
    9. 

  9.  *
    10. 

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

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

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

  13.  *  any later version.
    14. 

  14.  *
    15. 

  15.  *  GPAC is distributed in the hope that it will be useful,
    16. 

  16.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
    17. 

  17.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    18. 

  18.  *  GNU Lesser General Public License for more details.
    19. 

  19.  *
    20. 

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

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

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

  23.  *
    24. 

  24.  */
    25. 

  25. 

  26. #include "../../include/gpac/base_coding.h"
    27. 

  27. #include "../../include/gpac/events.h"
    28. 

  28. #include "../../include/gpac/nodes_svg.h"
    29. 

  29. 

  30. #ifndef GPAC_DISABLE_SVG
    31. 

  31. 

  32. #include "../../include/gpac/internal/scenegraph_dev.h"
    33. 

  33. 

  34. #define DUMP_COORDINATES 1
    35. 

  35. 

  36. 

  37. static const struct dom_event_def {u32 event;  const char *name; u32 category; } defined_dom_events [] =
    38. 

  38. {
    39. 

  39. 	{ GF_EVENT_ABORT, "abort", GF_DOM_EVENT_DOM },
    40. 

  40. 	{ GF_EVENT_ERROR, "error", GF_DOM_EVENT_DOM },
    41. 

  41. 	{ GF_EVENT_LOAD, "load", GF_DOM_EVENT_DOM },
    42. 

  42. 	{ GF_EVENT_UNLOAD, "unload", GF_DOM_EVENT_DOM },
    43. 

  43. 

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

  45. 	{ GF_EVENT_FOCUSIN, "DOMFocusIn", GF_DOM_EVENT_FOCUS },
    46. 

  46. 	{ GF_EVENT_FOCUSIN, "focusin", GF_DOM_EVENT_FOCUS },
    47. 

  47. 	{ GF_EVENT_FOCUSOUT, "DOMFocusOut", GF_DOM_EVENT_FOCUS },
    48. 

  48. 	{ GF_EVENT_FOCUSOUT, "focusout", GF_DOM_EVENT_FOCUS },
    49. 

  49. 	{ GF_EVENT_CHANGE, "change", GF_DOM_EVENT_FOCUS },
    50. 

  50. 	{ GF_EVENT_FOCUS, "focus", GF_DOM_EVENT_FOCUS },
    51. 

  51. 	{ GF_EVENT_BLUR, "blur", GF_DOM_EVENT_FOCUS },
    52. 

  52. 

  53. 	/*key events*/
    54. 

  54. 	{ GF_EVENT_KEYDOWN, "keydown", GF_DOM_EVENT_KEY },
    55. 

  55. 	{ GF_EVENT_KEYDOWN, "accesskey", GF_DOM_EVENT_KEY },
    56. 

  56. 	{ GF_EVENT_KEYDOWN, "keypress", GF_DOM_EVENT_KEY },
    57. 

  57. 	{ GF_EVENT_KEYUP, "keyup", GF_DOM_EVENT_KEY },
    58. 

  58. 	{ GF_EVENT_LONGKEYPRESS, "longaccesskey", GF_DOM_EVENT_KEY },
    59. 

  59. 

  60. 	{ GF_EVENT_CLICK, "click", GF_DOM_EVENT_MOUSE },
    61. 

  61. 	{ GF_EVENT_DBLCLICK, "dblclick", GF_DOM_EVENT_MOUSE },
    62. 

  62. 	{ GF_EVENT_MOUSEDOWN, "mousedown", GF_DOM_EVENT_MOUSE },
    63. 

  63. 	{ GF_EVENT_MOUSEMOVE, "mousemove", GF_DOM_EVENT_MOUSE },
    64. 

  64. 	{ GF_EVENT_MOUSEOUT, "mouseout", GF_DOM_EVENT_MOUSE },
    65. 

  65. 	{ GF_EVENT_MOUSEOVER, "mouseover", GF_DOM_EVENT_MOUSE },
    66. 

  66. 	{ GF_EVENT_MOUSEUP, "mouseup", GF_DOM_EVENT_MOUSE },
    67. 

  67. 	{ GF_EVENT_MOUSEWHEEL, "wheel", GF_DOM_EVENT_MOUSE },
    68. 

  68. 	{ GF_EVENT_MOUSEWHEEL, "SVGMousewheel", GF_DOM_EVENT_MOUSE },
    69. 

  69. 

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

  71. 	{ GF_EVENT_ACTIVATE, "activate", GF_DOM_EVENT_MOUSE | GF_DOM_EVENT_KEY },
    72. 

  72. 	{ GF_EVENT_ACTIVATE, "DOMActivate", GF_DOM_EVENT_MOUSE | GF_DOM_EVENT_KEY },
    73. 

  73. 

  74. 	/*text events*/
    75. 

  75. 	{ GF_EVENT_TEXTINPUT, "textInput", GF_DOM_EVENT_TEXT },
    76. 

  76. 	{ GF_EVENT_TEXTSELECT, "select", GF_DOM_EVENT_TEXT },
    77. 

  77. 

  78. 	/*SMIL events*/
    79. 

  79. 	{ GF_EVENT_BEGIN, "begin", GF_DOM_EVENT_FAKE },
    80. 

  80. 	{ GF_EVENT_BEGIN_EVENT, "beginEvent", GF_DOM_EVENT_SMIL },
    81. 

  81. 	{ GF_EVENT_END, "end", GF_DOM_EVENT_FAKE },
    82. 

  82. 	{ GF_EVENT_END_EVENT, "endEvent", GF_DOM_EVENT_SMIL },
    83. 

  83. 	{ GF_EVENT_REPEAT, "repeat", GF_DOM_EVENT_FAKE },
    84. 

  84. 	{ GF_EVENT_REPEAT_EVENT, "repeatEvent", GF_DOM_EVENT_SMIL },
    85. 

  85. 

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

  87. 	{ GF_EVENT_RESIZE, "resize", GF_DOM_EVENT_UI },
    88. 

  88. 	{ GF_EVENT_SCROLL, "scroll", GF_DOM_EVENT_UI },
    89. 

  89. 	{ GF_EVENT_ZOOM, "zoom", GF_DOM_EVENT_UI },
    90. 

  90. 

  91. 

  92. 	{ GF_EVENT_LOAD, "SVGLoad", GF_DOM_EVENT_DOM },
    93. 

  93. 	{ GF_EVENT_RESIZE, "SVGResize", GF_DOM_EVENT_UI },
    94. 

  94. 	{ GF_EVENT_SCROLL, "SVGScroll", GF_DOM_EVENT_UI },
    95. 

  95. 	{ GF_EVENT_ZOOM, "SVGZoom", GF_DOM_EVENT_UI },
    96. 

  96. 

  97. 	/*mutation events and DCCI*/
    98. 

  98. 	{ GF_EVENT_TREE_MODIFIED, "DOMSubtreeModified", GF_DOM_EVENT_MUTATION },
    99. 

  99. 	{ GF_EVENT_NODE_INSERTED, "DOMNodeInserted", GF_DOM_EVENT_MUTATION },
    100. 

  100. 	{ GF_EVENT_NODE_REMOVED, "DOMNodeRemoved", GF_DOM_EVENT_MUTATION },
    101. 

  101. 	{ GF_EVENT_NODE_REMOVED_DOC, "DOMNodeRemovedFromDocument", GF_DOM_EVENT_MUTATION },
    102. 

  102. 	{ GF_EVENT_NODE_INSERTED_DOC, "DOMNodeInsertedIntoDocument", GF_DOM_EVENT_MUTATION },
    103. 

  103. 	{ GF_EVENT_ATTR_MODIFIED, "DOMAttrModified", GF_DOM_EVENT_MUTATION },
    104. 

  104. 	{ GF_EVENT_CHAR_DATA_MODIFIED, "DOMCharacterDataModified", GF_DOM_EVENT_MUTATION },
    105. 

  105. 	{ GF_EVENT_NODE_NAME_CHANGED, "DOMElementNameChanged", GF_DOM_EVENT_MUTATION },
    106. 

  106. 	{ GF_EVENT_ATTR_NAME_CHANGED, "DOMAttributeNameChanged", GF_DOM_EVENT_MUTATION },
    107. 

  107. 	{ GF_EVENT_DCCI_PROP_CHANGE, "DCCI-prop-change", GF_DOM_EVENT_MUTATION },
    108. 

  108. 

  109. 	/*LASeR events - some events are attached to other categorues*/
    110. 

  110. 	{ GF_EVENT_ACTIVATED, "activatedEvent", GF_DOM_EVENT_LASER },
    111. 

  111. 	{ GF_EVENT_DEACTIVATED, "deactivatedEvent", GF_DOM_EVENT_LASER },
    112. 

  112. 	{ GF_EVENT_EXECUTION_TIME, "executionTime", GF_DOM_EVENT_FAKE },
    113. 

  113. 	{ GF_EVENT_PAUSE, "pause", GF_DOM_EVENT_SMIL },
    114. 

  114. 	{ GF_EVENT_PAUSED_EVENT, "pausedEvent", GF_DOM_EVENT_SMIL },
    115. 

  115. 	{ GF_EVENT_PLAY, "play", GF_DOM_EVENT_SMIL },
    116. 

  116. 	{ GF_EVENT_RESUME_EVENT, "resumedEvent", GF_DOM_EVENT_SMIL },
    117. 

  117. 	{ GF_EVENT_REPEAT_KEY, "repeatKey", GF_DOM_EVENT_KEY },
    118. 

  118. 	{ GF_EVENT_SHORT_ACCESSKEY, "shortAccessKey", GF_DOM_EVENT_KEY },
    119. 

  119. 

  120. 	/*LASeR unofficial events*/
    121. 

  121. 	{ GF_EVENT_BATTERY, "battery", GF_DOM_EVENT_LASER },
    122. 

  122. 	{ GF_EVENT_CPU, "cpu", GF_DOM_EVENT_LASER },
    123. 

  123. 

  124. 	/*MediaAccess events*/
    125. 

  125. #if 0
    126. 

  126. 	{ GF_EVENT_MEDIA_BEGIN_SESSION_SETUP, "BeginSessionSetup", GF_DOM_EVENT_MEDIA_ACCESS },
    127. 

  127. 	{ GF_EVENT_MEDIA_END_SESSION_SETUP, "EndSessionSetup", GF_DOM_EVENT_MEDIA_ACCESS },
    128. 

  128. 	{ GF_EVENT_MEDIA_DATA_REQUEST, "DataRequest", GF_DOM_EVENT_MEDIA_ACCESS },
    129. 

  129. 	{ GF_EVENT_MEDIA_PLAYABLE, "Playable", GF_DOM_EVENT_MEDIA_ACCESS },
    130. 

  130. 	{ GF_EVENT_MEDIA_NOT_PLAYABLE, "NotPlayable", GF_DOM_EVENT_MEDIA_ACCESS },
    131. 

  131. 	{ GF_EVENT_MEDIA_DATA_PROGRESS, "DataReceptionProgress", GF_DOM_EVENT_MEDIA_ACCESS },
    132. 

  132. 	{ GF_EVENT_MEDIA_END_OF_DATA, "EndOfDataReception", GF_DOM_EVENT_MEDIA_ACCESS },
    133. 

  133. 	{ GF_EVENT_MEDIA_STOP, "Stop", GF_DOM_EVENT_MEDIA_ACCESS },
    134. 

  134. 	{ GF_EVENT_MEDIA_ERROR, "Error", GF_DOM_EVENT_MEDIA_ACCESS },
    135. 

  135. #endif
    136. 

  136. 

  137. 	{ GF_EVENT_MEDIA_SETUP_BEGIN, "setupbegin", GF_DOM_EVENT_MEDIA},
    138. 

  138. 	{ GF_EVENT_MEDIA_SETUP_DONE, "setupdone", GF_DOM_EVENT_MEDIA},
    139. 

  139. 

  140. 	{ GF_EVENT_MEDIA_LOAD_START, "loadstart", GF_DOM_EVENT_MEDIA },
    141. 

  141. 	{ GF_EVENT_MEDIA_LOAD_DONE, "loaddone", GF_DOM_EVENT_MEDIA },
    142. 

  142. 	{ GF_EVENT_MEDIA_PROGRESS, "progress", GF_DOM_EVENT_MEDIA },
    143. 

  143. 	{ GF_EVENT_MEDIA_SUSPEND, "suspend", GF_DOM_EVENT_MEDIA },
    144. 

  144. 	{ GF_EVENT_ABORT, "abort", GF_DOM_EVENT_MEDIA },
    145. 

  145. 	{ GF_EVENT_ERROR, "error", GF_DOM_EVENT_MEDIA },
    146. 

  146. 	{ GF_EVENT_MEDIA_EMPTIED, "emptied", GF_DOM_EVENT_MEDIA },
    147. 

  147. 	{ GF_EVENT_MEDIA_STALLED, "stalled", GF_DOM_EVENT_MEDIA },
    148. 

  148. 	{ GF_EVENT_MEDIA_LOADED_METADATA, "loadedmetadata", GF_DOM_EVENT_MEDIA },
    149. 

  149. 	{ GF_EVENT_MEDIA_LODADED_DATA, "loadeddata", GF_DOM_EVENT_MEDIA },
    150. 

  150. 	{ GF_EVENT_MEDIA_CANPLAY, "canplay", GF_DOM_EVENT_MEDIA },
    151. 

  151. 	{ GF_EVENT_MEDIA_CANPLAYTHROUGH, "canplaythrough", GF_DOM_EVENT_MEDIA },
    152. 

  152. 	{ GF_EVENT_MEDIA_PLAYING, "playing", GF_DOM_EVENT_MEDIA },
    153. 

  153. 	{ GF_EVENT_MEDIA_WAITING, "waiting", GF_DOM_EVENT_MEDIA },
    154. 

  154. 	{ GF_EVENT_MEDIA_SEEKING, "seeking", GF_DOM_EVENT_MEDIA },
    155. 

  155. 	{ GF_EVENT_MEDIA_SEEKED, "seeked", GF_DOM_EVENT_MEDIA },
    156. 

  156. 	{ GF_EVENT_MEDIA_ENDED, "ended", GF_DOM_EVENT_MEDIA },
    157. 

  157. 	{ GF_EVENT_MEDIA_DURATION_CHANGED, "durationchanged", GF_DOM_EVENT_MEDIA },
    158. 

  158. 	{ GF_EVENT_MEDIA_TIME_UPDATE, "timeupdate", GF_DOM_EVENT_MEDIA },
    159. 

  159. 	{ GF_EVENT_PLAY, "play", GF_DOM_EVENT_MEDIA },
    160. 

  160. 	{ GF_EVENT_PAUSE, "pause", GF_DOM_EVENT_MEDIA },
    161. 

  161. 	{ GF_EVENT_MEDIA_RATECHANGE, "ratechange", GF_DOM_EVENT_MEDIA },
    162. 

  162. 	{ GF_EVENT_MEDIA_VOLUME_CHANGED, "volumechange", GF_DOM_EVENT_MEDIA },
    163. 

  163. 

  164. 	/* Media Source Events */
    165. 

  165. 	{ GF_EVENT_HTML_MSE_SOURCE_OPEN, "sourceopen", GF_DOM_EVENT_MEDIASOURCE },
    166. 

  166. 	{ GF_EVENT_HTML_MSE_SOURCE_ENDED, "sourceended", GF_DOM_EVENT_MEDIASOURCE },
    167. 

  167. 	{ GF_EVENT_HTML_MSE_SOURCE_CLOSE, "sourceclose", GF_DOM_EVENT_MEDIASOURCE },
    168. 

  168. 	{ GF_EVENT_HTML_MSE_APPEND_START, "appendstart", GF_DOM_EVENT_MEDIASOURCE },
    169. 

  169. 	{ GF_EVENT_HTML_MSE_APPEND_END, "appendend", GF_DOM_EVENT_MEDIASOURCE },
    170. 

  170. 	{ GF_EVENT_HTML_MSE_APPEND_ERROR, "error", GF_DOM_EVENT_MEDIASOURCE },
    171. 

  171. 	{ GF_EVENT_HTML_MSE_APPEND_ABORT, "abort", GF_DOM_EVENT_MEDIASOURCE },
    172. 

  172. 	{ GF_EVENT_HTML_MSE_ADD_SOURCE_BUFFER, "addsourcebuffer", GF_DOM_EVENT_MEDIASOURCE },
    173. 

  173. 	{ GF_EVENT_HTML_MSE_REMOVE_SOURCE_BUFFER, "removesourcebuffer", GF_DOM_EVENT_MEDIASOURCE },
    174. 

  174. 

  175. 	/*GPAC internals*/
    176. 

  176. 	{ GF_EVENT_SCENE_ATTACHED, "gpac_scene_attached", GF_DOM_EVENT_DOM },
    177. 

  177. 	{ GF_EVENT_VP_RESIZE, "gpac_vp_changed", GF_DOM_EVENT_DOM },
    178. 

  178. };
    179. 

  179. 

  180. GF_EXPORT
    181. 

  181. u32 gf_dom_event_type_by_name(const char *name)
    182. 

  182. {
    183. 

  183. 	u32 i, count;
    184. 

  184. 	count = sizeof(defined_dom_events) / sizeof(struct dom_event_def);
    185. 

  185. 	if (!name) return GF_EVENT_UNKNOWN;
    186. 

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

  187. 	for (i=0;i<count;i++) {
    188. 

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

  189. 			return defined_dom_events[i].event;
    190. 

  190. 	}
    191. 

  191. 	return GF_EVENT_UNKNOWN;
    192. 

  192. }
    193. 

  193. 

  194. const char *gf_dom_event_get_name(u32 type)
    195. 

  195. {
    196. 

  196. 	u32 i, count;
    197. 

  197. 	count = sizeof(defined_dom_events) / sizeof(struct dom_event_def);
    198. 

  198. 	for (i=0;i<count;i++) {
    199. 

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

  200. 			return defined_dom_events[i].name;
    201. 

  201. 	}
    202. 

  202. 	return "unknown";
    203. 

  203. }
    204. 

  204. 

  205. u32 gf_dom_event_get_category(u32 type)
    206. 

  206. {
    207. 

  207. 	u32 i, count;
    208. 

  208. 	count = sizeof(defined_dom_events) / sizeof(struct dom_event_def);
    209. 

  209. 	for (i=0;i<count;i++) {
    210. 

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

  211. 			return defined_dom_events[i].category;
    212. 

  212. 	}
    213. 

  213. 	return 0;
    214. 

  214. }
    215. 

  215. 

  216. 

  217. static const struct predef_keyid {u32 key_code;  const char *name; } predefined_key_identifiers[] =
    218. 

  218. {
    219. 

  219. 	{ GF_KEY_ACCEPT, "Accept" },
    220. 

  220. 	{ GF_KEY_AGAIN, "Again" },
    221. 

  221. 	{ GF_KEY_ALLCANDIDATES, "AllCandidates" },
    222. 

  222. 	{ GF_KEY_ALPHANUM, "Alphanumeric" },
    223. 

  223. 	{ GF_KEY_ALT, "Alt" },
    224. 

  224. 	{ GF_KEY_ALTGRAPH, "AltGraph" },
    225. 

  225. 	{ GF_KEY_APPS, "Apps" },
    226. 

  226. 	{ GF_KEY_ATTN, "Attn" },
    227. 

  227. 	{ GF_KEY_BROWSERBACK, "BrowserBack" },
    228. 

  228. 	{ GF_KEY_BROWSERFAVORITES, "BrowserFavorites" },
    229. 

  229. 	{ GF_KEY_BROWSERFORWARD, "BrowserForward" },
    230. 

  230. 	{ GF_KEY_BROWSERHOME, "BrowserHome" },
    231. 

  231. 	{ GF_KEY_BROWSERREFRESH, "BrowserRefresh" },
    232. 

  232. 	{ GF_KEY_BROWSERSEARCH, "BrowserSearch" },
    233. 

  233. 	{ GF_KEY_BROWSERSTOP, "BrowserStop" },
    234. 

  234. 	{ GF_KEY_CAPSLOCK, "CapsLock" },
    235. 

  235. 	{ GF_KEY_CLEAR, "Clear" },
    236. 

  236. 	{ GF_KEY_CODEINPUT, "CodeInput" },
    237. 

  237. 	{ GF_KEY_COMPOSE, "Compose" },
    238. 

  238. 	{ GF_KEY_CONTROL, "Control" },
    239. 

  239. 	{ GF_KEY_CRSEL, "Crsel" },
    240. 

  240. 	{ GF_KEY_CONVERT, "Convert" },
    241. 

  241. 	{ GF_KEY_COPY, "Copy"  },
    242. 

  242. 	{ GF_KEY_CUT, "Cut" },
    243. 

  243. 	{ GF_KEY_DOWN, "Down" },
    244. 

  244. 	{ GF_KEY_END, "End" },
    245. 

  245. 	{ GF_KEY_ENTER, "Enter" },
    246. 

  246. 	{ GF_KEY_ERASEEOF, "EraseEof" },
    247. 

  247. 	{ GF_KEY_EXECUTE, "Execute" },
    248. 

  248. 	{ GF_KEY_EXSEL, "Exsel" },
    249. 

  249. 	{ GF_KEY_F1, "F1" },
    250. 

  250. 	{ GF_KEY_F2, "F2" },
    251. 

  251. 	{ GF_KEY_F3, "F3" },
    252. 

  252. 	{ GF_KEY_F4, "F4" },
    253. 

  253. 	{ GF_KEY_F5, "F5" },
    254. 

  254. 	{ GF_KEY_F6, "F6" },
    255. 

  255. 	{ GF_KEY_F7, "F7" },
    256. 

  256. 	{ GF_KEY_F8, "F8" },
    257. 

  257. 	{ GF_KEY_F9, "F9" },
    258. 

  258. 	{ GF_KEY_F10, "F10" },
    259. 

  259. 	{ GF_KEY_F11, "F11" },
    260. 

  260. 	{ GF_KEY_F12, "F12" },
    261. 

  261. 	{ GF_KEY_F13, "F13" },
    262. 

  262. 	{ GF_KEY_F14, "F14" },
    263. 

  263. 	{ GF_KEY_F15, "F15" },
    264. 

  264. 	{ GF_KEY_F16, "F16" },
    265. 

  265. 	{ GF_KEY_F17, "F17" },
    266. 

  266. 	{ GF_KEY_F18, "F18" },
    267. 

  267. 	{ GF_KEY_F19, "F19" },
    268. 

  268. 	{ GF_KEY_F20, "F20" },
    269. 

  269. 	{ GF_KEY_F21, "F21" },
    270. 

  270. 	{ GF_KEY_F22, "F22" },
    271. 

  271. 	{ GF_KEY_F23, "F23" },
    272. 

  272. 	{ GF_KEY_F24, "F24" },
    273. 

  273. 	{ GF_KEY_FINALMODE, "FinalMode" },
    274. 

  274. 	{ GF_KEY_FIND, "Find" },
    275. 

  275. 	{ GF_KEY_FULLWIDTH, "FullWidth" },
    276. 

  276. 	{ GF_KEY_HALFWIDTH, "HalfWidth" },
    277. 

  277. 	{ GF_KEY_HANGULMODE, "HangulMode" },
    278. 

  278. 	{ GF_KEY_HANJAMODE, "HanjaMode"   },
    279. 

  279. 	{ GF_KEY_HELP, "Help" },
    280. 

  280. 	{ GF_KEY_HIRAGANA, "Hiragana" },
    281. 

  281. 	{ GF_KEY_HOME, "Home" },
    282. 

  282. 	{ GF_KEY_INSERT, "Insert" },
    283. 

  283. 	{ GF_KEY_JAPANESEHIRAGANA, "JapaneseHiragana" },
    284. 

  284. 	{ GF_KEY_JAPANESEKATAKANA, "JapaneseKatakana" },
    285. 

  285. 	{ GF_KEY_JAPANESEROMAJI, "JapaneseRomaji" },
    286. 

  286. 	{ GF_KEY_JUNJAMODE, "JunjaMode" },
    287. 

  287. 	{ GF_KEY_KANAMODE, "KanaMode"   },
    288. 

  288. 	{ GF_KEY_KANJIMODE, "KanjiMode" },
    289. 

  289. 	{ GF_KEY_KATAKANA, "Katakana"   },
    290. 

  290. 	{ GF_KEY_LAUNCHAPPLICATION1, "LaunchApplication1" },
    291. 

  291. 	{ GF_KEY_LAUNCHAPPLICATION2, "LaunchApplication2" },
    292. 

  292. 	{ GF_KEY_LAUNCHMAIL, "LaunchMail" },
    293. 

  293. 	{ GF_KEY_LEFT, "Left" },
    294. 

  294. 	{ GF_KEY_META, "Meta" },
    295. 

  295. 	{ GF_KEY_MEDIANEXTTRACK, "MediaNextTrack" },
    296. 

  296. 	{ GF_KEY_MEDIAPLAYPAUSE, "MediaPlayPause" },
    297. 

  297. 	{ GF_KEY_MEDIAPREVIOUSTRACK, "MediaPreviousTrack" },
    298. 

  298. 	{ GF_KEY_MEDIASTOP, "MediaStop" },
    299. 

  299. 	{ GF_KEY_MODECHANGE, "ModeChange" },
    300. 

  300. 	{ GF_KEY_NONCONVERT, "Nonconvert" },
    301. 

  301. 	{ GF_KEY_NUMLOCK, "NumLock" },
    302. 

  302. 	{ GF_KEY_PAGEDOWN, "PageDown" },
    303. 

  303. 	{ GF_KEY_PAGEUP, "PageUp" },
    304. 

  304. 	{ GF_KEY_PASTE, "Paste" },
    305. 

  305. 	{ GF_KEY_PAUSE, "Pause" },
    306. 

  306. 	{ GF_KEY_PLAY, "Play" },
    307. 

  307. 	{ GF_KEY_PREVIOUSCANDIDATE, "PreviousCandidate" },
    308. 

  308. 	{ GF_KEY_PRINTSCREEN, "PrintScreen" },
    309. 

  309. 	{ GF_KEY_PROCESS, "Process" },
    310. 

  310. 	{ GF_KEY_PROPS, "Props" },
    311. 

  311. 	{ GF_KEY_RIGHT, "Right" },
    312. 

  312. 	{ GF_KEY_ROMANCHARACTERS, "RomanCharacters" },
    313. 

  313. 	{ GF_KEY_SCROLL, "Scroll" },
    314. 

  314. 	{ GF_KEY_SELECT, "Select" },
    315. 

  315. 	{ GF_KEY_SELECTMEDIA, "SelectMedia" },
    316. 

  316. 	{ GF_KEY_SHIFT, "Shift" },
    317. 

  317. 	{ GF_KEY_STOP, "Stop" },
    318. 

  318. 	{ GF_KEY_UP, "Up" },
    319. 

  319. 	{ GF_KEY_UNDO, "Undo" },
    320. 

  320. 	{ GF_KEY_VOLUMEDOWN, "VolumeDown" },
    321. 

  321. 	{ GF_KEY_VOLUMEMUTE, "VolumeMute" },
    322. 

  322. 	{ GF_KEY_VOLUMEUP, "VolumeUp" },
    323. 

  323. 	{ GF_KEY_WIN, "Win" },
    324. 

  324. 	{ GF_KEY_ZOOM, "Zoom" },
    325. 

  325. 	{ GF_KEY_BACKSPACE, "U+0008" },
    326. 

  326. 	{ GF_KEY_TAB, "U+0009" },
    327. 

  327. 	{ GF_KEY_CANCEL, "U+0018" },
    328. 

  328. 	{ GF_KEY_ESCAPE, "U+001B" },
    329. 

  329. 	{ GF_KEY_SPACE, "U+0020" },
    330. 

  330. 	{ GF_KEY_EXCLAMATION, "U+0021" },
    331. 

  331. 	{ GF_KEY_QUOTATION, "U+0022" },
    332. 

  332. 	{ GF_KEY_NUMBER, "U+0023" },
    333. 

  333. 	{ GF_KEY_DOLLAR, "U+0024" },
    334. 

  334. 	{ GF_KEY_AMPERSAND, "U+0026" },
    335. 

  335. 	{ GF_KEY_APOSTROPHE, "U+0027" },
    336. 

  336. 	{ GF_KEY_LEFTPARENTHESIS, "U+0028" },
    337. 

  337. 	{ GF_KEY_RIGHTPARENTHESIS, "U+0029" },
    338. 

  338. 	{ GF_KEY_STAR, "U+002A" },
    339. 

  339. 	{ GF_KEY_PLUS, "U+002B" },
    340. 

  340. 	{ GF_KEY_COMMA, "U+002C" },
    341. 

  341. 	{ GF_KEY_HYPHEN, "U+002D" },
    342. 

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

  343. 	{ GF_KEY_SLASH, "U+002F" },
    344. 

  344. 	{ GF_KEY_0, "U+0030" },
    345. 

  345. 	{ GF_KEY_1, "U+0031" },
    346. 

  346. 	{ GF_KEY_2, "U+0032" },
    347. 

  347. 	{ GF_KEY_3, "U+0033" },
    348. 

  348. 	{ GF_KEY_4, "U+0034" },
    349. 

  349. 	{ GF_KEY_5, "U+0035" },
    350. 

  350. 	{ GF_KEY_6, "U+0036" },
    351. 

  351. 	{ GF_KEY_7, "U+0037" },
    352. 

  352. 	{ GF_KEY_8, "U+0038" },
    353. 

  353. 	{ GF_KEY_9, "U+0039" },
    354. 

  354. 	{ GF_KEY_COLON, "U+003A" },
    355. 

  355. 	{ GF_KEY_SEMICOLON, "U+003B" },
    356. 

  356. 	{ GF_KEY_LESSTHAN, "U+003C" },
    357. 

  357. 	{ GF_KEY_EQUALS, "U+003D" },
    358. 

  358. 	{ GF_KEY_GREATERTHAN, "U+003E" },
    359. 

  359. 	{ GF_KEY_QUESTION, "U+003F" },
    360. 

  360. 	{ GF_KEY_AT, "U+0040" },
    361. 

  361. 	{ GF_KEY_A, "U+0041" },
    362. 

  362. 	{ GF_KEY_B, "U+0042" },
    363. 

  363. 	{ GF_KEY_C, "U+0043" },
    364. 

  364. 	{ GF_KEY_D, "U+0044" },
    365. 

  365. 	{ GF_KEY_E, "U+0045" },
    366. 

  366. 	{ GF_KEY_F, "U+0046" },
    367. 

  367. 	{ GF_KEY_G, "U+0047" },
    368. 

  368. 	{ GF_KEY_H, "U+0048" },
    369. 

  369. 	{ GF_KEY_I, "U+0049" },
    370. 

  370. 	{ GF_KEY_J, "U+004A" },
    371. 

  371. 	{ GF_KEY_K, "U+004B" },
    372. 

  372. 	{ GF_KEY_L, "U+004C" },
    373. 

  373. 	{ GF_KEY_M, "U+004D" },
    374. 

  374. 	{ GF_KEY_N, "U+004E" },
    375. 

  375. 	{ GF_KEY_O, "U+004F" },
    376. 

  376. 	{ GF_KEY_P, "U+0050" },
    377. 

  377. 	{ GF_KEY_Q, "U+0051" },
    378. 

  378. 	{ GF_KEY_R, "U+0052" },
    379. 

  379. 	{ GF_KEY_S, "U+0053" },
    380. 

  380. 	{ GF_KEY_T, "U+0054" },
    381. 

  381. 	{ GF_KEY_U, "U+0055" },
    382. 

  382. 	{ GF_KEY_V, "U+0056" },
    383. 

  383. 	{ GF_KEY_W, "U+0057" },
    384. 

  384. 	{ GF_KEY_X, "U+0058" },
    385. 

  385. 	{ GF_KEY_Y, "U+0059" },
    386. 

  386. 	{ GF_KEY_Z, "U+005A" },
    387. 

  387. 	{ GF_KEY_LEFTSQUAREBRACKET, "U+005B" },
    388. 

  388. 	{ GF_KEY_BACKSLASH, "U+005C" },
    389. 

  389. 	{ GF_KEY_RIGHTSQUAREBRACKET, "U+005D" },
    390. 

  390. 	{ GF_KEY_CIRCUM, "U+005E" },
    391. 

  391. 	{ GF_KEY_UNDERSCORE, "U+005F" },
    392. 

  392. 	{ GF_KEY_GRAVEACCENT, "U+0060" },
    393. 

  393. 	{ GF_KEY_LEFTCURLYBRACKET, "U+007B" },
    394. 

  394. 	{ GF_KEY_PIPE, "U+007C" },
    395. 

  395. 	{ GF_KEY_RIGHTCURLYBRACKET, "U+007D" },
    396. 

  396. 	{ GF_KEY_DEL, "U+007F" },
    397. 

  397. 	{ GF_KEY_INVERTEXCLAMATION, "U+00A1" },
    398. 

  398. 	{ GF_KEY_DEADGRAVE, "U+0300" },
    399. 

  399. 	{ GF_KEY_DEADEACUTE, "U+0301" },
    400. 

  400. 	{ GF_KEY_DEADCIRCUM, "U+0302" },
    401. 

  401. 	{ GF_KEY_DEADTILDE, "U+0303" },
    402. 

  402. 	{ GF_KEY_DEADMACRON, "U+0304" },
    403. 

  403. 	{ GF_KEY_DEADBREVE, "U+0306" },
    404. 

  404. 	{ GF_KEY_DEADABOVEDOT, "U+0307" },
    405. 

  405. 	{ GF_KEY_DEADDIARESIS, "U+0308" },
    406. 

  406. 	{ GF_KEY_DEADRINGABOVE, "U+030A" },
    407. 

  407. 	{ GF_KEY_DEADDOUBLEACUTE, "U+030B" },
    408. 

  408. 	{ GF_KEY_DEADCARON, "U+030C" },
    409. 

  409. 	{ GF_KEY_DEADCEDILLA, "U+0327" },
    410. 

  410. 	{ GF_KEY_DEADOGONEK, "U+0328" },
    411. 

  411. 	{ GF_KEY_DEADIOTA, "U+0345" },
    412. 

  412. 	{ GF_KEY_EURO, "U+20AC" },
    413. 

  413. 	{ GF_KEY_DEADVOICESOUND, "U+3099" },
    414. 

  414. 	{ GF_KEY_DEADSEMIVOICESOUND, "U+309A" },
    415. 

  415. 	{ GF_KEY_CHANNELUP, "ChannelUp" },
    416. 

  416. 	{ GF_KEY_CHANNELDOWN, "ChannelDown" },
    417. 

  417. 	{ GF_KEY_TEXT, "Text" },
    418. 

  418. 	{ GF_KEY_INFO, "Info" },
    419. 

  419. 	{ GF_KEY_EPG, "EPG" },
    420. 

  420. 	{ GF_KEY_RECORD, "Record" },
    421. 

  421. 	{ GF_KEY_BEGINPAGE, "BeginPage" }
    422. 

  422. };
    423. 

  423. 

  424. 

  425. GF_EXPORT
    426. 

  426. const char *gf_dom_get_key_name(u32 key_identifier)
    427. 

  427. {
    428. 

  428. 	u32 count = sizeof(predefined_key_identifiers) / sizeof(struct predef_keyid);
    429. 

  429. 	if (!key_identifier || count<=key_identifier) return "Unknown";
    430. 

  430. 	return predefined_key_identifiers[key_identifier-1].name;
    431. 

  431. }
    432. 

  432. 

  433. 

  434. u32 gf_dom_get_key_type(char *key_name)
    435. 

  435. {
    436. 

  436. 	if (strlen(key_name) == 1) {
    437. 

  437. 		char c[2];
    438. 

  438. 		c[0] = key_name[0];
    439. 

  439. 		c[1] = 0;
    440. 

  440. 		strupr(c);
    441. 

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

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

  443. 

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

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

  446. 

  447. 		switch (c[0]) {
    448. 

  448. 		case '@': return GF_KEY_AT;
    449. 

  449. 		case '*': return GF_KEY_STAR;
    450. 

  450. 		case '#': return GF_KEY_NUMBER;
    451. 

  451. 		case ' ': return GF_KEY_SPACE;
    452. 

  452. 		case '!': return GF_KEY_EXCLAMATION;
    453. 

  453. 		case '"': return GF_KEY_QUOTATION;
    454. 

  454. 		case '$': return GF_KEY_DOLLAR;
    455. 

  455. 		case '&': return GF_KEY_AMPERSAND;
    456. 

  456. 		case '\'': return GF_KEY_APOSTROPHE;
    457. 

  457. 		case '(': return GF_KEY_LEFTPARENTHESIS;
    458. 

  458. 		case ')': return GF_KEY_RIGHTPARENTHESIS;
    459. 

  459. 		case '+': return GF_KEY_PLUS;
    460. 

  460. 		case ',': return GF_KEY_COMMA;
    461. 

  461. 		case '-': return GF_KEY_HYPHEN;
    462. 

  462. 		case '.': return GF_KEY_FULLSTOP;
    463. 

  463. 		case '/': return GF_KEY_SLASH;
    464. 

  464. 		case ':': return GF_KEY_COLON;
    465. 

  465. 		case ';': return GF_KEY_SEMICOLON;
    466. 

  466. 		case '<': return GF_KEY_LESSTHAN;
    467. 

  467. 		case '=': return GF_KEY_EQUALS;
    468. 

  468. 		case '>': return GF_KEY_GREATERTHAN;
    469. 

  469. 		case '?': return GF_KEY_QUESTION;
    470. 

  470. 		case '[': return GF_KEY_LEFTSQUAREBRACKET;
    471. 

  471. 		case '\\': return GF_KEY_BACKSLASH;
    472. 

  472. 		case ']': return GF_KEY_RIGHTSQUAREBRACKET;
    473. 

  473. 		case '^': return GF_KEY_CIRCUM;
    474. 

  474. 		case '_': return GF_KEY_UNDERSCORE;
    475. 

  475. 		case '`': return GF_KEY_GRAVEACCENT;
    476. 

  476. 		case '{': return GF_KEY_LEFTCURLYBRACKET;
    477. 

  477. 		case '|': return GF_KEY_PIPE;
    478. 

  478. 		case '}': return GF_KEY_RIGHTCURLYBRACKET;
    479. 

  479. 		case 'Ą': return GF_KEY_INVERTEXCLAMATION;
    480. 

  480. 		default: return GF_KEY_UNIDENTIFIED;
    481. 

  481. 		}
    482. 

  482. 	} else {
    483. 

  483. 		u32 i, count;
    484. 

  484. 		count = sizeof(predefined_key_identifiers) / sizeof(struct predef_keyid);
    485. 

  485. 		for (i=0; i<count; i++) {
    486. 

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

  487. 				return predefined_key_identifiers[i].key_code;
    488. 

  488. 			}
    489. 

  489. 		}
    490. 

  490. 		return GF_KEY_UNIDENTIFIED;
    491. 

  491. 	}
    492. 

  492. }
    493. 

  493. 

  494. /* Basic SVG datatype parsing functions */
    495. 

  495. static const struct predef_col { const char *name; u8 r; u8 g; u8 b; } predefined_colors[] =
    496. 

  496. {
    497. 

  497. 	{"aliceblue",240, 248, 255},
    498. 

  498. 	{"antiquewhite",250, 235, 215},
    499. 

  499. 	{"aqua", 0, 255, 255},
    500. 

  500. 	{"aquamarine",127, 255, 212},
    501. 

  501. 	{"azure",240, 255, 255},
    502. 

  502. 	{"beige",245, 245, 220},
    503. 

  503. 	{"bisque",255, 228, 196},
    504. 

  504. 	{"black", 0, 0, 0},
    505. 

  505. 	{"blanchedalmond",255, 235, 205},
    506. 

  506. 	{"blue", 0, 0, 255},
    507. 

  507. 	{"blueviolet",138, 43, 226},
    508. 

  508. 	{"brown",165, 42, 42},
    509. 

  509. 	{"burlywood",222, 184, 135},
    510. 

  510. 	{"cadetblue", 95, 158, 160},
    511. 

  511. 	{"chartreuse",127, 255, 0},
    512. 

  512. 	{"chocolate",210, 105, 30},
    513. 

  513. 	{"coral",255, 127, 80},
    514. 

  514. 	{"lightpink",255, 182, 193},
    515. 

  515. 	{"lightsalmon",255, 160, 122},
    516. 

  516. 	{"lightseagreen", 32, 178, 170},
    517. 

  517. 	{"lightskyblue",135, 206, 250},
    518. 

  518. 	{"lightslategray",119, 136, 153},
    519. 

  519. 	{"lightslategrey",119, 136, 153},
    520. 

  520. 	{"lightsteelblue",176, 196, 222},
    521. 

  521. 	{"lightyellow",255, 255, 224},
    522. 

  522. 	{"lime", 0, 255, 0},
    523. 

  523. 	{"limegreen", 50, 205, 50},
    524. 

  524. 	{"linen",250, 240, 230},
    525. 

  525. 	{"magenta",255, 0, 255},
    526. 

  526. 	{"maroon",128, 0, 0},
    527. 

  527. 	{"mediumaquamarine",102, 205, 170},
    528. 

  528. 	{"mediumblue", 0, 0, 205},
    529. 

  529. 	{"mediumorchid",186, 85, 211},
    530. 

  530. 	{"cornflowerblue",100, 149, 237},
    531. 

  531. 	{"cornsilk",255, 248, 220},
    532. 

  532. 	{"crimson",220, 20, 60},
    533. 

  533. 	{"cyan", 0, 255, 255},
    534. 

  534. 	{"darkblue", 0, 0, 139},
    535. 

  535. 	{"darkcyan", 0, 139, 139},
    536. 

  536. 	{"darkgoldenrod",184, 134, 11},
    537. 

  537. 	{"darkgray",169, 169, 169},
    538. 

  538. 	{"darkgreen", 0, 100, 0},
    539. 

  539. 	{"darkgrey",169, 169, 169},
    540. 

  540. 	{"darkkhaki",189, 183, 107},
    541. 

  541. 	{"darkmagenta",139, 0, 139},
    542. 

  542. 	{"darkolivegreen", 85, 107, 47},
    543. 

  543. 	{"darkorange",255, 140, 0},
    544. 

  544. 	{"darkorchid",153, 50, 204},
    545. 

  545. 	{"darkred",139, 0, 0},
    546. 

  546. 	{"darksalmon",233, 150, 122},
    547. 

  547. 	{"darkseagreen",143, 188, 143},
    548. 

  548. 	{"darkslateblue", 72, 61, 139},
    549. 

  549. 	{"darkslategray", 47, 79, 79},
    550. 

  550. 	{"darkslategrey", 47, 79, 79},
    551. 

  551. 	{"darkturquoise", 0, 206, 209},
    552. 

  552. 	{"darkviolet",148, 0, 211},
    553. 

  553. 	{"deeppink",255, 20, 147},
    554. 

  554. 	{"deepskyblue", 0, 191, 255},
    555. 

  555. 	{"dimgray",105, 105, 105},
    556. 

  556. 	{"dimgrey",105, 105, 105},
    557. 

  557. 	{"dodgerblue", 30, 144, 255},
    558. 

  558. 	{"firebrick",178, 34, 34},
    559. 

  559. 	{"floralwhite",255, 250, 240},
    560. 

  560. 	{"forestgreen", 34, 139, 34},
    561. 

  561. 	{"fuchsia",255, 0, 255},
    562. 

  562. 	{"gainsboro",220, 220, 220},
    563. 

  563. 	{"ghostwhite",248, 248, 255},
    564. 

  564. 	{"gold",255, 215, 0},
    565. 

  565. 	{"goldenrod",218, 165, 32},
    566. 

  566. 	{"gray",128, 128, 128},
    567. 

  567. 	{"grey",128, 128, 128},
    568. 

  568. 	{"green", 0, 128, 0},
    569. 

  569. 	{"greenyellow",173, 255, 47},
    570. 

  570. 	{"honeydew",240, 255, 240},
    571. 

  571. 	{"hotpink",255, 105, 180},
    572. 

  572. 	{"indianred",205, 92, 92},
    573. 

  573. 	{"indigo", 75, 0, 130},
    574. 

  574. 	{"ivory",255, 255, 240},
    575. 

  575. 	{"khaki",240, 230, 140},
    576. 

  576. 	{"lavender",230, 230, 25},
    577. 

  577. 	{"lavenderblush",255, 240, 245},
    578. 

  578. 	{"mediumpurple",147, 112, 219},
    579. 

  579. 	{"mediumseagreen", 60, 179, 113},
    580. 

  580. 	{"mediumslateblue",123, 104, 238},
    581. 

  581. 	{"mediumspringgreen", 0, 250, 154},
    582. 

  582. 	{"mediumturquoise", 72, 209, 204},
    583. 

  583. 	{"mediumvioletred",199, 21, 133},
    584. 

  584. 	{"midnightblue", 25, 25, 112},
    585. 

  585. 	{"mintcream",245, 255, 250},
    586. 

  586. 	{"mistyrose",255, 228, 225},
    587. 

  587. 	{"moccasin",255, 228, 181},
    588. 

  588. 	{"navajowhite",255, 222, 173},
    589. 

  589. 	{"navy", 0, 0, 128},
    590. 

  590. 	{"oldlace",253, 245, 230},
    591. 

  591. 	{"olive",128, 128, 0},
    592. 

  592. 	{"olivedrab",107, 142, 35},
    593. 

  593. 	{"orange",255, 165, 0},
    594. 

  594. 	{"orangered",255, 69, 0},
    595. 

  595. 	{"orchid",218, 112, 214},
    596. 

  596. 	{"palegoldenrod",238, 232, 170},
    597. 

  597. 	{"palegreen",152, 251, 152},
    598. 

  598. 	{"paleturquoise",175, 238, 238},
    599. 

  599. 	{"palevioletred",219, 112, 147},
    600. 

  600. 	{"papayawhip",255, 239, 213},
    601. 

  601. 	{"peachpuff",255, 218, 185},
    602. 

  602. 	{"peru",205, 133, 63},
    603. 

  603. 	{"pink",255, 192, 203},
    604. 

  604. 	{"plum",221, 160, 221},
    605. 

  605. 	{"powderblue",176, 224, 230},
    606. 

  606. 	{"purple",128, 0, 128},
    607. 

  607. 	{"red",255, 0, 0},
    608. 

  608. 	{"rosybrown",188, 143, 143},
    609. 

  609. 	{"royalblue", 65, 105, 225},
    610. 

  610. 	{"saddlebrown",139, 69, 19},
    611. 

  611. 	{"salmon",250, 128, 114},
    612. 

  612. 	{"sandybrown",244, 164, 96},
    613. 

  613. 	{"seagreen", 46, 139, 87},
    614. 

  614. 	{"seashell",255, 245, 238},
    615. 

  615. 	{"sienna",160, 82, 45},
    616. 

  616. 	{"silver",192, 192, 192},
    617. 

  617. 	{"skyblue",135, 206, 235},
    618. 

  618. 	{"slateblue",106, 90, 205},
    619. 

  619. 	{"slategray",112, 128, 144},
    620. 

  620. 	{"slategrey",112, 128, 144},
    621. 

  621. 	{"snow",255, 250, 250},
    622. 

  622. 	{"springgreen", 0, 255, 127},
    623. 

  623. 	{"steelblue", 70, 130, 180},
    624. 

  624. 	{"tan",210, 180, 140},
    625. 

  625. 	{"teal", 0, 128, 128},
    626. 

  626. 	{"lawngreen",124, 252, 0},
    627. 

  627. 	{"lemonchiffon",255, 250, 205},
    628. 

  628. 	{"lightblue",173, 216, 230},
    629. 

  629. 	{"lightcoral",240, 128, 128},
    630. 

  630. 	{"lightcyan",224, 255, 255},
    631. 

  631. 	{"lightgoldenrodyellow",250, 250, 210},
    632. 

  632. 	{"lightgray",211, 211, 211},
    633. 

  633. 	{"lightgreen",144, 238, 144},
    634. 

  634. 	{"lightgrey",211, 211, 211},
    635. 

  635. 	{"thistle",216, 191, 216},
    636. 

  636. 	{"tomato",255, 99, 71},
    637. 

  637. 	{"turquoise", 64, 224, 208},
    638. 

  638. 	{"violet",238, 130, 238},
    639. 

  639. 	{"wheat",245, 222, 179},
    640. 

  640. 	{"white",255, 255, 255},
    641. 

  641. 	{"whitesmoke",245, 245, 245},
    642. 

  642. 	{"yellow",255, 255, 0},
    643. 

  643. 	{"yellowgreen",154, 205, 50}
    644. 

  644. 

  645. };
    646. 

  646. 

  647. 

  648. /* Basic SVG datatype parsing functions */
    649. 

  649. static const struct sys_col { const char *name; u8 type; } system_colors[] =
    650. 

  650. {
    651. 

  651. 	{"ActiveBorder", SVG_COLOR_ACTIVE_BORDER},
    652. 

  652. 	{"ActiveCaption", SVG_COLOR_ACTIVE_CAPTION},
    653. 

  653. 	{"AppWorkspace", SVG_COLOR_APP_WORKSPACE},
    654. 

  654. 	{"Background", SVG_COLOR_BACKGROUND},
    655. 

  655. 	{"ButtonFace", SVG_COLOR_BUTTON_FACE},
    656. 

  656. 	{"ButtonHighlight", SVG_COLOR_BUTTON_HIGHLIGHT},
    657. 

  657. 	{"ButtonShadow", SVG_COLOR_BUTTON_SHADOW},
    658. 

  658. 	{"ButtonText", SVG_COLOR_BUTTON_TEXT},
    659. 

  659. 	{"CaptionText", SVG_COLOR_CAPTION_TEXT},
    660. 

  660. 	{"GrayText", SVG_COLOR_GRAY_TEXT},
    661. 

  661. 	{"Highlight", SVG_COLOR_HIGHLIGHT},
    662. 

  662. 	{"HighlightText", SVG_COLOR_HIGHLIGHT_TEXT},
    663. 

  663. 	{"InactiveBorder", SVG_COLOR_INACTIVE_BORDER},
    664. 

  664. 	{"InactiveCaption", SVG_COLOR_INACTIVE_CAPTION},
    665. 

  665. 	{"InactiveCaptionText", SVG_COLOR_INACTIVE_CAPTION_TEXT},
    666. 

  666. 	{"InfoBackground", SVG_COLOR_INFO_BACKGROUND},
    667. 

  667. 	{"InfoText", SVG_COLOR_INFO_TEXT},
    668. 

  668. 	{"Menu", SVG_COLOR_MENU},
    669. 

  669. 	{"MenuText", SVG_COLOR_MENU_TEXT},
    670. 

  670. 	{"Scrollbar", SVG_COLOR_SCROLLBAR},
    671. 

  671. 	{"ThreeDDarkShadow", SVG_COLOR_3D_DARK_SHADOW},
    672. 

  672. 	{"ThreeDFace", SVG_COLOR_3D_FACE},
    673. 

  673. 	{"ThreeDHighlight", SVG_COLOR_3D_HIGHLIGHT},
    674. 

  674. 	{"ThreeDLightShadow", SVG_COLOR_3D_LIGHT_SHADOW},
    675. 

  675. 	{"ThreeDShadow", SVG_COLOR_3D_SHADOW},
    676. 

  676. 	{"Window", SVG_COLOR_WINDOW},
    677. 

  677. 	{"WindowFrame", SVG_COLOR_WINDOW_FRAME},
    678. 

  678. 	{"WindowText", SVG_COLOR_WINDOW_TEXT},
    679. 

  679. };
    680. 

  680. 

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

  682. static void svg_parse_named_color(SVG_Color *col, char *attribute_content)
    683. 

  683. {
    684. 

  684. 	u32 i, count;
    685. 

  685. 	count = sizeof(predefined_colors) / sizeof(struct predef_col);
    686. 

  686. 	for (i=0; i<count; i++) {
    687. 

  687. 		if (!strcmp(attribute_content, predefined_colors[i].name)) {
    688. 

  688. 			col->red = INT2FIX(predefined_colors[i].r) / 255;
    689. 

  689. 			col->green = INT2FIX(predefined_colors[i].g) / 255;
    690. 

  690. 			col->blue = INT2FIX(predefined_colors[i].b) / 255;
    691. 

  691. 			col->type = SVG_COLOR_RGBCOLOR;
    692. 

  692. 			return;
    693. 

  693. 		}
    694. 

  694. 	}
    695. 

  695. 	count = sizeof(system_colors) / sizeof(struct sys_col);
    696. 

  696. 	for (i=0; i<count; i++) {
    697. 

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

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

  699. 			return;
    700. 

  700. 		}
    701. 

  701. 	}
    702. 

  702. }
    703. 

  703. 

  704. const char *gf_svg_get_system_paint_server_name(u32 paint_type)
    705. 

  705. {
    706. 

  706. 	u32 i, count;
    707. 

  707. 	count = sizeof(system_colors) / sizeof(struct sys_col);
    708. 

  708. 	for (i=0; i<count; i++) {
    709. 

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

  710. 	}
    711. 

  711. 	return "undefined";
    712. 

  712. }
    713. 

  713. 

  714. u32 gf_svg_get_system_paint_server_type(const char *name)
    715. 

  715. {
    716. 

  716. 	u32 i, count;
    717. 

  717. 	count = sizeof(system_colors) / sizeof(struct sys_col);
    718. 

  718. 	for (i=0; i<count; i++) {
    719. 

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

  720. 	}
    721. 

  721. 	return 0;
    722. 

  722. }
    723. 

  723. 

  724. /* Reads an SVG Color
    725. 

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

  726.    ignores any space, comma, semi-column before and any space after
    727. 

  727.    TODO:
    728. 

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

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

  730. */
    731. 

  731. static void svg_parse_color(SVG_Color *col, char *attribute_content)
    732. 

  732. {
    733. 

  733. 	char *str = attribute_content;
    734. 

  734. 	while (str[strlen(attribute_content)-1] == ' ') str[strlen(attribute_content)-1] = 0;
    735. 

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

  736. 

  737. 	if (!strcmp(str, "currentColor")) {
    738. 

  738. 		col->type = SVG_COLOR_CURRENTCOLOR;
    739. 

  739. 		return;
    740. 

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

  741. 		col->type = SVG_COLOR_INHERIT;
    742. 

  742. 		return;
    743. 

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

  744. 		u32 val;
    745. 

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

  746. 		if (strlen(str) == 7) {
    747. 

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

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

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

  750. 		} else {
    751. 

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

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

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

  754. 		}
    755. 

  755. 		col->type = SVG_COLOR_RGBCOLOR;
    756. 

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

  757. 		Float _val;
    758. 

  758. 		u8 is_percentage= 0;
    759. 

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

  760. 		str = strstr(str, "(");
    761. 

  761. 		str++;
    762. 

  762. 		sscanf(str, "%f", &_val); col->red = FLT2FIX(_val);
    763. 

  763. 		str = strstr(str, ",");
    764. 

  764. 		if (!str) {
    765. 

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

  766. 			col->red = col->green = col->blue = 0;
    767. 

  767. 			return;
    768. 

  768. 		}
    769. 

  769. 		str++;
    770. 

  770. 		sscanf(str, "%f", &_val); col->green = FLT2FIX(_val);
    771. 

  771. 		str = strstr(str, ",");
    772. 

  772. 		if (!str) {
    773. 

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

  774. 			col->red = col->green = col->blue = 0;
    775. 

  775. 			return;
    776. 

  776. 		}
    777. 

  777. 		str++;
    778. 

  778. 		sscanf(str, "%f", &_val); col->blue = FLT2FIX(_val);
    779. 

  779. 		if (is_percentage) {
    780. 

  780. 			col->red /= 100;
    781. 

  781. 			col->green /= 100;
    782. 

  782. 			col->blue /= 100;
    783. 

  783. 		} else {
    784. 

  784. 			col->red /= 255;
    785. 

  785. 			col->green /= 255;
    786. 

  786. 			col->blue /= 255;
    787. 

  787. 		}
    788. 

  788. 		col->type = SVG_COLOR_RGBCOLOR;
    789. 

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

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

  791. 		svg_parse_named_color(col, str);
    792. 

  792. 	} else {
    793. 

  793. 		Float _r, _g, _b;
    794. 

  794. 		sscanf(str, "%f %f %f", &_r, &_g, &_b);
    795. 

  795. 		col->red = FLT2FIX(_r);
    796. 

  796. 		col->green = FLT2FIX(_g);
    797. 

  797. 		col->blue = FLT2FIX(_b);
    798. 

  798. 		col->type = SVG_COLOR_RGBCOLOR;
    799. 

  799. 	}
    800. 

  800. }
    801. 

  801. 

  802. /*
    803. 

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

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

  805. 		reads an optional + or -
    806. 

  806. 		then reads a digit between 0 and 9
    807. 

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

  808. 		optionally followed by e or E and digits between 0 and 9
    809. 

  809. 	Returns the number of chars read in d
    810. 

  810. */
    811. 

  811. static u32 svg_parse_number(char *d, Fixed *f, Bool is_angle)
    812. 

  812. {
    813. 

  813.     u32 nb_digit_before = 0;
    814. 

  814. 	u32 nb_digit_after = 0;
    815. 

  815.     Bool has_fractional = 0;
    816. 

  816. 	Bool is_negative = 0;
    817. 

  817. 	Float _val = 0;
    818. 

  818. 	u32 i = 0;
    819. 

  819. 

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

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

  822. 

  823.     if (!d[i]) {
    824. 

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

  825.         return 0;
    826. 

  826.     }
    827. 

  827.     if (d[i] == '+') {
    828. 

  828.         i++;
    829. 

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

  830. 		is_negative = 1;
    831. 

  831. 		i++;
    832. 

  832. 	}
    833. 

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

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

  835. 		i+= 3;
    836. 

  836. 		_val = 0;
    837. 

  837. 		goto end;
    838. 

  838. 	}*/
    839. 

  839.     /* read the digit-sequence token of the BNF */
    840. 

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

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

  842.         nb_digit_before++;
    843. 

  843. 		i++;
    844. 

  844. 	}
    845. 

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

  846.         has_fractional = 1;
    847. 

  847. 		i++;
    848. 

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

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

  850. 			nb_digit_after++;
    851. 

  851. 			i++;
    852. 

  852. 		}
    853. 

  853.         if (nb_digit_after) {
    854. 

  854.             _val /= (Float)pow(10,nb_digit_after);
    855. 

  855.         } else if (nb_digit_before == 0) {
    856. 

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

  857.             return 0;
    858. 

  858.         } else {
    859. 

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

  860.         }
    861. 

  861. 	}
    862. 

  862.     if ((nb_digit_before == 0) && (has_fractional == 0)) {
    863. 

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

  864.         return 0;
    865. 

  865.     }
    866. 

  866.     /* reading the exponent */
    867. 

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

  868. 		Bool neg_exp = 0;
    869. 

  869. 		u32 nb_exp_digits = 0;
    870. 

  870.         s32 exp = 0;
    871. 

  871. 		i++;
    872. 

  872. 		if (d[i] == '+') i++;
    873. 

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

  874. 			i++;
    875. 

  875. 			neg_exp=1;
    876. 

  876. 		}
    877. 

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

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

  879.             nb_exp_digits++;
    880. 

  880. 			i++;
    881. 

  881. 		}
    882. 

  882.         if (nb_exp_digits) {
    883. 

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

  884.         } else {
    885. 

  885.             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));
    886. 

  886.             return 0;
    887. 

  887.         }
    888. 

  888. 	}
    889. 

  889.     /* We can now produce the final number */
    890. 

  890. 	if (is_negative) _val *= -1;
    891. 

  891. 	if (is_angle) {
    892. 

  892. 		_val/=180;
    893. 

  893. 		(*f) = gf_mulfix(FLT2FIX(_val), GF_PI);
    894. 

  894. 	} else {
    895. 

  895. 		(*f) = FLT2FIX(_val);
    896. 

  896. 	}
    897. 

  897. 

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

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

  900. 	return i;
    901. 

  901. }
    902. 

  902. 

  903. /*
    904. 

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

  905. */
    906. 

  906. static GF_Err svg_parse_clock_value(char *d, Double *clock_value)
    907. 

  907. {
    908. 

  908. 	char *tmp;
    909. 

  909. 	s32 sign = 1;
    910. 

  910. 

  911. 	if (!d) return GF_BAD_PARAM;
    912. 

  912. 

  913. 	if (!d[0]) return GF_BAD_PARAM;
    914. 

  914. 

  915. 	if (d[0] == '+') d++;
    916. 

  916. 	else if (d[0] == '-') { sign = -1; d++; }
    917. 

  917. 

  918. 	if (!d[0]) return GF_BAD_PARAM;
    919. 

  919. 

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

  921. 		'+-2s'
    922. 

  922. 		'1++s' even though sscanf returns the right values
    923. 

  923. 	*/
    924. 

  924. 	if (strchr(d, '+') || strchr(d, '-')) return GF_BAD_PARAM;
    925. 

  925. 

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

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

  928. 	while (*d == ' ') d++;
    929. 

  929. 

  930. 	if ((tmp = strchr(d, ':'))) {
    931. 

  931. 		/* Full or Partial Clock value */
    932. 

  932. 		tmp++;
    933. 

  933. 		if ((tmp = strchr(tmp, ':'))) {
    934. 

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

  935. 			u32 hours;
    936. 

  936. 			u32 minutes;
    937. 

  937. 			Float seconds;
    938. 

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

  939. 			*clock_value = hours*3600 + minutes*60 + seconds;
    940. 

  940. 		} else {
    941. 

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

  942. 			s32 minutes;
    943. 

  943. 			Float seconds;
    944. 

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

  945. 			*clock_value = minutes*60 + seconds;
    946. 

  946. 		}
    947. 

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

  948. 		Float f;
    949. 

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

  950. 		*clock_value = 3600*f;
    951. 

  951. 	} else if (strstr(d, "min")) {
    952. 

  952. 		Float f;
    953. 

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

  954. 		*clock_value = 60*f;
    955. 

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

  956. 		Float f;
    957. 

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

  958. 		*clock_value = f/1000;
    959. 

  959. 	} else if (strchr(d, 's')) {
    960. 

  960. 		Float f;
    961. 

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

  962. 		*clock_value = f;
    963. 

  963. 	} else {
    964. 

  964. 		Float f;
    965. 

  965. 		if (sscanf(d, "%f", &f) == 0) return GF_BAD_PARAM;
    966. 

  966. 		*clock_value = f;
    967. 

  967. 	}
    968. 

  968. 	*clock_value *= sign;
    969. 

  969. 	return GF_OK;
    970. 

  970. }
    971. 

  971. /* Parses one SVG time value:
    972. 

  972. 	  indefinite,
    973. 

  973. 	  element_id.event_name
    974. 

  974. 	  wallclock,
    975. 

  975. 	  accessKey,
    976. 

  976. 	  events,
    977. 

  977. 	  clock value.
    978. 

  978.  */
    979. 

  979. static GF_Err smil_parse_time(GF_Node *elt, SMIL_Time *v, char *d)
    980. 

  980. {
    981. 

  981. 	GF_Err e = GF_OK;
    982. 

  982. 	char *tmp;
    983. 

  983. 

  984. 	/* Offset Values */
    985. 

  985. 	if ((d[0] >= '0' && d[0] <= '9') || d[0] == '+' || d[0] == '-'){
    986. 

  986. 		v->type = GF_SMIL_TIME_CLOCK;
    987. 

  987. 		return svg_parse_clock_value(d, &(v->clock));
    988. 

  988. 	}
    989. 

  989. 

  990. 	/* Indefinite Values */
    991. 

  991. 	else if (!strcmp(d, "indefinite")) {
    992. 

  992. 		v->type = GF_SMIL_TIME_INDEFINITE;
    993. 

  993. 		return GF_OK;
    994. 

  994. 	}
    995. 

  995. 

  996. 	/* Wallclock Values */
    997. 

  997. 	else if ((tmp = strstr(d, "wallclock("))) {
    998. 

  998. 		u32 year, month, day;
    999. 

  999. 		u32 hours, minutes;
    1000. 

  1000. 		u32 nhours, nminutes;
    1001. 

  1001. 		Float seconds;
    1002. 

  1002. 		char *tmp1, *tmp2;
    1003. 

  1003. 

  1004. 		v->type = GF_SMIL_TIME_WALLCLOCK;
    1005. 

  1005. 		tmp += 10;
    1006. 

  1006. 		if ((tmp1 = strchr(tmp, 'T')) ) {
    1007. 

  1007. 			/* From tmp to wallStartTime, we parse a date */
    1008. 

  1008. 			sscanf(tmp, "%u-%u-%dT", &year, &month, &day);
    1009. 

  1009. 			tmp1++;
    1010. 

  1010. 			tmp = tmp1;
    1011. 

  1011. 		}
    1012. 

  1012. 		if ((tmp1 = strchr(tmp, ':')) ) {
    1013. 

  1013. 			if ((tmp2 = strchr(tmp1, ':')) ) {
    1014. 

  1014. 				/* HHMMSS */
    1015. 

  1015. 				sscanf(tmp, "%u:%u:%f", &hours, &minutes, &seconds);
    1016. 

  1016. 			} else {
    1017. 

  1017. 				/* HHMM */
    1018. 

  1018. 				sscanf(tmp, "%u:%u", &hours, &minutes);
    1019. 

  1019. 			}
    1020. 

  1020. 		}
    1021. 

  1021. 		if (strchr(tmp, 'Z')) {
    1022. 

  1022. 			return GF_OK;
    1023. 

  1023. 		} else {
    1024. 

  1024. 			if ( (tmp1 = strchr(tmp, '+')) ) {
    1025. 

  1025. 				sscanf(tmp1, "%u:%u", &nhours, &nminutes);
    1026. 

  1026. 			} else if ( (tmp1 = strchr(tmp, '-')) ) {
    1027. 

  1027. 				sscanf(tmp1, "%u:%u", &nhours, &nminutes);
    1028. 

  1028. 			}
    1029. 

  1029. 		}
    1030. 

  1030. 		return GF_OK;
    1031. 

  1031. 	}
    1032. 

  1032. 

  1033. 	/* AccessKey Values */
    1034. 

  1034. 	else if ((tmp = strstr(d, "accessKey("))) {
    1035. 

  1035. 		char *sep;
    1036. 

  1036. 		v->type = GF_SMIL_TIME_EVENT;
    1037. 

  1037. 		v->event.type = GF_EVENT_KEYDOWN;
    1038. 

  1038. 		v->element = elt->sgprivate->scenegraph->RootNode;
    1039. 

  1039. 		tmp+=10;
    1040. 

  1040. 		sep = strchr(d, ')');
    1041. 

  1041. 		sep[0] = 0;
    1042. 

  1042. 		v->event.parameter = gf_dom_get_key_type(tmp);
    1043. 

  1043. 		sep++;
    1044. 

  1044. 		if ((tmp = strchr(sep, '+')) || (tmp = strchr(sep, '-'))) {
    1045. 

  1045. 			char c = *tmp;
    1046. 

  1046. 			tmp++;
    1047. 

  1047. 			e = svg_parse_clock_value(tmp, &(v->clock));
    1048. 

  1048. 			if (c == '-') v->clock *= -1;
    1049. 

  1049. 		}
    1050. 

  1050. 		return e;
    1051. 

  1051. 	}
    1052. 

  1052. 

  1053. 	else {
    1054. 

  1054. 		Bool had_param = 0;
    1055. 

  1055. 		char *tmp2;
    1056. 

  1056. 		v->type = GF_SMIL_TIME_EVENT;
    1057. 

  1057. 		if ((tmp = strchr(d, '.'))) {
    1058. 

  1058. 			tmp[0] = 0;
    1059. 

  1059. 			if (strlen(d) == 0) {
    1060. 

  1060. 				GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] expecting an id before '.' in SMIL Time .%s\n", tmp+1));
    1061. 

  1061. 				return GF_BAD_PARAM;
    1062. 

  1062. 			}
    1063. 

  1063. 			v->element_id = gf_strdup(d);
    1064. 

  1064. 			tmp[0] = '.';
    1065. 

  1065. 			tmp++;
    1066. 

  1066. 		} else {
    1067. 

  1067. 			tmp = d;
    1068. 

  1068. 		}
    1069. 

  1069. 		if ((tmp2 = strchr(tmp, '('))) {
    1070. 

  1070. 			tmp2[0] = 0;
    1071. 

  1071. 			v->event.type = gf_dom_event_type_by_name(tmp);
    1072. 

  1072. 			tmp2[0] = '(';
    1073. 

  1073. 			tmp2++;
    1074. 

  1074. 			had_param = 1;
    1075. 

  1075. 			v->event.parameter = atoi(tmp2);
    1076. 

  1076. 			tmp = strchr(tmp2, ')');
    1077. 

  1077. 			if (!tmp) {
    1078. 

  1078. 				GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] expecting ')' in SMIL Time %s\n", d));
    1079. 

  1079. 				return GF_BAD_PARAM;
    1080. 

  1080. 			}
    1081. 

  1081. 			tmp++;
    1082. 

  1082. 		}
    1083. 

  1083. 		if ((tmp2 = strchr(tmp, '+')) || (tmp2 = strchr(tmp, '-'))) {
    1084. 

  1084. 			char c = *tmp2;
    1085. 

  1085. 			char *tmp3 = tmp2;
    1086. 

  1086. 			tmp2[0] = 0;
    1087. 

  1087. 			tmp3--;
    1088. 

  1088. 			while (*tmp3==' ') { *tmp3=0; tmp3--; }
    1089. 

  1089. 			if (v->event.type == 0) v->event.type = gf_dom_event_type_by_name(tmp);
    1090. 

  1090. 			if (!had_param && (v->event.type == GF_EVENT_REPEAT || v->event.type == GF_EVENT_REPEAT_EVENT))
    1091. 

  1091. 				v->event.parameter = 1;
    1092. 

  1092. 			tmp2[0] = c;
    1093. 

  1093. 			tmp2++;
    1094. 

  1094. 			e = svg_parse_clock_value(tmp2, &(v->clock));
    1095. 

  1095. 			if (c == '-') v->clock *= -1;
    1096. 

  1096. 			return e;
    1097. 

  1097. 		} else {
    1098. 

  1098. 			if (v->event.type == 0) v->event.type = gf_dom_event_type_by_name(tmp);
    1099. 

  1099. 			if (!had_param && (v->event.type == GF_EVENT_REPEAT || v->event.type == GF_EVENT_REPEAT_EVENT))
    1100. 

  1100. 				v->event.parameter = 1;
    1101. 

  1101. 		}
    1102. 

  1102. 	}
    1103. 

  1103. 	return GF_OK;
    1104. 

  1104. }
    1105. 

  1105. 

  1106. /* Parses a list of SVG transformations and collapses them in the given matrix */
    1107. 

  1107. Bool gf_svg_parse_transformlist(GF_Matrix2D *mat, char *attribute_content)
    1108. 

  1108. {
    1109. 

  1109. 	GF_Matrix2D tmp;
    1110. 

  1110. 

  1111. 	char *str;
    1112. 

  1112.     u32 read_chars;
    1113. 

  1113. 	u32 i;
    1114. 

  1114. 

  1115. 	gf_mx2d_init(*mat);
    1116. 

  1116. 

  1117. 	str = attribute_content;
    1118. 

  1118. 	i = 0;
    1119. 

  1119. 	while (str[i] != 0) {
    1120. 

  1120. 		while (str[i] == ' ') i++;
    1121. 

  1121. 		if (str[i] == ',') i++;
    1122. 

  1122. 		while (str[i] == ' ') i++;
    1123. 

  1123. 		if (strstr(str+i, "scale")==str+i) {
    1124. 

  1124. 			i += 5;
    1125. 

  1125. 			while(str[i] == ' ') i++;
    1126. 

  1126. 			if (str[i] == '(') {
    1127. 

  1127. 				Fixed sx, sy;
    1128. 

  1128. 				i++;
    1129. 

  1129. 				read_chars = svg_parse_number(&(str[i]), &sx, 0);
    1130. 

  1130.                 if (!read_chars) {
    1131. 

  1131.                     GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error reading sx component in scale: %s\n", attribute_content));
    1132. 

  1132.                     return 0;
    1133. 

  1133.                 }
    1134. 

  1134.                 i += read_chars;
    1135. 

  1135. 

  1136. 				if (str[i] == ')') {
    1137. 

  1137. 					sy = sx;
    1138. 

  1138. 				} else {
    1139. 

  1139. 					read_chars = svg_parse_number(&(str[i]), &sy, 0);
    1140. 

  1140.                     if (!read_chars) {
    1141. 

  1141.                         GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error reading sy component in scale: %s\n", attribute_content));
    1142. 

  1142.                         return 0;
    1143. 

  1143.                     }
    1144. 

  1144.                     i += read_chars;
    1145. 

  1145. 				}
    1146. 

  1146. 				gf_mx2d_init(tmp);
    1147. 

  1147. 				gf_mx2d_add_scale(&tmp, sx, sy);
    1148. 

  1148. 				gf_mx2d_add_matrix(&tmp, mat);
    1149. 

  1149. 				gf_mx2d_copy(*mat, tmp);
    1150. 

  1150. 

  1151. 				while(str[i] == ' ') i++;
    1152. 

  1152. 				if (str[i] == ')') i++;
    1153. 

  1153. 				else {
    1154. 

  1154.                     GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Missing closing parenthesis in transform attribute: %s\n", attribute_content));
    1155. 

  1155.                     return 0;
    1156. 

  1156. 				}
    1157. 

  1157. 			} else {
    1158. 

  1158. 				GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Missing opening parenthesis in transform attribute: %s\n", attribute_content));
    1159. 

  1159.                 return 0;
    1160. 

  1160. 			}
    1161. 

  1161. 		} else if (strstr(str+i, "translate")==str+i) {
    1162. 

  1162. 			i += 9;
    1163. 

  1163. 			while(str[i] == ' ') i++;
    1164. 

  1164. 			if (str[i] == '(') {
    1165. 

  1165. 				Fixed tx, ty;
    1166. 

  1166. 				i++;
    1167. 

  1167. 				read_chars = svg_parse_number(&(str[i]), &tx, 0);
    1168. 

  1168.                 if (!read_chars) {
    1169. 

  1169.                     GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error reading tx component in translate: %s\n", attribute_content));
    1170. 

  1170.                     return 0;
    1171. 

  1171.                 }
    1172. 

  1172.                 i += read_chars;
    1173. 

  1173. 				if (str[i] == ')') {
    1174. 

  1174. 					ty = 0;
    1175. 

  1175. 				} else {
    1176. 

  1176. 					read_chars = svg_parse_number(&(str[i]), &ty, 0);
    1177. 

  1177.                     if (!read_chars) {
    1178. 

  1178.                         GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error reading ty component in translate: %s\n", attribute_content));
    1179. 

  1179.                         return 0;
    1180. 

  1180.                     }
    1181. 

  1181.                     i += read_chars;
    1182. 

  1182. 				}
    1183. 

  1183. 				gf_mx2d_init(tmp);
    1184. 

  1184. 				gf_mx2d_add_translation(&tmp, tx, ty);
    1185. 

  1185. 				gf_mx2d_add_matrix(&tmp, mat);
    1186. 

  1186. 				gf_mx2d_copy(*mat, tmp);
    1187. 

  1187. 				while(str[i] == ' ') i++;
    1188. 

  1188. 				if (str[i] == ')') i++;
    1189. 

  1189. 				else {
    1190. 

  1190.                     GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Missing closing parenthesis in transform attribute: %s\n", attribute_content));
    1191. 

  1191.                     return 0;
    1192. 

  1192. 				}
    1193. 

  1193. 			} else {
    1194. 

  1194. 				GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Missing opening parenthesis in transform attribute: %s\n", attribute_content));
    1195. 

  1195.                 return 0;
    1196. 

  1196. 			}
    1197. 

  1197. 		} else if (strstr(str+i, "rotate")==str+i) {
    1198. 

  1198. 			i += 6;
    1199. 

  1199. 			while(str[i] == ' ') i++;
    1200. 

  1200. 			if (str[i] == '(') {
    1201. 

  1201. 				Fixed angle, cx, cy;
    1202. 

  1202. 				i++;
    1203. 

  1203. 				read_chars = svg_parse_number(&(str[i]), &angle, 1);
    1204. 

  1204.                 if (!read_chars) {
    1205. 

  1205.                     GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error reading angle component in rotate: %s\n", attribute_content));
    1206. 

  1206.                     return 0;
    1207. 

  1207.                 }
    1208. 

  1208.                 i += read_chars;
    1209. 

  1209. 				if (str[i] == ')') {
    1210. 

  1210. 					cx = cy = 0;
    1211. 

  1211. 				} else {
    1212. 

  1212. 					read_chars = svg_parse_number(&(str[i]), &cx, 0);
    1213. 

  1213.                     if (!read_chars) {
    1214. 

  1214.                         GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error reading cx component in rotate: %s\n", attribute_content));
    1215. 

  1215.                         return 0;
    1216. 

  1216.                     }
    1217. 

  1217.                     i += read_chars;
    1218. 

  1218. 					read_chars = svg_parse_number(&(str[i]), &cy, 0);
    1219. 

  1219.                     if (!read_chars) {
    1220. 

  1220.                         GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error reading cy component in rotate: %s\n", attribute_content));
    1221. 

  1221.                         return 0;
    1222. 

  1222.                     }
    1223. 

  1223.                     i += read_chars;
    1224. 

  1224. 				}
    1225. 

  1225. 				gf_mx2d_init(tmp);
    1226. 

  1226. 				gf_mx2d_add_rotation(&tmp, cx, cy, angle);
    1227. 

  1227. 				gf_mx2d_add_matrix(&tmp, mat);
    1228. 

  1228. 				gf_mx2d_copy(*mat, tmp);
    1229. 

  1229. 				while(str[i] == ' ') i++;
    1230. 

  1230. 				if (str[i] == ')') i++;
    1231. 

  1231. 				else {
    1232. 

  1232.                     GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Missing closing parenthesis in transform attribute: %s\n", attribute_content));
    1233. 

  1233.                     return 0;
    1234. 

  1234. 				}
    1235. 

  1235. 			} else {
    1236. 

  1236. 				GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Missing opening parenthesis in transform attribute: %s\n", attribute_content));
    1237. 

  1237.                 return 0;
    1238. 

  1238. 			}
    1239. 

  1239. 		} else if (strstr(str+i, "skewX")==str+i) {
    1240. 

  1240. 			i += 5;
    1241. 

  1241. 			while(str[i] == ' ') i++;
    1242. 

  1242. 			if (str[i] == '(') {
    1243. 

  1243. 				Fixed angle;
    1244. 

  1244. 				i++;
    1245. 

  1245. 				read_chars = svg_parse_number(&(str[i]), &angle, 1);
    1246. 

  1246.                 if (!read_chars) {
    1247. 

  1247.                     GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error reading angle in skewX: %s\n", attribute_content));
    1248. 

  1248.                     return 0;
    1249. 

  1249.                 }
    1250. 

  1250.                 i += read_chars;
    1251. 

  1251. 				gf_mx2d_init(tmp);
    1252. 

  1252. 				gf_mx2d_add_skew_x(&tmp, angle);
    1253. 

  1253. 				gf_mx2d_add_matrix(&tmp, mat);
    1254. 

  1254. 				gf_mx2d_copy(*mat, tmp);
    1255. 

  1255. 				while(str[i] == ' ') i++;
    1256. 

  1256. 				if (str[i] == ')') i++;
    1257. 

  1257. 				else {
    1258. 

  1258.                     GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Missing closing parenthesis in transform attribute: %s\n", attribute_content));
    1259. 

  1259.                     return 0;
    1260. 

  1260. 				}
    1261. 

  1261. 			} else {
    1262. 

  1262. 				GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Missing opening parenthesis in transform attribute: %s\n", attribute_content));
    1263. 

  1263.                 return 0;
    1264. 

  1264. 			}
    1265. 

  1265. 		} else if (strstr(str+i, "skewY")==str+i) {
    1266. 

  1266. 			i += 5;
    1267. 

  1267. 			while(str[i] == ' ') i++;
    1268. 

  1268. 			if (str[i] == '(') {
    1269. 

  1269. 				Fixed angle;
    1270. 

  1270. 				i++;
    1271. 

  1271. 				read_chars = svg_parse_number(&(str[i]), &angle, 1);
    1272. 

  1272.                 if (!read_chars) {
    1273. 

  1273.                     GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error reading angle component in skewY: %s\n", attribute_content));
    1274. 

  1274.                     return 0;
    1275. 

  1275.                 }
    1276. 

  1276.                 i += read_chars;
    1277. 

  1277. 				gf_mx2d_init(tmp);
    1278. 

  1278. 				gf_mx2d_add_skew_y(&tmp, angle);
    1279. 

  1279. 				gf_mx2d_add_matrix(&tmp, mat);
    1280. 

  1280. 				gf_mx2d_copy(*mat, tmp);
    1281. 

  1281. 				while(str[i] == ' ') i++;
    1282. 

  1282. 				if (str[i] == ')') i++;
    1283. 

  1283. 				else {
    1284. 

  1284.                     GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Missing closing parenthesis in transform attribute: %s\n", attribute_content));
    1285. 

  1285.                     return 0;
    1286. 

  1286. 				}
    1287. 

  1287. 			} else {
    1288. 

  1288. 				GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Missing opening parenthesis in transform attribute: %s\n", attribute_content));
    1289. 

  1289.                 return 0;
    1290. 

  1290. 			}
    1291. 

  1291. 		} else if (strstr(str+i, "matrix")==str+i) {
    1292. 

  1292. 			i+=6;
    1293. 

  1293. 			while(str[i] == ' ') i++;
    1294. 

  1294. 			if (str[i] == '(') {
    1295. 

  1295. 				i++;
    1296. 

  1296. 				read_chars = svg_parse_number(&(str[i]), &(tmp.m[0]), 0);
    1297. 

  1297.                 if (!read_chars) {
    1298. 

  1298.                     GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error reading coefficient a in matrix: %s\n", attribute_content));
    1299. 

  1299.                     return 0;
    1300. 

  1300.                 }
    1301. 

  1301.                 i += read_chars;
    1302. 

  1302. 				read_chars = svg_parse_number(&(str[i]), &(tmp.m[3]), 0);
    1303. 

  1303.                 if (!read_chars) {
    1304. 

  1304.                     GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error reading coefficient b in matrix: %s\n", attribute_content));
    1305. 

  1305.                     return 0;
    1306. 

  1306.                 }
    1307. 

  1307.                 i += read_chars;
    1308. 

  1308. 				read_chars = svg_parse_number(&(str[i]), &(tmp.m[1]), 0);
    1309. 

  1309.                 if (!read_chars) {
    1310. 

  1310.                     GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error reading coefficient c in matrix: %s\n", attribute_content));
    1311. 

  1311.                     return 0;
    1312. 

  1312.                 }
    1313. 

  1313.                 i += read_chars;
    1314. 

  1314. 				read_chars = svg_parse_number(&(str[i]), &(tmp.m[4]), 0);
    1315. 

  1315.                 if (!read_chars) {
    1316. 

  1316.                     GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error reading coefficient d in matrix: %s\n", attribute_content));
    1317. 

  1317.                     return 0;
    1318. 

  1318.                 }
    1319. 

  1319.                 i += read_chars;
    1320. 

  1320. 				read_chars = svg_parse_number(&(str[i]), &(tmp.m[2]), 0);
    1321. 

  1321.                 if (!read_chars) {
    1322. 

  1322.                     GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error reading coefficient e in matrix: %s\n", attribute_content));
    1323. 

  1323.                     return 0;
    1324. 

  1324.                 }
    1325. 

  1325.                 i += read_chars;
    1326. 

  1326. 				read_chars = svg_parse_number(&(str[i]), &(tmp.m[5]), 0);
    1327. 

  1327.                 if (!read_chars) {
    1328. 

  1328.                     GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error reading coefficient f in matrix: %s\n", attribute_content));
    1329. 

  1329.                     return 0;
    1330. 

  1330.                 }
    1331. 

  1331.                 i += read_chars;
    1332. 

  1332. 				gf_mx2d_add_matrix(&tmp, mat);
    1333. 

  1333. 				gf_mx2d_copy(*mat, tmp);
    1334. 

  1334. 				while(str[i] == ' ') i++;
    1335. 

  1335. 				if (str[i] == ')') i++;
    1336. 

  1336. 				else {
    1337. 

  1337.                     GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Missing closing parenthesis in transform attribute: %s\n", attribute_content));
    1338. 

  1338.                     return 0;
    1339. 

  1339. 				}
    1340. 

  1340. 			} else {
    1341. 

  1341. 				GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Missing opening parenthesis in transform attribute: %s\n", attribute_content));
    1342. 

  1342.                 return 0;
    1343. 

  1343. 			}
    1344. 

  1344. 		} else {
    1345. 

  1345. 			GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Unrecognized transofrm type in attribute %s\n", attribute_content));
    1346. 

  1346.             return 0;
    1347. 

  1347. 		}
    1348. 

  1348. 		/*for svgView parsing*/
    1349. 

  1349. 		if (str[i] == ')') i++;
    1350. 

  1350. 	}
    1351. 

  1351.     return 1;
    1352. 

  1352. }
    1353. 

  1353. 

  1354. /* Parses an SVG transform attribute and collapses all in the given matrix */
    1355. 

  1355. static Bool svg_parse_transform(SVG_Transform *t, char *attribute_content)
    1356. 

  1356. {
    1357. 

  1357. 	char *str;
    1358. 

  1358. 	u32 i;
    1359. 

  1359.     u32 read_chars;
    1360. 

  1360. 	str = attribute_content;
    1361. 

  1361. 	i = 0;
    1362. 

  1362. 

  1363. 	if ((str = strstr(attribute_content, "ref"))) {
    1364. 

  1364. 		t->is_ref = 1;
    1365. 

  1365. 		gf_mx2d_init(t->mat);
    1366. 

  1366. 		str+=2;
    1367. 

  1367. 		while (str[i] == ' ') i++;
    1368. 

  1368. 		if (str[i] == '(') {
    1369. 

  1369. 			i++;
    1370. 

  1370. 			while (str[i] == ' ') i++;
    1371. 

  1371. 			if (str[i] == 's' && str[i+1] == 'v' && str[i+2] == 'g') {
    1372. 

  1372. 				i+=3;
    1373. 

  1373. 				while (str[i] == ' ') i++;
    1374. 

  1374.                 if (str[i] == ',') {
    1375. 

  1375.                     i++;
    1376. 

  1376.                 } else if (str[i] == ')') {
    1377. 

  1377. 					i++;
    1378. 

  1378. 					return GF_OK;
    1379. 

  1379. 				}
    1380. 

  1380. 				read_chars = svg_parse_number(&(str[i]), &(t->mat.m[2]), 0);
    1381. 

  1381.                 if (!read_chars) {
    1382. 

  1382.                     GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error reading coefficient tx in ref transform: %s\n", attribute_content));
    1383. 

  1383.                     return GF_BAD_PARAM;
    1384. 

  1384.                 }
    1385. 

  1385.                 i += read_chars;
    1386. 

  1386. 				read_chars = svg_parse_number(&(str[i]), &(t->mat.m[5]), 0);
    1387. 

  1387.                 if (!read_chars) {
    1388. 

  1388.                     GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error reading coefficient ty in ref transform: %s\n", attribute_content));
    1389. 

  1389.                     return GF_BAD_PARAM;
    1390. 

  1390.                 }
    1391. 

  1391.                 i += read_chars;
    1392. 

  1392.             } else {
    1393. 

  1393. 				GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Unsupported syntax for ref transform attribute"));
    1394. 

  1394.             }
    1395. 

  1395. 			while (str[i] == ' ') i++;
    1396. 

  1396. 			if (str[i] == ')') i++;
    1397. 

  1397. 			else {
    1398. 

  1398.                 GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Missing closing parenthesis in transform attribute: %s\n", attribute_content));
    1399. 

  1399. 			}
    1400. 

  1400. 			return GF_OK;
    1401. 

  1401. 		} else {
    1402. 

  1402.             GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Missing opening parenthesis in ref transform attribute: %s\n", attribute_content));
    1403. 

  1403. 			return GF_BAD_PARAM;
    1404. 

  1404. 		}
    1405. 

  1405. 	} else {
    1406. 

  1406. 		read_chars = gf_svg_parse_transformlist(&t->mat, attribute_content);
    1407. 

  1407.         if (!read_chars) {
    1408. 

  1408.             GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error parsing transform list: %s\n", attribute_content));
    1409. 

  1409.             return GF_BAD_PARAM;
    1410. 

  1410.         }
    1411. 

  1411. 	}
    1412. 

  1412. 	return GF_OK;
    1413. 

  1413. }
    1414. 

  1414. 

  1415. #undef REMOVE_ALLOC
    1416. 

  1416. 

  1417. #if USE_GF_PATH
    1418. 

  1418. 

  1419. //#define PARSE_PATH_ONLY
    1420. 

  1420. 

  1421. static void svg_parse_path(SVG_PathData *path, char *attribute_content)
    1422. 

  1422. {
    1423. 

  1423. 	char *d = attribute_content;
    1424. 

  1424. 

  1425.     /* used to detect end of BNF production:
    1426. 

  1426.     "The processing of the BNF must consume as much of a given BNF production as possible,
    1427. 

  1427.     stopping at the point when a character is encountered which no longer satisfies the production." */
    1428. 

  1428.     u32 read_chars = 0;
    1429. 

  1429. 

  1430. 	/* Point used to start a new subpath when the previous subpath is closed */
    1431. 

  1431. 	SVG_Point prev_m_pt;
    1432. 

  1432. 	/* Point used to convert relative 'lower-case commands' into absolute */
    1433. 

  1433. 	SVG_Point rel_ref_pt;
    1434. 

  1434. 	/* Points used to convert S, T commands into C, Q */
    1435. 

  1435. 	SVG_Point orig, ct_orig, ct_end, end;
    1436. 

  1436. 	/* Used by elliptical arcs */
    1437. 

  1437. 	Fixed x_axis_rotation, large_arc_flag, sweep_flag;
    1438. 

  1438. 

  1439. 	char c, prev_c;
    1440. 

  1440. 	u32 i;
    1441. 

  1441. 

  1442. 	if (*d == 0) return;
    1443. 

  1443. 

  1444. 	i = 0;
    1445. 

  1445. 	prev_c = 'M';
    1446. 

  1446. 	orig.x = orig.y = ct_orig.x = ct_orig.y = prev_m_pt.x = prev_m_pt.y = rel_ref_pt.x = rel_ref_pt.y = end.x = end.y = 0;
    1447. 

  1447. 	while(1) {
    1448. 

  1448. 		while ( (d[i]==' ') || (d[i] =='\t') || (d[i] =='\r') || (d[i] =='\n') ) i++;
    1449. 

  1449. 		c = d[i];
    1450. 

  1450. 		if (! c) break;
    1451. 

  1451. next_command:
    1452. 

  1452. 		switch (c) {
    1453. 

  1453. 		case 'm':
    1454. 

  1454. 		case 'M':
    1455. 

  1455. 			i++;
    1456. 

  1456. 			read_chars = svg_parse_number(&(d[i]), &(orig.x), 0);
    1457. 

  1457.             if (!read_chars) return;
    1458. 

  1458.             i += read_chars;
    1459. 

  1459. 			read_chars = svg_parse_number(&(d[i]), &(orig.y), 0);
    1460. 

  1460.             if (!read_chars) return;
    1461. 

  1461.             i += read_chars;
    1462. 

  1462. 			if (c == 'm') {
    1463. 

  1463. 				orig.x += rel_ref_pt.x;
    1464. 

  1464. 				orig.y += rel_ref_pt.y;
    1465. 

  1465. 			}
    1466. 

  1466. #ifndef PARSE_PATH_ONLY
    1467. 

  1467. 			gf_path_add_move_to(path, orig.x, orig.y);
    1468. 

  1468. #endif
    1469. 

  1469. 			rel_ref_pt = orig;
    1470. 

  1470. 			prev_m_pt = orig;
    1471. 

  1471. 			/*provision for nextCurveTo when no curve is specified:
    1472. 

  1472. 				"If there is no previous command or if the previous command was not an C, c, S or s,
    1473. 

  1473. 				assume the first control point is coincident with the current point.
    1474. 

  1474. 			*/
    1475. 

  1475. 			ct_orig = orig;
    1476. 

  1476. 			prev_c = c;
    1477. 

  1477. 			break;
    1478. 

  1478. 		case 'L':
    1479. 

  1479. 		case 'l':
    1480. 

  1480. 			i++;
    1481. 

  1481. 			read_chars = svg_parse_number(&(d[i]), &(orig.x), 0);
    1482. 

  1482.             if (!read_chars) return;
    1483. 

  1483.             i += read_chars;
    1484. 

  1484. 			read_chars = svg_parse_number(&(d[i]), &(orig.y), 0);
    1485. 

  1485.             if (!read_chars) return;
    1486. 

  1486.             i += read_chars;
    1487. 

  1487. 			if (c == 'l') {
    1488. 

  1488. 				orig.x += rel_ref_pt.x;
    1489. 

  1489. 				orig.y += rel_ref_pt.y;
    1490. 

  1490. 			}
    1491. 

  1491. #ifndef PARSE_PATH_ONLY
    1492. 

  1492. 			gf_path_add_line_to(path, orig.x, orig.y);
    1493. 

  1493. #endif
    1494. 

  1494. 			rel_ref_pt = orig;
    1495. 

  1495. 			orig = end;
    1496. 

  1496. 			/*cf above*/
    1497. 

  1497. 			ct_orig = orig;
    1498. 

  1498. 			prev_c = c;
    1499. 

  1499. 			break;
    1500. 

  1500. 		case 'H':
    1501. 

  1501. 		case 'h':
    1502. 

  1502. 			i++;
    1503. 

  1503. 			read_chars = svg_parse_number(&(d[i]), &(orig.x), 0);
    1504. 

  1504.             if (!read_chars) return;
    1505. 

  1505.             i += read_chars;
    1506. 

  1506. 			if (c == 'h') {
    1507. 

  1507. 				orig.x += rel_ref_pt.x;
    1508. 

  1508. 			}
    1509. 

  1509. 			orig.y = rel_ref_pt.y;
    1510. 

  1510. #ifndef PARSE_PATH_ONLY
    1511. 

  1511. 			gf_path_add_line_to(path, orig.x, orig.y);
    1512. 

  1512. #endif
    1513. 

  1513. 			rel_ref_pt.x = orig.x;
    1514. 

  1514. 			orig = end;
    1515. 

  1515. 			/*cf above*/
    1516. 

  1516. 			ct_orig = orig;
    1517. 

  1517. 			prev_c = c;
    1518. 

  1518. 			break;
    1519. 

  1519. 		case 'V':
    1520. 

  1520. 		case 'v':
    1521. 

  1521. 			i++;
    1522. 

  1522. 			read_chars = svg_parse_number(&(d[i]), &(orig.y), 0);
    1523. 

  1523.             if (!read_chars) return;
    1524. 

  1524.             i += read_chars;
    1525. 

  1525. 			if (c == 'v') {
    1526. 

  1526. 				orig.y += rel_ref_pt.y;
    1527. 

  1527. 			}
    1528. 

  1528. 			orig.x = rel_ref_pt.x;
    1529. 

  1529. #ifndef PARSE_PATH_ONLY
    1530. 

  1530. 			gf_path_add_line_to(path, orig.x, orig.y);
    1531. 

  1531. #endif
    1532. 

  1532. 			rel_ref_pt.y = orig.y;
    1533. 

  1533. 			orig = end;
    1534. 

  1534. 			/*cf above*/
    1535. 

  1535. 			ct_orig = orig;
    1536. 

  1536. 			prev_c = c;
    1537. 

  1537. 			break;
    1538. 

  1538. 		case 'C':
    1539. 

  1539. 		case 'c':
    1540. 

  1540. 			i++;
    1541. 

  1541. 			read_chars = svg_parse_number(&(d[i]), &(ct_orig.x), 0);
    1542. 

  1542.             if (!read_chars) return;
    1543. 

  1543.             i += read_chars;
    1544. 

  1544. 			read_chars = svg_parse_number(&(d[i]), &(ct_orig.y), 0);
    1545. 

  1545.             if (!read_chars) return;
    1546. 

  1546.             i += read_chars;
    1547. 

  1547. 			if (c == 'c') {
    1548. 

  1548. 				ct_orig.x += rel_ref_pt.x;
    1549. 

  1549. 				ct_orig.y += rel_ref_pt.y;
    1550. 

  1550. 			}
    1551. 

  1551. 			read_chars = svg_parse_number(&(d[i]), &(ct_end.x), 0);
    1552. 

  1552.             if (!read_chars) return;
    1553. 

  1553.             i += read_chars;
    1554. 

  1554. 			read_chars = svg_parse_number(&(d[i]), &(ct_end.y), 0);
    1555. 

  1555.             if (!read_chars) return;
    1556. 

  1556.             i += read_chars;
    1557. 

  1557. 			if (c == 'c') {
    1558. 

  1558. 				ct_end.x += rel_ref_pt.x;
    1559. 

  1559. 				ct_end.y += rel_ref_pt.y;
    1560. 

  1560. 			}
    1561. 

  1561. 			read_chars = svg_parse_number(&(d[i]), &(end.x), 0);
    1562. 

  1562.             if (!read_chars) return;
    1563. 

  1563.             i += read_chars;
    1564. 

  1564. 			read_chars = svg_parse_number(&(d[i]), &(end.y), 0);
    1565. 

  1565.             if (!read_chars) return;
    1566. 

  1566.             i += read_chars;
    1567. 

  1567. 			if (c == 'c') {
    1568. 

  1568. 				end.x += rel_ref_pt.x;
    1569. 

  1569. 				end.y += rel_ref_pt.y;
    1570. 

  1570. 			}
    1571. 

  1571. #ifndef PARSE_PATH_ONLY
    1572. 

  1572. 			gf_path_add_cubic_to(path, ct_orig.x, ct_orig.y, ct_end.x, ct_end.y, end.x, end.y);
    1573. 

  1573. #endif
    1574. 

  1574. 			rel_ref_pt = end;
    1575. 

  1575. 			ct_orig = ct_end;
    1576. 

  1576. 			orig = end;
    1577. 

  1577. 			prev_c = c;
    1578. 

  1578. 			break;
    1579. 

  1579. 		case 'S':
    1580. 

  1580. 		case 's':
    1581. 

  1581. 			i++;
    1582. 

  1582. 			ct_orig.x = 2*orig.x - ct_orig.x;
    1583. 

  1583. 			ct_orig.y = 2*orig.y - ct_orig.y;
    1584. 

  1584. 			read_chars = svg_parse_number(&(d[i]), &(ct_end.x), 0);
    1585. 

  1585.             if (!read_chars) return;
    1586. 

  1586.             i += read_chars;
    1587. 

  1587. 			read_chars = svg_parse_number(&(d[i]), &(ct_end.y), 0);
    1588. 

  1588.             if (!read_chars) return;
    1589. 

  1589.             i += read_chars;
    1590. 

  1590. 			if (c == 's') {
    1591. 

  1591. 				ct_end.x += rel_ref_pt.x;
    1592. 

  1592. 				ct_end.y += rel_ref_pt.y;
    1593. 

  1593. 			}
    1594. 

  1594. 			read_chars = svg_parse_number(&(d[i]), &(end.x), 0);
    1595. 

  1595.             if (!read_chars) return;
    1596. 

  1596.             i += read_chars;
    1597. 

  1597. 			read_chars = svg_parse_number(&(d[i]), &(end.y), 0);
    1598. 

  1598.             if (!read_chars) return;
    1599. 

  1599.             i += read_chars;
    1600. 

  1600. 			if (c == 's') {
    1601. 

  1601. 				end.x += rel_ref_pt.x;
    1602. 

  1602. 				end.y += rel_ref_pt.y;
    1603. 

  1603. 			}
    1604. 

  1604. #ifndef PARSE_PATH_ONLY
    1605. 

  1605. 			gf_path_add_cubic_to(path, ct_orig.x, ct_orig.y, ct_end.x, ct_end.y, end.x, end.y);
    1606. 

  1606. #endif
    1607. 

  1607. 			rel_ref_pt = end;
    1608. 

  1608. 			ct_orig = ct_end;
    1609. 

  1609. 			orig = end;
    1610. 

  1610. 			prev_c = c;
    1611. 

  1611. 			break;
    1612. 

  1612. 		case 'Q':
    1613. 

  1613. 		case 'q':
    1614. 

  1614. 			i++;
    1615. 

  1615. 			read_chars = svg_parse_number(&(d[i]), &(ct_orig.x), 0);
    1616. 

  1616.             if (!read_chars) return;
    1617. 

  1617.             i += read_chars;
    1618. 

  1618. 			read_chars = svg_parse_number(&(d[i]), &(ct_orig.y), 0);
    1619. 

  1619.             if (!read_chars) return;
    1620. 

  1620.             i += read_chars;
    1621. 

  1621. 			if (c == 'q') {
    1622. 

  1622. 				ct_orig.x += rel_ref_pt.x;
    1623. 

  1623. 				ct_orig.y += rel_ref_pt.y;
    1624. 

  1624. 			}
    1625. 

  1625. 			read_chars = svg_parse_number(&(d[i]), &(end.x), 0);
    1626. 

  1626.             if (!read_chars) return;
    1627. 

  1627.             i += read_chars;
    1628. 

  1628. 			read_chars = svg_parse_number(&(d[i]), &(end.y), 0);
    1629. 

  1629.             if (!read_chars) return;
    1630. 

  1630.             i += read_chars;
    1631. 

  1631. 			if (c == 'q') {
    1632. 

  1632. 				end.x += rel_ref_pt.x;
    1633. 

  1633. 				end.y += rel_ref_pt.y;
    1634. 

  1634. 			}
    1635. 

  1635. #ifndef PARSE_PATH_ONLY
    1636. 

  1636. 			gf_path_add_quadratic_to(path, ct_orig.x, ct_orig.y, end.x, end.y);
    1637. 

  1637. #endif
    1638. 

  1638. 			rel_ref_pt = end;
    1639. 

  1639. 			orig = end;
    1640. 

  1640. 			prev_c = c;
    1641. 

  1641. 			break;
    1642. 

  1642. 		case 'T':
    1643. 

  1643. 		case 't':
    1644. 

  1644. 			i++;
    1645. 

  1645. 			ct_orig.x = 2*orig.x - ct_orig.x;
    1646. 

  1646. 			ct_orig.y = 2*orig.y - ct_orig.y;
    1647. 

  1647. 			read_chars = svg_parse_number(&(d[i]), &(end.x), 0);
    1648. 

  1648.             if (!read_chars) return;
    1649. 

  1649.             i += read_chars;
    1650. 

  1650. 			read_chars = svg_parse_number(&(d[i]), &(end.y), 0);
    1651. 

  1651.             if (!read_chars) return;
    1652. 

  1652.             i += read_chars;
    1653. 

  1653. 			if (c == 't') {
    1654. 

  1654. 				end.x += rel_ref_pt.x;
    1655. 

  1655. 				end.y += rel_ref_pt.y;
    1656. 

  1656. 			}
    1657. 

  1657. #ifndef PARSE_PATH_ONLY
    1658. 

  1658. 			gf_path_add_quadratic_to(path, ct_orig.x, ct_orig.y, end.x, end.y);
    1659. 

  1659. #endif
    1660. 

  1660. 			rel_ref_pt = end;
    1661. 

  1661. 			orig = end;
    1662. 

  1662. 			prev_c = c;
    1663. 

  1663. 			break;
    1664. 

  1664. 		case 'A':
    1665. 

  1665. 		case 'a':
    1666. 

  1666. 			i++;
    1667. 

  1667. 

  1668. 			read_chars = svg_parse_number(&(d[i]), &(orig.x), 0);
    1669. 

  1669.             if (!read_chars) return;
    1670. 

  1670.             i += read_chars;
    1671. 

  1671. 			read_chars = svg_parse_number(&(d[i]), &(orig.y), 0);
    1672. 

  1672.             if (!read_chars) return;
    1673. 

  1673.             i += read_chars;
    1674. 

  1674. 

  1675. 			read_chars = svg_parse_number(&(d[i]), &(x_axis_rotation), 0);
    1676. 

  1676.             if (!read_chars) return;
    1677. 

  1677.             i += read_chars;
    1678. 

  1678. 			read_chars = svg_parse_number(&(d[i]), &(large_arc_flag), 0);
    1679. 

  1679.             if (!read_chars) return;
    1680. 

  1680.             i += read_chars;
    1681. 

  1681. 			read_chars = svg_parse_number(&(d[i]), &(sweep_flag), 0);
    1682. 

  1682.             if (!read_chars) return;
    1683. 

  1683.             i += read_chars;
    1684. 

  1684. 

  1685. 			read_chars = svg_parse_number(&(d[i]), &(end.x), 0);
    1686. 

  1686.             if (!read_chars) return;
    1687. 

  1687.             i += read_chars;
    1688. 

  1688. 			read_chars = svg_parse_number(&(d[i]), &(end.y), 0);
    1689. 

  1689.             if (!read_chars) return;
    1690. 

  1690.             i += read_chars;
    1691. 

  1691. 			if (c == 'a') {
    1692. 

  1692. 				end.x += rel_ref_pt.x;
    1693. 

  1693. 				end.y += rel_ref_pt.y;
    1694. 

  1694. 			}
    1695. 

  1695. #ifndef PARSE_PATH_ONLY
    1696. 

  1696. 			gf_path_add_svg_arc_to(path, end.x, end.y, orig.x, orig.y, x_axis_rotation , (large_arc_flag == FIX_ONE ? 1 : 0), (sweep_flag == FIX_ONE ? 1 : 0));
    1697. 

  1697. #endif
    1698. 

  1698. 			rel_ref_pt = end;
    1699. 

  1699. 			ct_orig = end;
    1700. 

  1700. 			prev_c = c;
    1701. 

  1701. 			break;
    1702. 

  1702. 		case 'Z':
    1703. 

  1703. 		case 'z':
    1704. 

  1704. 			i++;
    1705. 

  1705. #ifndef PARSE_PATH_ONLY
    1706. 

  1706. 			gf_path_close(path);
    1707. 

  1707. #endif
    1708. 

  1708. 			prev_c = c;
    1709. 

  1709. 			rel_ref_pt = prev_m_pt;
    1710. 

  1710. 			break;
    1711. 

  1711. 		default:
    1712. 

  1712. 			i--;
    1713. 

  1713. 			switch (prev_c) {
    1714. 

  1714. 			case 'M':
    1715. 

  1715. 				c = 'L';
    1716. 

  1716. 				break;
    1717. 

  1717. 			case 'm':
    1718. 

  1718. 				c = 'l';
    1719. 

  1719. 				break;
    1720. 

  1720. 			default:
    1721. 

  1721. 				c = prev_c;
    1722. 

  1722. 			}
    1723. 

  1723. 			goto next_command;
    1724. 

  1724. 		}
    1725. 

  1725. 	}
    1726. 

  1726. }
    1727. 

  1727. #else
    1728. 

  1728. /* TODO: Change the function to handle elliptical arcs, requires changing data structure */
    1729. 

  1729. static void svg_parse_path(SVG_PathData *d_attribute, char *attribute_content)
    1730. 

  1730. {
    1731. 

  1731. 	GF_List *d_commands = d_attribute->commands;
    1732. 

  1732. 	GF_List *d_points = d_attribute->points;
    1733. 

  1733. 	char *d = attribute_content;
    1734. 

  1734. 

  1735. 	if (strlen(d)) {
    1736. 

  1736. 		SVG_Point *pt, cur_pt, prev_m_pt;
    1737. 

  1737. 		u8 *command;
    1738. 

  1738. 		u32 i, k;
    1739. 

  1739. 		char c, prev_c = 'M';
    1740. 

  1740. #ifdef REMOVE_ALLOC
    1741. 

  1741. 		GF_SAFEALLOC(pt, SVG_Point)
    1742. 

  1742. #endif
    1743. 

  1743. 		i = 0;
    1744. 

  1744. 		cur_pt.x = cur_pt.y = 0;
    1745. 

  1745. 		prev_m_pt.x = prev_m_pt.y = 0;
    1746. 

  1746. 		while(1) {
    1747. 

  1747. 			while ( (d[i]==' ') || (d[i] =='\t') ) i++;
    1748. 

  1748. 			c = d[i];
    1749. 

  1749. 			if (! c) break;
    1750. 

  1750. next_command:
    1751. 

  1751. 			switch (c) {
    1752. 

  1752. 			case 'm':
    1753. 

  1753. 			case 'M':
    1754. 

  1754. 				i++;
    1755. 

  1755. #ifndef REMOVE_ALLOC
    1756. 

  1756. 				GF_SAFEALLOC(command, u8)
    1757. 

  1757. 				gf_list_add(d_commands, command);
    1758. 

  1758. 				*command = SVG_PATHCOMMAND_M;
    1759. 

  1759. 

  1760. 				GF_SAFEALLOC(pt, SVG_Point)
    1761. 

  1761. 				gf_list_add(d_points, pt);
    1762. 

  1762. #endif
    1763. 

  1763. 				i += svg_parse_number(&(d[i]), &(pt->x), 0);
    1764. 

  1764. 				i += svg_parse_number(&(d[i]), &(pt->y), 0);
    1765. 

  1765. 				if (c == 'm') {
    1766. 

  1766. 					pt->x += cur_pt.x;
    1767. 

  1767. 					pt->y += cur_pt.y;
    1768. 

  1768. 				}
    1769. 

  1769. 				cur_pt.x = pt->x;
    1770. 

  1770. 				cur_pt.y = pt->y;
    1771. 

  1771. 				prev_m_pt = cur_pt;
    1772. 

  1772. 				prev_c = c;
    1773. 

  1773. 				break;
    1774. 

  1774. 			case 'L':
    1775. 

  1775. 			case 'l':
    1776. 

  1776. 				i++;
    1777. 

  1777. #ifndef REMOVE_ALLOC
    1778. 

  1778. 				GF_SAFEALLOC(command, u8)
    1779. 

  1779. 				gf_list_add(d_commands, command);
    1780. 

  1780. 				*command = SVG_PATHCOMMAND_L;
    1781. 

  1781. 

  1782. 				GF_SAFEALLOC(pt, SVG_Point)
    1783. 

  1783. 				gf_list_add(d_points, pt);
    1784. 

  1784. #endif
    1785. 

  1785. 				i += svg_parse_number(&(d[i]), &(pt->x), 0);
    1786. 

  1786. 				i += svg_parse_number(&(d[i]), &(pt->y), 0);
    1787. 

  1787. 				if (c == 'l') {
    1788. 

  1788. 					pt->x += cur_pt.x;
    1789. 

  1789. 					pt->y += cur_pt.y;
    1790. 

  1790. 				}
    1791. 

  1791. 				cur_pt.x = pt->x;
    1792. 

  1792. 				cur_pt.y = pt->y;
    1793. 

  1793. 				prev_c = c;
    1794. 

  1794. 				break;
    1795. 

  1795. 			case 'H':
    1796. 

  1796. 			case 'h':
    1797. 

  1797. 				i++;
    1798. 

  1798. #ifndef REMOVE_ALLOC
    1799. 

  1799. 				GF_SAFEALLOC(command, u8)
    1800. 

  1800. 				gf_list_add(d_commands, command);
    1801. 

  1801. 				*command = SVG_PATHCOMMAND_L;
    1802. 

  1802. 

  1803. 				GF_SAFEALLOC(pt, SVG_Point)
    1804. 

  1804. 				gf_list_add(d_points, pt);
    1805. 

  1805. #endif
    1806. 

  1806. 				i += svg_parse_number(&(d[i]), &(pt->x), 0);
    1807. 

  1807. 				if (c == 'h') {
    1808. 

  1808. 					pt->x += cur_pt.x;
    1809. 

  1809. 				}
    1810. 

  1810. 				pt->y = cur_pt.y;
    1811. 

  1811. 				cur_pt.x = pt->x;
    1812. 

  1812. 				prev_c = c;
    1813. 

  1813. 				break;
    1814. 

  1814. 			case 'V':
    1815. 

  1815. 			case 'v':
    1816. 

  1816. 				i++;
    1817. 

  1817. #ifndef REMOVE_ALLOC
    1818. 

  1818. 				GF_SAFEALLOC(command, u8)
    1819. 

  1819. 				gf_list_add(d_commands, command);
    1820. 

  1820. 				*command = SVG_PATHCOMMAND_L;
    1821. 

  1821. 

  1822. 				GF_SAFEALLOC(pt, SVG_Point)
    1823. 

  1823. 				gf_list_add(d_points, pt);
    1824. 

  1824. #endif
    1825. 

  1825. 				i += svg_parse_number(&(d[i]), &(pt->y), 0);
    1826. 

  1826. 				if (c == 'v') {
    1827. 

  1827. 					pt->y += cur_pt.y;
    1828. 

  1828. 				}
    1829. 

  1829. 				pt->x = cur_pt.x;
    1830. 

  1830. 				cur_pt.y = pt->y;
    1831. 

  1831. 				prev_c = c;
    1832. 

  1832. 				break;
    1833. 

  1833. 			case 'C':
    1834. 

  1834. 			case 'c':
    1835. 

  1835. 				i++;
    1836. 

  1836. #ifndef REMOVE_ALLOC
    1837. 

  1837. 				GF_SAFEALLOC(command, u8)
    1838. 

  1838. 				gf_list_add(d_commands, command);
    1839. 

  1839. 				*command = SVG_PATHCOMMAND_C;
    1840. 

  1840. #endif
    1841. 

  1841. 

  1842. 				for (k=0; k<3; k++) {
    1843. 

  1843. #ifndef REMOVE_ALLOC
    1844. 

  1844. 					GF_SAFEALLOC(pt, SVG_Point)
    1845. 

  1845. 					gf_list_add(d_points, pt);
    1846. 

  1846. #endif
    1847. 

  1847. 					i += svg_parse_number(&(d[i]), &(pt->x), 0);
    1848. 

  1848. 					i += svg_parse_number(&(d[i]), &(pt->y), 0);
    1849. 

  1849. 					if (c == 'c') {
    1850. 

  1850. 						pt->x += cur_pt.x;
    1851. 

  1851. 						pt->y += cur_pt.y;
    1852. 

  1852. 					}
    1853. 

  1853. 				}
    1854. 

  1854. 				cur_pt.x = pt->x;
    1855. 

  1855. 				cur_pt.y = pt->y;
    1856. 

  1856. 				prev_c = c;
    1857. 

  1857. 				break;
    1858. 

  1858. 			case 'S':
    1859. 

  1859. 			case 's':
    1860. 

  1860. 				i++;
    1861. 

  1861. #ifndef REMOVE_ALLOC
    1862. 

  1862. 				GF_SAFEALLOC(command, u8)
    1863. 

  1863. 				gf_list_add(d_commands, command);
    1864. 

  1864. 				*command = SVG_PATHCOMMAND_S;
    1865. 

  1865. #endif
    1866. 

  1866. 

  1867. 				for (k=0; k<2; k++) {
    1868. 

  1868. #ifndef REMOVE_ALLOC
    1869. 

  1869. 					GF_SAFEALLOC(pt, SVG_Point)
    1870. 

  1870. 					gf_list_add(d_points, pt);
    1871. 

  1871. #endif
    1872. 

  1872. 					i += svg_parse_number(&(d[i]), &(pt->x), 0);
    1873. 

  1873. 					i += svg_parse_number(&(d[i]), &(pt->y), 0);
    1874. 

  1874. 					if (c == 's') {
    1875. 

  1875. 						pt->x += cur_pt.x;
    1876. 

  1876. 						pt->y += cur_pt.y;
    1877. 

  1877. 					}
    1878. 

  1878. 				}
    1879. 

  1879. 				cur_pt.x = pt->x;
    1880. 

  1880. 				cur_pt.y = pt->y;
    1881. 

  1881. 				prev_c = c;
    1882. 

  1882. 				break;
    1883. 

  1883. 			case 'Q':
    1884. 

  1884. 			case 'q':
    1885. 

  1885. 				i++;
    1886. 

  1886. #ifndef REMOVE_ALLOC
    1887. 

  1887. 				GF_SAFEALLOC(command, u8)
    1888. 

  1888. 				gf_list_add(d_commands, command);
    1889. 

  1889. 				*command = SVG_PATHCOMMAND_Q;
    1890. 

  1890. #endif
    1891. 

  1891. 

  1892. 				for (k=0; k<2; k++) {
    1893. 

  1893. #ifndef REMOVE_ALLOC
    1894. 

  1894. 					GF_SAFEALLOC(pt, SVG_Point)
    1895. 

  1895. 					gf_list_add(d_points, pt);
    1896. 

  1896. #endif
    1897. 

  1897. 					i += svg_parse_number(&(d[i]), &(pt->x), 0);
    1898. 

  1898. 					i += svg_parse_number(&(d[i]), &(pt->y), 0);
    1899. 

  1899. 					if (c == 'q') {
    1900. 

  1900. 						pt->x += cur_pt.x;
    1901. 

  1901. 						pt->y += cur_pt.y;
    1902. 

  1902. 					}
    1903. 

  1903. 				}
    1904. 

  1904. 				cur_pt.x = pt->x;
    1905. 

  1905. 				cur_pt.y = pt->y;
    1906. 

  1906. 				prev_c = c;
    1907. 

  1907. 				break;
    1908. 

  1908. 			case 'T':
    1909. 

  1909. 			case 't':
    1910. 

  1910. 				i++;
    1911. 

  1911. #ifndef REMOVE_ALLOC
    1912. 

  1912. 				GF_SAFEALLOC(command, u8)
    1913. 

  1913. 				gf_list_add(d_commands, command);
    1914. 

  1914. 				*command = SVG_PATHCOMMAND_T;
    1915. 

  1915. 

  1916. 				GF_SAFEALLOC(pt, SVG_Point)
    1917. 

  1917. 				gf_list_add(d_points, pt);
    1918. 

  1918. #endif
    1919. 

  1919. 				i += svg_parse_number(&(d[i]), &(pt->x), 0);
    1920. 

  1920. 				i += svg_parse_number(&(d[i]), &(pt->y), 0);
    1921. 

  1921. 				if (c == 't') {
    1922. 

  1922. 					pt->x += cur_pt.x;
    1923. 

  1923. 					pt->y += cur_pt.y;
    1924. 

  1924. 				}
    1925. 

  1925. 				cur_pt.x = pt->x;
    1926. 

  1926. 				cur_pt.y = pt->y;
    1927. 

  1927. 				prev_c = c;
    1928. 

  1928. 				break;
    1929. 

  1929. 			case 'A':
    1930. 

  1930. 			case 'a':
    1931. 

  1931. 				{
    1932. 

  1932. 					Fixed tmp;
    1933. 

  1933. 					i++;
    1934. 

  1934. #ifndef REMOVE_ALLOC
    1935. 

  1935. 					GF_SAFEALLOC(command, u8)
    1936. 

  1936. 					gf_list_add(d_commands, command);
    1937. 

  1937. 					*command = SVG_PATHCOMMAND_A;
    1938. 

  1938. 

  1939. 					GF_SAFEALLOC(pt, SVG_Point)
    1940. 

  1940. 					gf_list_add(d_points, pt);
    1941. 

  1941. #endif
    1942. 

  1942. 					i += svg_parse_number(&(d[i]), &(pt->x), 0);
    1943. 

  1943. 					i += svg_parse_number(&(d[i]), &(pt->y), 0);
    1944. 

  1944. 

  1945. 					i += svg_parse_number(&(d[i]), &(tmp), 0);
    1946. 

  1946. 					i += svg_parse_number(&(d[i]), &(tmp), 0);
    1947. 

  1947. 					i += svg_parse_number(&(d[i]), &(tmp), 0);
    1948. 

  1948. 

  1949. #ifndef REMOVE_ALLOC
    1950. 

  1950. 					GF_SAFEALLOC(pt, SVG_Point)
    1951. 

  1951. 					gf_list_add(d_points, pt);
    1952. 

  1952. #endif
    1953. 

  1953. 					i += svg_parse_number(&(d[i]), &(pt->x), 0);
    1954. 

  1954. 					i += svg_parse_number(&(d[i]), &(pt->y), 0);
    1955. 

  1955. 					if (c == 'a') {
    1956. 

  1956. 						pt->x += cur_pt.x;
    1957. 

  1957. 						pt->y += cur_pt.y;
    1958. 

  1958. 					}
    1959. 

  1959. 					cur_pt.x = pt->x;
    1960. 

  1960. 					cur_pt.y = pt->y;
    1961. 

  1961. 				}
    1962. 

  1962. 				prev_c = c;
    1963. 

  1963. 				break;
    1964. 

  1964. 			case 'Z':
    1965. 

  1965. 			case 'z':
    1966. 

  1966. 				i++;
    1967. 

  1967. #ifndef REMOVE_ALLOC
    1968. 

  1968. 				GF_SAFEALLOC(command, u8)
    1969. 

  1969. 				gf_list_add(d_commands, command);
    1970. 

  1970. 				*command = SVG_PATHCOMMAND_Z;
    1971. 

  1971. #endif
    1972. 

  1972. 				prev_c = c;
    1973. 

  1973. 				cur_pt = prev_m_pt;
    1974. 

  1974. 				break;
    1975. 

  1975. 			default:
    1976. 

  1976. 				i--;
    1977. 

  1977. 				switch (prev_c) {
    1978. 

  1978. 				case 'M':
    1979. 

  1979. 					c = 'L';
    1980. 

  1980. 					break;
    1981. 

  1981. 				case 'm':
    1982. 

  1982. 					c = 'l';
    1983. 

  1983. 					break;
    1984. 

  1984. 				default:
    1985. 

  1985. 					c = prev_c;
    1986. 

  1986. 				}
    1987. 

  1987. 				goto next_command;
    1988. 

  1988. 			}
    1989. 

  1989. 		}
    1990. 

  1990. 	}
    1991. 

  1991. }
    1992. 

  1992. #endif
    1993. 

  1993. 

  1994. static void svg_parse_iri(GF_Node *elt, XMLRI *iri, char *attribute_content)
    1995. 

  1995. {
    1996. 

  1996. 	if (iri->string) {
    1997. 

  1997. 		gf_free(iri->string);
    1998. 

  1998. 		iri->string = NULL;
    1999. 

  1999. 	}
    2000. 

  2000. 	/* TODO: Handle xpointer(id()) syntax */
    2001. 

  2001. 	if (attribute_content[0] == '#') {
    2002. 

  2002. 		iri->string = gf_strdup(attribute_content);
    2003. 

  2003. 		iri->target = gf_sg_find_node_by_name(elt->sgprivate->scenegraph, attribute_content + 1);
    2004. 

  2004. 		if (!iri->target) {
    2005. 

  2005. 			iri->type = XMLRI_STRING;
    2006. 

  2006. 		} else {
    2007. 

  2007. 			iri->type = XMLRI_ELEMENTID;
    2008. 

  2008. 			gf_node_register_iri(elt->sgprivate->scenegraph, iri);
    2009. 

  2009. 		}
    2010. 

  2010. 	} else {
    2011. 

  2011. 		iri->type = XMLRI_STRING;
    2012. 

  2012. 		iri->string = gf_strdup(attribute_content);
    2013. 

  2013. 	}
    2014. 

  2014. }
    2015. 

  2015. 

  2016. static void svg_parse_idref(GF_Node *elt, XML_IDREF *iri, char *attribute_content)
    2017. 

  2017. {
    2018. 

  2018. 	iri->type = XMLRI_ELEMENTID;
    2019. 

  2019. 	iri->target = gf_sg_find_node_by_name(elt->sgprivate->scenegraph, attribute_content);
    2020. 

  2020. 	if (!iri->target) {
    2021. 

  2021. 		iri->string = gf_strdup(attribute_content);
    2022. 

  2022. 	} else {
    2023. 

  2023. 		gf_node_register_iri(elt->sgprivate->scenegraph, iri);
    2024. 

  2024. 	}
    2025. 

  2025. }
    2026. 

  2026. 

  2027. /* Parses a paint attribute: none, inherit or color */
    2028. 

  2028. static void svg_parse_paint(GF_Node *n, SVG_Paint *paint, char *attribute_content)
    2029. 

  2029. {
    2030. 

  2030. 	if (!strcmp(attribute_content, "none")) {
    2031. 

  2031. 		paint->type = SVG_PAINT_NONE;
    2032. 

  2032. 	} else if (!strcmp(attribute_content, "inherit")) {
    2033. 

  2033. 		paint->type = SVG_PAINT_INHERIT;
    2034. 

  2034. 	} else if (!strncmp(attribute_content, "url(", 4) ) {
    2035. 

  2035. 		char *ext = strrchr(attribute_content, ')');
    2036. 

  2036. 		paint->type = SVG_PAINT_URI;
    2037. 

  2037. 		if (ext) ext[0] = 0;
    2038. 

  2038. 		svg_parse_iri(n, &paint->iri, attribute_content+4);
    2039. 

  2039. 		if (ext) ext[0] = ')';
    2040. 

  2040. 	} else {
    2041. 

  2041. 		paint->type = SVG_PAINT_COLOR;
    2042. 

  2042. 		svg_parse_color(&paint->color, attribute_content);
    2043. 

  2043. 	}
    2044. 

  2044. }
    2045. 

  2045. 

  2046. /* Parses a length which is a number with a unit */
    2047. 

  2047. static u32 svg_parse_length(SVG_Number *number, char *value_string, Bool clamp0to1)
    2048. 

  2048. {
    2049. 

  2049.     char c = '\0';
    2050. 

  2050.     char *unit = NULL;
    2051. 

  2051.     u32 len = 0;
    2052. 

  2052.     u32 unit_pos = 0;
    2053. 

  2053.     u32 unit_len = 0;
    2054. 

  2054.     u32 read_chars;
    2055. 

  2055. 

  2056. 	if (!strcmp(value_string, "inherit")) {
    2057. 

  2057. 		number->type = SVG_NUMBER_INHERIT;
    2058. 

  2058. 		return 7;
    2059. 

  2059. 	} else if (!strcmp(value_string, "auto")) {
    2060. 

  2060. 		number->type = SVG_NUMBER_AUTO;
    2061. 

  2061. 		return 4;
    2062. 

  2062. 	} else if (!strcmp(value_string, "auto-reverse")) {
    2063. 

  2063. 		number->type = SVG_NUMBER_AUTO_REVERSE;
    2064. 

  2064. 		return 12;
    2065. 

  2065. 	} else if ((unit = strstr(value_string, "%")) ) {
    2066. 

  2066. 		number->type = SVG_NUMBER_PERCENTAGE;
    2067. 

  2067.         unit_len = 1;
    2068. 

  2068. 	} else if ((unit = strstr(value_string, "em"))) {
    2069. 

  2069. 		number->type = SVG_NUMBER_EMS;
    2070. 

  2070. 	} else if ((unit = strstr(value_string, "ex"))) {
    2071. 

  2071. 		number->type = SVG_NUMBER_EXS;
    2072. 

  2072. 	} else if ((unit = strstr(value_string, "px"))) {
    2073. 

  2073. 		number->type = SVG_NUMBER_PX;
    2074. 

  2074. 	} else if ((unit = strstr(value_string, "cm"))) {
    2075. 

  2075. 		number->type = SVG_NUMBER_CM;
    2076. 

  2076. 	} else if ((unit = strstr(value_string, "mm"))) {
    2077. 

  2077. 		number->type = SVG_NUMBER_MM;
    2078. 

  2078. 	} else if ((unit = strstr(value_string, "in"))) {
    2079. 

  2079. 		number->type = SVG_NUMBER_IN;
    2080. 

  2080. 	} else if ((unit = strstr(value_string, "pt"))) {
    2081. 

  2081. 		number->type = SVG_NUMBER_PT;
    2082. 

  2082. 	} else if ((unit = strstr(value_string, "pc"))) {
    2083. 

  2083. 		number->type = SVG_NUMBER_PC;
    2084. 

  2084. 	} else {
    2085. 

  2085. 		number->type = SVG_NUMBER_VALUE;
    2086. 

  2086. 	}
    2087. 

  2087.     if (unit) {
    2088. 

  2088.         if (!unit_len) unit_len = 2;
    2089. 

  2089.         unit_pos = (u32) (unit - value_string);
    2090. 

  2090.         /* setting the first unit character to 0 for the svg_parse_number method to finish */
    2091. 

  2091.         c = value_string[unit_pos];
    2092. 

  2092.         value_string[unit_pos] = 0;
    2093. 

  2093.     }
    2094. 

  2094. 	read_chars = svg_parse_number(value_string, &(number->value), 0);
    2095. 

  2095.     if (unit) {
    2096. 

  2096.         value_string[unit_pos] = c;
    2097. 

  2097.     }
    2098. 

  2098.     if (!read_chars) {
    2099. 

  2099.         GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error in parsing: %s\n", value_string));
    2100. 

  2100.         len = 0;
    2101. 

  2101.     } else {
    2102. 

  2102.         len = unit_len + read_chars;
    2103. 

  2103.     }
    2104. 

  2104. 

  2105. 	if (clamp0to1) number->value = MAX(0, MIN(1, number->value));
    2106. 

  2106. 	return len;
    2107. 

  2107. }
    2108. 

  2108. 

  2109. static void svg_parse_visibility(SVG_Visibility *value, char *value_string)
    2110. 

  2110. {
    2111. 

  2111. 	if (!strcmp(value_string, "inherit")) {
    2112. 

  2112. 		*value = SVG_VISIBILITY_INHERIT;
    2113. 

  2113. 	} else if (!strcmp(value_string, "visible")) {
    2114. 

  2114. 		*value = SVG_VISIBILITY_VISIBLE;
    2115. 

  2115. 	} else if (!strcmp(value_string, "hidden")) {
    2116. 

  2116. 		*value = SVG_VISIBILITY_HIDDEN;
    2117. 

  2117. 	} else if (!strcmp(value_string, "collapse")) {
    2118. 

  2118. 		*value = SVG_VISIBILITY_COLLAPSE;
    2119. 

  2119. 	}
    2120. 

  2120. }
    2121. 

  2121. 

  2122. static void svg_parse_display(SVG_Display *value, char *value_string)
    2123. 

  2123. {
    2124. 

  2124. 	if (!strcmp(value_string, "inherit")) {
    2125. 

  2125. 		*value = SVG_DISPLAY_INHERIT;
    2126. 

  2126. 	} else if (!strcmp(value_string, "none")) {
    2127. 

  2127. 		*value = SVG_DISPLAY_NONE;
    2128. 

  2128. 	} else if (!strcmp(value_string, "inline")) {
    2129. 

  2129. 		*value = SVG_DISPLAY_INLINE;
    2130. 

  2130. 	} else if (!strcmp(value_string, "block")) {
    2131. 

  2131. 		*value = SVG_DISPLAY_BLOCK;
    2132. 

  2132. 	} else if (!strcmp(value_string, "list-item")) {
    2133. 

  2133. 		*value = SVG_DISPLAY_LIST_ITEM;
    2134. 

  2134. 	} else if (!strcmp(value_string, "run-in")) {
    2135. 

  2135. 		*value = SVG_DISPLAY_RUN_IN;
    2136. 

  2136. 	} else if (!strcmp(value_string, "compact")) {
    2137. 

  2137. 		*value = SVG_DISPLAY_COMPACT;
    2138. 

  2138. 	} else if (!strcmp(value_string, "marker")) {
    2139. 

  2139. 		*value = SVG_DISPLAY_MARKER;
    2140. 

  2140. 	} else if (!strcmp(value_string, "table")) {
    2141. 

  2141. 		*value = SVG_DISPLAY_TABLE;
    2142. 

  2142. 	} else if (!strcmp(value_string, "inline-table")) {
    2143. 

  2143. 		*value = SVG_DISPLAY_INLINE_TABLE;
    2144. 

  2144. 	} else if (!strcmp(value_string, "table-row-group")) {
    2145. 

  2145. 		*value = SVG_DISPLAY_TABLE_ROW_GROUP;
    2146. 

  2146. 	} else if (!strcmp(value_string, "table-header-group")) {
    2147. 

  2147. 		*value = SVG_DISPLAY_TABLE_HEADER_GROUP;
    2148. 

  2148. 	} else if (!strcmp(value_string, "table-footer-group")) {
    2149. 

  2149. 		*value = SVG_DISPLAY_TABLE_FOOTER_GROUP;
    2150. 

  2150. 	} else if (!strcmp(value_string, "table-row")) {
    2151. 

  2151. 		*value = SVG_DISPLAY_TABLE_ROW;
    2152. 

  2152. 	} else if (!strcmp(value_string, "table-column-group")) {
    2153. 

  2153. 		*value = SVG_DISPLAY_TABLE_COLUMN_GROUP;
    2154. 

  2154. 	} else if (!strcmp(value_string, "table-column")) {
    2155. 

  2155. 		*value = SVG_DISPLAY_TABLE_COLUMN;
    2156. 

  2156. 	} else if (!strcmp(value_string, "table-cell")) {
    2157. 

  2157. 		*value = SVG_DISPLAY_TABLE_CELL;
    2158. 

  2158. 	} else if (!strcmp(value_string, "table-caption")) {
    2159. 

  2159. 		*value = SVG_DISPLAY_TABLE_CAPTION;
    2160. 

  2160. 	}
    2161. 

  2161. }
    2162. 

  2162. 

  2163. static void svg_parse_displayalign(SVG_DisplayAlign *value, char *value_string)
    2164. 

  2164. {
    2165. 

  2165. 	if (!strcmp(value_string, "inherit")) {
    2166. 

  2166. 		*value = SVG_DISPLAYALIGN_INHERIT;
    2167. 

  2167. 	} else if (!strcmp(value_string, "auto")) {
    2168. 

  2168. 		*value = SVG_DISPLAYALIGN_AUTO;
    2169. 

  2169. 	} else if (!strcmp(value_string, "before")) {
    2170. 

  2170. 		*value = SVG_DISPLAYALIGN_BEFORE;
    2171. 

  2171. 	} else if (!strcmp(value_string, "center")) {
    2172. 

  2172. 		*value = SVG_DISPLAYALIGN_CENTER;
    2173. 

  2173. 	} else if (!strcmp(value_string, "after")) {
    2174. 

  2174. 		*value = SVG_DISPLAYALIGN_AFTER;
    2175. 

  2175. 	}
    2176. 

  2176. }
    2177. 

  2177. 

  2178. static void svg_parse_textalign(SVG_TextAlign *value, char *value_string)
    2179. 

  2179. {
    2180. 

  2180. 	if (!strcmp(value_string, "inherit")) {
    2181. 

  2181. 		*value = SVG_TEXTALIGN_INHERIT;
    2182. 

  2182. 	} else if (!strcmp(value_string, "start")) {
    2183. 

  2183. 		*value = SVG_TEXTALIGN_START;
    2184. 

  2184. 	} else if (!strcmp(value_string, "center")) {
    2185. 

  2185. 		*value = SVG_TEXTALIGN_CENTER;
    2186. 

  2186. 	} else if (!strcmp(value_string, "end")) {
    2187. 

  2187. 		*value = SVG_TEXTALIGN_END;
    2188. 

  2188. 	}
    2189. 

  2189. }
    2190. 

  2190. 

  2191. static void svg_parse_pointerevents(SVG_PointerEvents *value, char *value_string)
    2192. 

  2192. {
    2193. 

  2193. 	if (!strcmp(value_string, "inherit")) {
    2194. 

  2194. 		*value = SVG_POINTEREVENTS_INHERIT;
    2195. 

  2195. 	} else if (!strcmp(value_string, "visiblePainted")) {
    2196. 

  2196. 		*value = SVG_POINTEREVENTS_VISIBLEPAINTED;
    2197. 

  2197. 	} else if (!strcmp(value_string, "visibleFill")) {
    2198. 

  2198. 		*value = SVG_POINTEREVENTS_VISIBLEFILL;
    2199. 

  2199. 	} else if (!strcmp(value_string, "visibleStroke")) {
    2200. 

  2200. 		*value = SVG_POINTEREVENTS_VISIBLESTROKE;
    2201. 

  2201. 	} else if (!strcmp(value_string, "visible")) {
    2202. 

  2202. 		*value = SVG_POINTEREVENTS_VISIBLE;
    2203. 

  2203. 	} else if (!strcmp(value_string, "painted")) {
    2204. 

  2204. 		*value = SVG_POINTEREVENTS_PAINTED;
    2205. 

  2205. 	} else if (!strcmp(value_string, "fill")) {
    2206. 

  2206. 		*value = SVG_POINTEREVENTS_FILL;
    2207. 

  2207. 	} else if (!strcmp(value_string, "stroke")) {
    2208. 

  2208. 		*value = SVG_POINTEREVENTS_STROKE;
    2209. 

  2209. 	} else if (!strcmp(value_string, "all")) {
    2210. 

  2210. 		*value = SVG_POINTEREVENTS_ALL;
    2211. 

  2211. 	} else if (!strcmp(value_string, "boundingBox")) {
    2212. 

  2212. 		*value = SVG_POINTEREVENTS_BOUNDINGBOX;
    2213. 

  2213. 	} else if (!strcmp(value_string, "none")) {
    2214. 

  2214. 		*value = SVG_POINTEREVENTS_NONE;
    2215. 

  2215. 	}
    2216. 

  2216. }
    2217. 

  2217. 

  2218. static void svg_parse_renderinghint(SVG_RenderingHint *value, char *value_string)
    2219. 

  2219. {
    2220. 

  2220. 	if (!strcmp(value_string, "inherit")) {
    2221. 

  2221. 		*value = SVG_RENDERINGHINT_INHERIT;
    2222. 

  2222. 	} else if (!strcmp(value_string, "auto")) {
    2223. 

  2223. 		*value = SVG_RENDERINGHINT_AUTO;
    2224. 

  2224. 	} else if (!strcmp(value_string, "optimizeQuality")) {
    2225. 

  2225. 		*value = SVG_RENDERINGHINT_OPTIMIZEQUALITY;
    2226. 

  2226. 	} else if (!strcmp(value_string, "optimizeSpeed")) {
    2227. 

  2227. 		*value = SVG_RENDERINGHINT_OPTIMIZESPEED;
    2228. 

  2228. 	} else if (!strcmp(value_string, "optimizeLegibility")) {
    2229. 

  2229. 		*value = SVG_RENDERINGHINT_OPTIMIZELEGIBILITY;
    2230. 

  2230. 	} else if (!strcmp(value_string, "crispEdges")) {
    2231. 

  2231. 		*value = SVG_RENDERINGHINT_CRISPEDGES;
    2232. 

  2232. 	} else if (!strcmp(value_string, "geometricPrecision")) {
    2233. 

  2233. 		*value = SVG_RENDERINGHINT_GEOMETRICPRECISION;
    2234. 

  2234. 	}
    2235. 

  2235. }
    2236. 

  2236. 

  2237. static void svg_parse_vectoreffect(SVG_VectorEffect *value, char *value_string)
    2238. 

  2238. {
    2239. 

  2239. 	if (!strcmp(value_string, "inherit")) {
    2240. 

  2240. 		*value = SVG_VECTOREFFECT_INHERIT;
    2241. 

  2241. 	} else if (!strcmp(value_string, "none")) {
    2242. 

  2242. 		*value = SVG_VECTOREFFECT_NONE;
    2243. 

  2243. 	} else if (!strcmp(value_string, "non-scaling-stroke")) {
    2244. 

  2244. 		*value = SVG_VECTOREFFECT_NONSCALINGSTROKE;
    2245. 

  2245. 	}
    2246. 

  2246. }
    2247. 

  2247. 

  2248. static void svg_parse_playbackorder(SVG_VectorEffect *value, char *value_string)
    2249. 

  2249. {
    2250. 

  2250. 	if (!strcmp(value_string, "forwardOnly")) {
    2251. 

  2251. 		*value = SVG_PLAYBACKORDER_FORWARDONLY;
    2252. 

  2252. 	} else if (!strcmp(value_string, "all")) {
    2253. 

  2253. 		*value = SVG_PLAYBACKORDER_ALL;
    2254. 

  2254. 	}
    2255. 

  2255. }
    2256. 

  2256. 

  2257. static void svg_parse_timelinebegin(SVG_TimelineBegin *value, char *value_string)
    2258. 

  2258. {
    2259. 

  2259. 	if (!strcmp(value_string, "onStart")) {
    2260. 

  2260. 		*value = SVG_TIMELINEBEGIN_ONSTART;
    2261. 

  2261. 	} else if (!strcmp(value_string, "onLoad")) {
    2262. 

  2262. 		*value = SVG_TIMELINEBEGIN_ONLOAD;
    2263. 

  2263. 	}
    2264. 

  2264. }
    2265. 

  2265. 

  2266. static void svg_parse_xmlspace(XML_Space *value, char *value_string)
    2267. 

  2267. {
    2268. 

  2268. 	if (!strcmp(value_string, "default")) {
    2269. 

  2269. 		*value = XML_SPACE_DEFAULT;
    2270. 

  2270. 	} else if (!strcmp(value_string, "preserve")) {
    2271. 

  2271. 		*value = XML_SPACE_PRESERVE;
    2272. 

  2272. 	}
    2273. 

  2273. }
    2274. 

  2274. 

  2275. static void svg_parse_xmlev_propagate(XMLEV_Propagate *value, char *value_string)
    2276. 

  2276. {
    2277. 

  2277. 	if (!strcmp(value_string, "continue")) {
    2278. 

  2278. 		*value = XMLEVENT_PROPAGATE_CONTINUE;
    2279. 

  2279. 	} else if (!strcmp(value_string, "stop")) {
    2280. 

  2280. 		*value = XMLEVENT_PROPAGATE_STOP;
    2281. 

  2281. 	}
    2282. 

  2282. }
    2283. 

  2283. 

  2284. static void svg_parse_xmlev_defaultAction(XMLEV_DefaultAction *value, char *value_string)
    2285. 

  2285. {
    2286. 

  2286. 	if (!strcmp(value_string, "cancel")) {
    2287. 

  2287. 		*value = XMLEVENT_DEFAULTACTION_CANCEL;
    2288. 

  2288. 	} else if (!strcmp(value_string, "perform")) {
    2289. 

  2289. 		*value = XMLEVENT_DEFAULTACTION_PERFORM;
    2290. 

  2290. 	}
    2291. 

  2291. }
    2292. 

  2292. 

  2293. static void svg_parse_xmlev_phase(XMLEV_Phase *value, char *value_string)
    2294. 

  2294. {
    2295. 

  2295. 	if (!strcmp(value_string, "default")) {
    2296. 

  2296. 		*value = XMLEVENT_PHASE_DEFAULT;
    2297. 

  2297. 	} else if (!strcmp(value_string, "capture")) {
    2298. 

  2298. 		*value = XMLEVENT_PHASE_CAPTURE;
    2299. 

  2299. 	}
    2300. 

  2300. }
    2301. 

  2301. 

  2302. static void svg_parse_overflow(SVG_Overflow *value, char *value_string)
    2303. 

  2303. {
    2304. 

  2304. 	if (!strcmp(value_string, "inherit")) {
    2305. 

  2305. 		*value = SVG_OVERFLOW_INHERIT;
    2306. 

  2306. 	} else if (!strcmp(value_string, "visible")) {
    2307. 

  2307. 		*value = SVG_OVERFLOW_VISIBLE;
    2308. 

  2308. 	} else if (!strcmp(value_string, "hidden")) {
    2309. 

  2309. 		*value = SVG_OVERFLOW_HIDDEN;
    2310. 

  2310. 	} else if (!strcmp(value_string, "scroll")) {
    2311. 

  2311. 		*value = SVG_OVERFLOW_SCROLL;
    2312. 

  2312. 	} else if (!strcmp(value_string, "auto")) {
    2313. 

  2313. 		*value = SVG_OVERFLOW_AUTO;
    2314. 

  2314. 	}
    2315. 

  2315. }
    2316. 

  2316. 

  2317. static void svg_parse_textanchor(SVG_TextAnchor *value, char *value_string)
    2318. 

  2318. {
    2319. 

  2319. 	if (!strcmp(value_string, "inherit")) {
    2320. 

  2320. 		*value = SVG_TEXTANCHOR_INHERIT;
    2321. 

  2321. 	} else if (!strcmp(value_string, "start")) {
    2322. 

  2322. 		*value = SVG_TEXTANCHOR_START;
    2323. 

  2323. 	} else if (!strcmp(value_string, "middle")) {
    2324. 

  2324. 		*value = SVG_TEXTANCHOR_MIDDLE;
    2325. 

  2325. 	} else if (!strcmp(value_string, "end")) {
    2326. 

  2326. 		*value = SVG_TEXTANCHOR_END;
    2327. 

  2327. 	}
    2328. 

  2328. }
    2329. 

  2329. 

  2330. static void svg_parse_clipfillrule(SVG_FillRule *value, char *value_string)
    2331. 

  2331. {
    2332. 

  2332. 	if (!strcmp(value_string, "inherit")) {
    2333. 

  2333. 		*value = SVG_FILLRULE_INHERIT;
    2334. 

  2334. 	} else if (!strcmp(value_string, "nonzero")) {
    2335. 

  2335. 		*value = SVG_FILLRULE_NONZERO;
    2336. 

  2336. 	} else if (!strcmp(value_string, "evenodd")) {
    2337. 

  2337. 		*value = SVG_FILLRULE_EVENODD;
    2338. 

  2338. 	}
    2339. 

  2339. }
    2340. 

  2340. 

  2341. static void svg_parse_strokelinejoin(SVG_StrokeLineJoin *value, char *value_string)
    2342. 

  2342. {
    2343. 

  2343. 	if (!strcmp(value_string, "inherit")) {
    2344. 

  2344. 		*value = SVG_STROKELINEJOIN_INHERIT;
    2345. 

  2345. 	} else if (!strcmp(value_string, "miter")) {
    2346. 

  2346. 		*value = SVG_STROKELINEJOIN_MITER;
    2347. 

  2347. 	} else if (!strcmp(value_string, "round")) {
    2348. 

  2348. 		*value = SVG_STROKELINEJOIN_ROUND;
    2349. 

  2349. 	} else if (!strcmp(value_string, "bevel")) {
    2350. 

  2350. 		*value = SVG_STROKELINEJOIN_BEVEL;
    2351. 

  2351. 	}
    2352. 

  2352. }
    2353. 

  2353. 

  2354. static void svg_parse_strokelinecap(SVG_StrokeLineCap *value, char *value_string)
    2355. 

  2355. {
    2356. 

  2356. 	if (!strcmp(value_string, "inherit")) {
    2357. 

  2357. 		*value = SVG_STROKELINECAP_INHERIT;
    2358. 

  2358. 	} else if (!strcmp(value_string, "butt")) {
    2359. 

  2359. 		*value = SVG_STROKELINECAP_BUTT;
    2360. 

  2360. 	} else if (!strcmp(value_string, "round")) {
    2361. 

  2361. 		*value = SVG_STROKELINECAP_ROUND;
    2362. 

  2362. 	} else if (!strcmp(value_string, "square")) {
    2363. 

  2363. 		*value = SVG_STROKELINECAP_SQUARE;
    2364. 

  2364. 	}
    2365. 

  2365. }
    2366. 

  2366. 

  2367. static void svg_parse_fontfamily(SVG_FontFamily *value, char *value_string)
    2368. 

  2368. {
    2369. 

  2369. 	if (!strcmp(value_string, "inherit")) {
    2370. 

  2370. 		value->type = SVG_FONTFAMILY_INHERIT;
    2371. 

  2371. 	} else {
    2372. 

  2372. 		value->type = SVG_FONTFAMILY_VALUE;
    2373. 

  2373. 		value->value = gf_strdup(value_string);
    2374. 

  2374. 	}
    2375. 

  2375. }
    2376. 

  2376. 

  2377. static void svg_parse_fontstyle(SVG_FontStyle *value, char *value_string)
    2378. 

  2378. {
    2379. 

  2379. 	if (!strcmp(value_string, "inherit")) {
    2380. 

  2380. 		*value = SVG_FONTSTYLE_INHERIT;
    2381. 

  2381. 	} else if (!strcmp(value_string, "normal")) {
    2382. 

  2382. 		*value = SVG_FONTSTYLE_NORMAL;
    2383. 

  2383. 	} else if (!strcmp(value_string, "italic")) {
    2384. 

  2384. 		*value = SVG_FONTSTYLE_ITALIC;
    2385. 

  2385. 	} else if (!strcmp(value_string, "oblique")) {
    2386. 

  2386. 		*value = SVG_FONTSTYLE_OBLIQUE;
    2387. 

  2387. 	}
    2388. 

  2388. }
    2389. 

  2389. 

  2390. static void svg_parse_fontweight(SVG_FontWeight *value, char *value_string)
    2391. 

  2391. {
    2392. 

  2392. 	if (!strcmp(value_string, "inherit")) {
    2393. 

  2393. 		*value = SVG_FONTWEIGHT_INHERIT;
    2394. 

  2394. 	} else if (!strcmp(value_string, "normal")) {
    2395. 

  2395. 		*value = SVG_FONTWEIGHT_NORMAL;
    2396. 

  2396. 	} else if (!strcmp(value_string, "bold")) {
    2397. 

  2397. 		*value = SVG_FONTWEIGHT_BOLD;
    2398. 

  2398. 	} else if (!strcmp(value_string, "bolder")) {
    2399. 

  2399. 		*value = SVG_FONTWEIGHT_BOLDER;
    2400. 

  2400. 	} else if (!strcmp(value_string, "lighter")) {
    2401. 

  2401. 		*value = SVG_FONTWEIGHT_LIGHTER;
    2402. 

  2402. 	} else if (!strcmp(value_string, "100")) {
    2403. 

  2403. 		*value = SVG_FONTWEIGHT_100;
    2404. 

  2404. 	} else if (!strcmp(value_string, "200")) {
    2405. 

  2405. 		*value = SVG_FONTWEIGHT_200;
    2406. 

  2406. 	} else if (!strcmp(value_string, "300")) {
    2407. 

  2407. 		*value = SVG_FONTWEIGHT_300;
    2408. 

  2408. 	} else if (!strcmp(value_string, "400")) {
    2409. 

  2409. 		*value = SVG_FONTWEIGHT_400;
    2410. 

  2410. 	} else if (!strcmp(value_string, "500")) {
    2411. 

  2411. 		*value = SVG_FONTWEIGHT_500;
    2412. 

  2412. 	} else if (!strcmp(value_string, "600")) {
    2413. 

  2413. 		*value = SVG_FONTWEIGHT_600;
    2414. 

  2414. 	} else if (!strcmp(value_string, "700")) {
    2415. 

  2415. 		*value = SVG_FONTWEIGHT_700;
    2416. 

  2416. 	} else if (!strcmp(value_string, "800")) {
    2417. 

  2417. 		*value = SVG_FONTWEIGHT_800;
    2418. 

  2418. 	} else if (!strcmp(value_string, "900")) {
    2419. 

  2419. 		*value = SVG_FONTWEIGHT_900;
    2420. 

  2420. 	}
    2421. 

  2421. }
    2422. 

  2422. 

  2423. static void svg_parse_fontvariant(SVG_FontVariant *value, char *value_string)
    2424. 

  2424. {
    2425. 

  2425. 	if (!strcmp(value_string, "inherit")) {
    2426. 

  2426. 		*value = SVG_FONTVARIANT_INHERIT;
    2427. 

  2427. 	} else if (!strcmp(value_string, "normal")) {
    2428. 

  2428. 		*value = SVG_FONTVARIANT_NORMAL;
    2429. 

  2429. 	} else if (!strcmp(value_string, "small-caps")) {
    2430. 

  2430. 		*value = SVG_FONTVARIANT_SMALLCAPS;
    2431. 

  2431. 	}
    2432. 

  2432. }
    2433. 

  2433. 

  2434. static void svg_parse_boolean(SVG_Boolean *value, char *value_string)
    2435. 

  2435. {
    2436. 

  2436. 	/*simple for text editable*/
    2437. 

  2437. 	if (!strcmp(value_string, "1") || !strcmp(value_string, "true") || !strcmp(value_string, "simple"))
    2438. 

  2438. 		*value = 1;
    2439. 

  2439. 	else
    2440. 

  2440. 		*value = 0;
    2441. 

  2441. }
    2442. 

  2442. 

  2443. 

  2444. static void smil_parse_time_list(GF_Node *e, GF_List *values, char *begin_or_end_list)
    2445. 

  2445. {
    2446. 

  2446. 	SMIL_Time *value;
    2447. 

  2447. 	char value_string[500];
    2448. 

  2448. 	char *str = begin_or_end_list, *tmp;
    2449. 

  2449. 	u32 len;
    2450. 

  2450. 

  2451. 	/* get rid of leading spaces */
    2452. 

  2452. 	while (*str == ' ') str++;
    2453. 

  2453. 

  2454. 	while (1) {
    2455. 

  2455. 		tmp = strchr(str, ';');
    2456. 

  2456. 		if (tmp) len = (u32) (tmp-str);
    2457. 

  2457. 		else len = (u32) strlen(str);
    2458. 

  2458. 		memcpy(value_string, str, len);
    2459. 

  2459. 		while (value_string[len - 1] == ' ' && len > 0) len--;
    2460. 

  2460. 		value_string[len] = 0;
    2461. 

  2461. 

  2462. 		GF_SAFEALLOC(value, SMIL_Time)
    2463. 

  2463.  		gf_list_add(values, value);
    2464. 

  2464. 

  2465. 		if (smil_parse_time(e, value, value_string) != GF_OK) goto err;
    2466. 

  2466. 

  2467. 		if (!tmp) break;
    2468. 

  2468. 

  2469. 		str = tmp + 1;
    2470. 

  2470. 		while (*str == ' ') str++;
    2471. 

  2471. 	}
    2472. 

  2472. 

  2473. 	/* sorting timing values */
    2474. 

  2474. 	if (gf_list_count(values) > 1) {
    2475. 

  2475. 		SMIL_Time *v, *sv;
    2476. 

  2476. 		GF_List *sorted = gf_list_new();
    2477. 

  2477. 		u32 i, count;
    2478. 

  2478. 		u8 added = 0;
    2479. 

  2479. 		do {
    2480. 

  2480. 			v = (SMIL_Time*)gf_list_get(values, 0);
    2481. 

  2481. 			gf_list_rem(values, 0);
    2482. 

  2482. 			added = 0;
    2483. 

  2483. 			count = gf_list_count(sorted);
    2484. 

  2484. 			for (i=0; i<count; i++) {
    2485. 

  2485. 				sv = (SMIL_Time*)gf_list_get(sorted, i);
    2486. 

  2486. 				if (v->type >= GF_SMIL_TIME_EVENT) {
    2487. 

  2487. 					/* unresolved or indefinite so add at the end of the sorted list */
    2488. 

  2488. 					gf_list_add(sorted, v);
    2489. 

  2489. 					added = 1;
    2490. 

  2490. 					break;
    2491. 

  2491. 				} else {
    2492. 

  2492. 					if (sv->type >= GF_SMIL_TIME_EVENT) {
    2493. 

  2493. 						gf_list_insert(sorted, v, i);
    2494. 

  2494. 						added = 1;
    2495. 

  2495. 						break;
    2496. 

  2496. 					} else {
    2497. 

  2497. 						if (v->clock <= sv->clock) {
    2498. 

  2498. 							gf_list_insert(sorted, v, i);
    2499. 

  2499. 							added = 1;
    2500. 

  2500. 							break;
    2501. 

  2501. 						}
    2502. 

  2502. 					}
    2503. 

  2503. 				}
    2504. 

  2504. 			}
    2505. 

  2505. 			if (!added) gf_list_add(sorted, v);
    2506. 

  2506. 		} while (gf_list_count(values) > 0);
    2507. 

  2507. 

  2508. 		count = gf_list_count(sorted);
    2509. 

  2509. 		for (i = 0; i < count; i++) {
    2510. 

  2510. 			gf_list_add(values, gf_list_get(sorted, i));
    2511. 

  2511. 		}
    2512. 

  2512. 		gf_list_del(sorted);
    2513. 

  2513. 	}
    2514. 

  2514. 	return;
    2515. 

  2515. 

  2516. err:
    2517. 

  2517. 	/* See SVG spec:
    2518. 

  2518. 	"If the 'begin' attribute is
    2519. 

  2519. 	syntactically invalid, in the list itself or in any of the individual
    2520. 

  2520. 	list values, it is equivalent to a single 'begin' value of 'indefinite'."*/
    2521. 

  2521. 	len = gf_list_count(values);
    2522. 

  2522. 	while (len) {
    2523. 

  2523. 		SMIL_Time *v = (SMIL_Time*)gf_list_get(values, 0);
    2524. 

  2524. 		if (v->element_id) gf_free(v->element_id);
    2525. 

  2525. 		gf_list_rem(values, 0);
    2526. 

  2526. 		gf_free(v);
    2527. 

  2527. 		len--;
    2528. 

  2528. 	}
    2529. 

  2529. 

  2530. 	GF_SAFEALLOC(value, SMIL_Time)
    2531. 

  2531. 	gf_list_add(values, value);
    2532. 

  2532. 

  2533. 	switch (e->sgprivate->tag) {
    2534. 

  2534. 	case TAG_SVG_discard:
    2535. 

  2535. 		value->type = GF_SMIL_TIME_CLOCK;
    2536. 

  2536. 		value->clock = 0;
    2537. 

  2537. 		break;
    2538. 

  2538. 	default:
    2539. 

  2539. 		value->type = GF_SMIL_TIME_INDEFINITE;
    2540. 

  2540. 		break;
    2541. 

  2541. 	}
    2542. 

  2542. 	return;
    2543. 

  2543. }
    2544. 

  2544. 

  2545. static void smil_parse_attributeType(SMIL_AttributeType *value, char *value_string)
    2546. 

  2546. {
    2547. 

  2547. 	if (!strcmp(value_string, "auto")) {
    2548. 

  2548. 		*value = SMIL_ATTRIBUTETYPE_AUTO;
    2549. 

  2549. 	} else if (!strcmp(value_string, "XML")) {
    2550. 

  2550. 		*value = SMIL_ATTRIBUTETYPE_XML;
    2551. 

  2551. 	} else if (!strcmp(value_string, "CSS")) {
    2552. 

  2552. 		*value = SMIL_ATTRIBUTETYPE_CSS;
    2553. 

  2553. 	}
    2554. 

  2554. }
    2555. 

  2555. 

  2556. static void smil_parse_min_max_dur_repeatdur(SMIL_Duration *value, char *value_string)
    2557. 

  2557. {
    2558. 

  2558. 	if (!strcmp(value_string, "indefinite")) {
    2559. 

  2559. 		value->type = SMIL_DURATION_INDEFINITE;
    2560. 

  2560. 	} else if (!strcmp(value_string, "media")) {
    2561. 

  2561. 		value->type = SMIL_DURATION_MEDIA;
    2562. 

  2562. 	} else {
    2563. 

  2563. 		Double ftime;
    2564. 

  2564. 		if ((svg_parse_clock_value(value_string, &ftime) == GF_OK) && (ftime >= 0)) {
    2565. 

  2565. 			value->clock_value = ftime;
    2566. 

  2566. 			value->type = SMIL_DURATION_DEFINED;
    2567. 

  2567. 		} else {
    2568. 

  2568. 			/* WARNING: Should this attribute in error be removed ? */
    2569. 

  2569. 			value->type = SMIL_DURATION_INDEFINITE;
    2570. 

  2570. 		}
    2571. 

  2571. 	}
    2572. 

  2572. }
    2573. 

  2573. 

  2574. static void smil_parse_repeatcount(SMIL_RepeatCount *value, char *value_string)
    2575. 

  2575. {
    2576. 

  2576. 	if (!strcmp(value_string, "indefinite")) {
    2577. 

  2577. 		value->type = SMIL_REPEATCOUNT_INDEFINITE;
    2578. 

  2578. 	} else {
    2579. 

  2579. 		Float _val;
    2580. 

  2580. 		sscanf(value_string, "%f", &_val);
    2581. 

  2581. 		value->type = SMIL_REPEATCOUNT_DEFINED;
    2582. 

  2582. 		value->count = FLT2FIX(_val);
    2583. 

  2583. 	}
    2584. 

  2584. }
    2585. 

  2585. 

  2586. static void smil_parse_fill(SMIL_Fill *value, char *value_string)
    2587. 

  2587. {
    2588. 

  2588. 	if (!strcmp(value_string, "freeze")) {
    2589. 

  2589. 		*value = SMIL_FILL_FREEZE;
    2590. 

  2590. 	} else if (!strcmp(value_string, "remove")) {
    2591. 

  2591. 		*value = SMIL_FILL_REMOVE;
    2592. 

  2592. 	}
    2593. 

  2593. }
    2594. 

  2594. 

  2595. static void smil_parse_restart(SMIL_Restart *value, char *value_string)
    2596. 

  2596. {
    2597. 

  2597. 	if (!strcmp(value_string, "always")) {
    2598. 

  2598. 		*value = SMIL_RESTART_ALWAYS;
    2599. 

  2599. 	} else if (!strcmp(value_string, "whenNotActive")) {
    2600. 

  2600. 		*value = SMIL_RESTART_WHENNOTACTIVE;
    2601. 

  2601. 	} else if (!strcmp(value_string, "never")) {
    2602. 

  2602. 		*value = SMIL_RESTART_NEVER;
    2603. 

  2603. 	}
    2604. 

  2604. }
    2605. 

  2605. 

  2606. static void smil_parse_calcmode(SMIL_CalcMode *value, char *value_string)
    2607. 

  2607. {
    2608. 

  2608. 	if (!strcmp(value_string, "discrete")) {
    2609. 

  2609. 		*value = SMIL_CALCMODE_DISCRETE;
    2610. 

  2610. 	} else if (!strcmp(value_string, "linear")) {
    2611. 

  2611. 		*value = SMIL_CALCMODE_LINEAR;
    2612. 

  2612. 	} else if (!strcmp(value_string, "paced")) {
    2613. 

  2613. 		*value = SMIL_CALCMODE_PACED;
    2614. 

  2614. 	} else if (!strcmp(value_string, "spline")) {
    2615. 

  2615. 		*value = SMIL_CALCMODE_SPLINE;
    2616. 

  2616. 	}
    2617. 

  2617. }
    2618. 

  2618. 

  2619. static void smil_parse_additive(SMIL_Additive *value, char *value_string)
    2620. 

  2620. {
    2621. 

  2621. 	if (!strcmp(value_string, "replace")) {
    2622. 

  2622. 		*value = SMIL_ADDITIVE_REPLACE;
    2623. 

  2623. 	} else if (!strcmp(value_string, "sum")) {
    2624. 

  2624. 		*value = SMIL_ADDITIVE_SUM;
    2625. 

  2625. 	}
    2626. 

  2626. }
    2627. 

  2627. 

  2628. static void smil_parse_accumulate(SMIL_Accumulate *value, char *value_string)
    2629. 

  2629. {
    2630. 

  2630. 	if (!strcmp(value_string, "none")) {
    2631. 

  2631. 		*value = SMIL_ACCUMULATE_NONE;
    2632. 

  2632. 	} else if (!strcmp(value_string, "sum")) {
    2633. 

  2633. 		*value = SMIL_ACCUMULATE_SUM;
    2634. 

  2634. 	}
    2635. 

  2635. }
    2636. 

  2636. 

  2637. static void smil_parse_syncBehaviorOrDefault(SMIL_SyncBehavior *value, char *value_string)
    2638. 

  2638. {
    2639. 

  2639. 	if (!strcmp(value_string, "inherit")) {
    2640. 

  2640. 		*value = SMIL_SYNCBEHAVIOR_INHERIT;
    2641. 

  2641. 	} else if (!strcmp(value_string, "default")) {
    2642. 

  2642. 		*value = SMIL_SYNCBEHAVIOR_DEFAULT;
    2643. 

  2643. 	} else if (!strcmp(value_string, "locked")) {
    2644. 

  2644. 		*value = SMIL_SYNCBEHAVIOR_LOCKED;
    2645. 

  2645. 	} else if (!strcmp(value_string, "canSlip")) {
    2646. 

  2646. 		*value = SMIL_SYNCBEHAVIOR_CANSLIP;
    2647. 

  2647. 	} else if (!strcmp(value_string, "independent")) {
    2648. 

  2648. 		*value = SMIL_SYNCBEHAVIOR_INDEPENDENT;
    2649. 

  2649. 	}
    2650. 

  2650. }
    2651. 

  2651. 

  2652. static void smil_parse_syncToleranceOrDefault(SMIL_SyncTolerance *value, char *value_string)
    2653. 

  2653. {
    2654. 

  2654. 	if (!strcmp(value_string, "inherit")) {
    2655. 

  2655. 		value->type = SMIL_SYNCTOLERANCE_INHERIT;
    2656. 

  2656. 	} else if (!strcmp(value_string, "default")) {
    2657. 

  2657. 		value->type = SMIL_SYNCTOLERANCE_DEFAULT;
    2658. 

  2658. 	} else {
    2659. 

  2659. 		value->type = SMIL_SYNCBEHAVIOR_LOCKED;
    2660. 

  2660. 		svg_parse_clock_value(value_string, &(value->value));
    2661. 

  2661. 	}
    2662. 

  2662. }
    2663. 

  2663. 

  2664. static void svg_parse_viewbox(SVG_ViewBox *value, char *value_string)
    2665. 

  2665. {
    2666. 

  2666.     u32 read_chars;
    2667. 

  2667. 	char *str = value_string;
    2668. 

  2668. 	if (!strcmp(str, "none")) {
    2669. 

  2669. 		value->is_set = 0;
    2670. 

  2670. 	} else {
    2671. 

  2671. 		u32 i = 0;
    2672. 

  2672. 		value->is_set = 1;
    2673. 

  2673. 		read_chars = svg_parse_number(&(str[i]), &(value->x), 0);
    2674. 

  2674.         if (!read_chars) return;
    2675. 

  2675.         i += read_chars;
    2676. 

  2676. 		read_chars = svg_parse_number(&(str[i]), &(value->y), 0);
    2677. 

  2677.         if (!read_chars) return;
    2678. 

  2678.         i += read_chars;
    2679. 

  2679. 		read_chars = svg_parse_number(&(str[i]), &(value->width), 0);
    2680. 

  2680.         if (!read_chars) return;
    2681. 

  2681.         i += read_chars;
    2682. 

  2682. 		read_chars = svg_parse_number(&(str[i]), &(value->height), 0);
    2683. 

  2683.         if (!read_chars) return;
    2684. 

  2684.         i += read_chars;
    2685. 

  2685. 	}
    2686. 

  2686. }
    2687. 

  2687. 

  2688. /* Parses a list of coordinates or a list of lengths (in SVG, length and coordinate is the same type )*/
    2689. 

  2689. static void svg_parse_coordinates(GF_List *values, char *value_string)
    2690. 

  2690. {
    2691. 

  2691. 	SVG_Coordinate *c;
    2692. 

  2692. 	u32 i = 0;
    2693. 

  2693. 	char *str = value_string;
    2694. 

  2694. 	u32 len = (u32) strlen(str);
    2695. 

  2695. 

  2696. 	while (gf_list_count(values)) {
    2697. 

  2697. 		c = (SVG_Coordinate*)gf_list_get(values, 0);
    2698. 

  2698. 		gf_list_rem(values, 0);
    2699. 

  2699. 		gf_free(c);
    2700. 

  2700. 	}
    2701. 

  2701. 	while (i < len) {
    2702. 

  2702. 		u32 sub;
    2703. 

  2703. 		GF_SAFEALLOC(c, SVG_Coordinate)
    2704. 

  2704. 		sub = svg_parse_length(c, &(str[i]), 0);
    2705. 

  2705. 		if (!sub) {
    2706. 

  2706. 			gf_free(c);
    2707. 

  2707. 			return;
    2708. 

  2708. 		}
    2709. 

  2709. 		i+=sub;
    2710. 

  2710. 		gf_list_add(values, c);
    2711. 

  2711. 	}
    2712. 

  2712. }
    2713. 

  2713. 

  2714. /* Parse a point as a pair of number without units */
    2715. 

  2715. u32 svg_parse_point(SVG_Point *p, char *value_string)
    2716. 

  2716. {
    2717. 

  2717. 	u32 i = 0, j = 0;
    2718. 

  2718. 	i = svg_parse_number(&(value_string[i]), &(p->x), 0);
    2719. 

  2719.     /* TODO: handle cases where a point has an invalid syntax */
    2720. 

  2720. 	j = svg_parse_number(&(value_string[i]), &(p->y), 0);
    2721. 

  2721. 	/* we need to detect an odd number of coordinates in polygon points list
    2722. 

  2722. 	   cf. http://www.w3.org/TR/SVGMobile12/shapes.html#PolygonElement
    2723. 

  2723. 	   see svg_parse_points */
    2724. 

  2724. 	if (j == 0) return 0;
    2725. 

  2725. 	else return i+j;
    2726. 

  2726. }
    2727. 

  2727. 

  2728. static u32 svg_parse_point_into_matrix(GF_Matrix2D *p, char *value_string)
    2729. 

  2729. {
    2730. 

  2730. 	u32 i = 0, j = 0;
    2731. 

  2731. 	gf_mx2d_init(*p);
    2732. 

  2732. 	i = svg_parse_number(&(value_string[i]), &(p->m[2]), 0);
    2733. 

  2733.     if (i == 0) return 0;
    2734. 

  2734. 	j = svg_parse_number(&(value_string[i]), &(p->m[5]), 0);
    2735. 

  2735.     if (j == 0) return 0;
    2736. 

  2736. 	return i+j;
    2737. 

  2737. }
    2738. 

  2738. 

  2739. /* Parses the points attribute of a polygon or polyline element */
    2740. 

  2740. static void svg_parse_points(GF_List *values, char *value_string)
    2741. 

  2741. {
    2742. 

  2742. 	u32 i = 0, j;
    2743. 

  2743. 	char *str = value_string;
    2744. 

  2744. 	u32 len = (u32) strlen(str);
    2745. 

  2745. 	while (i < len) {
    2746. 

  2746. 		SVG_Point *p;
    2747. 

  2747. 		GF_SAFEALLOC(p, SVG_Point)
    2748. 

  2748. 		j = svg_parse_point(p, &str[i]);
    2749. 

  2749. 		if (j == 0) {
    2750. 

  2750. 			/* cf. http://www.w3.org/TR/SVGMobile12/shapes.html#PolygonElement
    2751. 

  2751. 			   If an odd number of coordinates is provided, then the element
    2752. 

  2752. 			   is treated as if the attribute had not been specified.*/
    2753. 

  2753. 			while (gf_list_count(values)) {
    2754. 

  2754. 				p = (SVG_Point *)gf_list_get(values, 0);
    2755. 

  2755. 				gf_free(p);
    2756. 

  2756. 				gf_list_rem(values, 0);
    2757. 

  2757. 			}
    2758. 

  2758. 			return;
    2759. 

  2759. 		}
    2760. 

  2760. 		i += j;
    2761. 

  2761. 		gf_list_add(values, p);
    2762. 

  2762. 	}
    2763. 

  2763. }
    2764. 

  2764. 

  2765. /* Parses a list of numbers */
    2766. 

  2766. static void svg_parse_numbers(GF_List *values, char *value_string, Bool is_angle)
    2767. 

  2767. {
    2768. 

  2768.     u32 read_chars;
    2769. 

  2769. 	u32 i = 0;
    2770. 

  2770. 	char *str = value_string;
    2771. 

  2771. 	u32 len = (u32) strlen(str);
    2772. 

  2772. 	while (i < len) {
    2773. 

  2773. 		Fixed *f;
    2774. 

  2774. 		GF_SAFEALLOC(f, Fixed)
    2775. 

  2775. 		read_chars = svg_parse_number(&(str[i]), f, is_angle);
    2776. 

  2776. 		if (!read_chars) {
    2777. 

  2777. 			gf_free(f);
    2778. 

  2778. 			return;
    2779. 

  2779. 		}
    2780. 

  2780.         i += read_chars;
    2781. 

  2781. 		gf_list_add(values, f);
    2782. 

  2782. 	}
    2783. 

  2783. }
    2784. 

  2784. 

  2785. static void svg_string_list_add(GF_List *values, char *string, u32 string_type)
    2786. 

  2786. {
    2787. 

  2787. 	XMLRI *iri;
    2788. 

  2788. 	switch (string_type) {
    2789. 

  2789. 	case 1:
    2790. 

  2790. 		iri = (XMLRI*)gf_malloc(sizeof(XMLRI));
    2791. 

  2791. 		iri->type = XMLRI_STRING;
    2792. 

  2792. 		iri->string = gf_strdup(string);
    2793. 

  2793. 		gf_list_add(values, iri);
    2794. 

  2794. 		break;
    2795. 

  2795. 	default:
    2796. 

  2796. 		gf_list_add(values, gf_strdup(string));
    2797. 

  2797. 		break;
    2798. 

  2798. 	}
    2799. 

  2799. }
    2800. 

  2800. 

  2801. static void svg_parse_strings(GF_List *values, char *value_string, u32 string_type)
    2802. 

  2802. {
    2803. 

  2803. 	char *next, *sep = value_string;
    2804. 

  2804. 

  2805. 	while (gf_list_count(values)) {
    2806. 

  2806. 		next = (char*)gf_list_last(values);
    2807. 

  2807. 		gf_list_rem_last(values);
    2808. 

  2808. 		gf_free(next);
    2809. 

  2809. 	}
    2810. 

  2810. 

  2811. 	while (1) {
    2812. 

  2812. 		while (sep && sep[0]==' ') sep++;
    2813. 

  2813. 		if (!sep) break;
    2814. 

  2814. 		next = sep+1;
    2815. 

  2815. 		while (next[0]) {
    2816. 

  2816. 			if (strchr(" ;,", next[0])) break;
    2817. 

  2817. 			next++;
    2818. 

  2818. 		}
    2819. 

  2819. 		if (!next[0]) {
    2820. 

  2820. 			svg_string_list_add(values, sep, string_type);
    2821. 

  2821. 			break;
    2822. 

  2822. 		}
    2823. 

  2823. 		next[0]=0;
    2824. 

  2824. 		svg_string_list_add(values, sep, string_type);
    2825. 

  2825. 		next[0]=';';
    2826. 

  2826. 		sep = next+1;
    2827. 

  2827. 		while (strchr(" ,;", sep[0])) sep++;
    2828. 

  2828. 	}
    2829. 

  2829. }
    2830. 

  2830. 

  2831. static void svg_parse_strokedasharray(SVG_StrokeDashArray *value, char *value_string)
    2832. 

  2832. {
    2833. 

  2833.     u32 read_chars;
    2834. 

  2834. 	if (!strcmp(value_string, "none")) {
    2835. 

  2835. 		value->type = SVG_STROKEDASHARRAY_NONE;
    2836. 

  2836. 	} else if (!strcmp(value_string, "inherit")) {
    2837. 

  2837. 		value->type = SVG_STROKEDASHARRAY_INHERIT;
    2838. 

  2838. 	} else {
    2839. 

  2839. 		UnitArray *vals = &(value->array);
    2840. 

  2840. 		GF_List *values = gf_list_new();
    2841. 

  2841. 		u32 i = 0;
    2842. 

  2842. 		u32 len = (u32) strlen(value_string);
    2843. 

  2843. 		char *str = value_string;
    2844. 

  2844. 		while (i < len) {
    2845. 

  2845. 			SVG_Length *f;
    2846. 

  2846. 			GF_SAFEALLOC(f, SVG_Length)
    2847. 

  2847. 			read_chars = svg_parse_length(f, &(str[i]), 0);
    2848. 

  2848.             if (!read_chars) {
    2849. 

  2849.                 gf_free(f);
    2850. 

  2850.                 return;
    2851. 

  2851.             }
    2852. 

  2852.             i += read_chars;
    2853. 

  2853. 			gf_list_add(values, f);
    2854. 

  2854. 		}
    2855. 

  2855. 		vals->count = gf_list_count(values);
    2856. 

  2856. 		vals->units = (u8 *) gf_malloc(sizeof(u8)*vals->count);
    2857. 

  2857. 		vals->vals = (Fixed *) gf_malloc(sizeof(Fixed)*vals->count);
    2858. 

  2858. 		for (i = 0; i < vals->count; i++) {
    2859. 

  2859. 			SVG_Length *f = (SVG_Length *)gf_list_get(values, i);
    2860. 

  2860. 			vals->vals[i] = f->value;
    2861. 

  2861.             vals->units[i] = f->type;
    2862. 

  2862. 			gf_free(f);
    2863. 

  2863. 		}
    2864. 

  2864. 		gf_list_del(values);
    2865. 

  2865. 		value->type = SVG_STROKEDASHARRAY_ARRAY;
    2866. 

  2866. 	}
    2867. 

  2867. }
    2868. 

  2868. 

  2869. static void svg_parse_zoomandpan(SVG_ZoomAndPan *value, char *value_string)
    2870. 

  2870. {
    2871. 

  2871. 	if (!strcmp(value_string, "disable")) {
    2872. 

  2872. 		*value = SVG_ZOOMANDPAN_DISABLE;
    2873. 

  2873. 	} else if (!strcmp(value_string, "magnify")) {
    2874. 

  2874. 		*value = SVG_ZOOMANDPAN_MAGNIFY;
    2875. 

  2875. 	}
    2876. 

  2876. }
    2877. 

  2877. 

  2878. static void svg_parse_preserveaspectratio(SVG_PreserveAspectRatio *par, char *attribute_content)
    2879. 

  2879. {
    2880. 

  2880. 	char *content = attribute_content;
    2881. 

  2881. 	while (*content == ' ') content++;
    2882. 

  2882. 	if (strstr(content, "defer")) {
    2883. 

  2883. 		par->defer = 1;
    2884. 

  2884. 		content += 4;
    2885. 

  2885. 	} else {
    2886. 

  2886. 		content = attribute_content;
    2887. 

  2887. 	}
    2888. 

  2888. 	while (*content == ' ') content++;
    2889. 

  2889. 	if (strstr(content, "none")) {
    2890. 

  2890. 		par->align = SVG_PRESERVEASPECTRATIO_NONE;
    2891. 

  2891. 		content+=4;
    2892. 

  2892. 	} else if (strstr(content, "xMinYMin")) {
    2893. 

  2893. 		par->align = SVG_PRESERVEASPECTRATIO_XMINYMIN;
    2894. 

  2894. 		content+=8;
    2895. 

  2895. 	} else if (strstr(content, "xMidYMin")) {
    2896. 

  2896. 		par->align = SVG_PRESERVEASPECTRATIO_XMIDYMIN;
    2897. 

  2897. 		content+=8;
    2898. 

  2898. 	} else if (strstr(content, "xMaxYMin")) {
    2899. 

  2899. 		par->align = SVG_PRESERVEASPECTRATIO_XMAXYMIN;
    2900. 

  2900. 		content+=8;
    2901. 

  2901. 	} else if (strstr(content, "xMinYMid")) {
    2902. 

  2902. 		par->align = SVG_PRESERVEASPECTRATIO_XMINYMID;
    2903. 

  2903. 		content+=8;
    2904. 

  2904. 	} else if (strstr(content, "xMidYMid")) {
    2905. 

  2905. 		par->align = SVG_PRESERVEASPECTRATIO_XMIDYMID;
    2906. 

  2906. 		content+=8;
    2907. 

  2907. 	} else if (strstr(content, "xMaxYMid")) {
    2908. 

  2908. 		par->align = SVG_PRESERVEASPECTRATIO_XMAXYMID;
    2909. 

  2909. 		content+=8;
    2910. 

  2910. 	} else if (strstr(content, "xMinYMax")) {
    2911. 

  2911. 		par->align = SVG_PRESERVEASPECTRATIO_XMINYMAX;
    2912. 

  2912. 		content+=8;
    2913. 

  2913. 	} else if (strstr(content, "xMidYMax")) {
    2914. 

  2914. 		par->align = SVG_PRESERVEASPECTRATIO_XMIDYMAX;
    2915. 

  2915. 		content+=8;
    2916. 

  2916. 	} else if (strstr(content, "xMaxYMax")) {
    2917. 

  2917. 		par->align = SVG_PRESERVEASPECTRATIO_XMAXYMAX;
    2918. 

  2918. 		content+=8;
    2919. 

  2919. 	}
    2920. 

  2920. 	while (*content == ' ') content++;
    2921. 

  2921. 	if (*content == 0) return;
    2922. 

  2922. 	if (strstr(content, "meet")) {
    2923. 

  2923. 		par->meetOrSlice = SVG_MEETORSLICE_MEET;
    2924. 

  2924. 	} else if (strstr(content, "slice")) {
    2925. 

  2925. 		par->meetOrSlice = SVG_MEETORSLICE_SLICE;
    2926. 

  2926. 	}
    2927. 

  2927. }
    2928. 

  2928. 

  2929. static void svg_parse_animatetransform_type(SVG_TransformType *anim_transform_type, char *attribute_content)
    2930. 

  2930. {
    2931. 

  2931. 	*anim_transform_type = SVG_TRANSFORM_MATRIX;
    2932. 

  2932. 	if (!strcmp(attribute_content, "scale")) {
    2933. 

  2933. 		*anim_transform_type = SVG_TRANSFORM_SCALE;
    2934. 

  2934. 	} else if (!strcmp(attribute_content, "rotate")) {
    2935. 

  2935. 		*anim_transform_type = SVG_TRANSFORM_ROTATE;
    2936. 

  2936. 	} else if (!strcmp(attribute_content, "translate")) {
    2937. 

  2937. 		*anim_transform_type = SVG_TRANSFORM_TRANSLATE;
    2938. 

  2938. 	} else if (!strcmp(attribute_content, "skewX")) {
    2939. 

  2939. 		*anim_transform_type = SVG_TRANSFORM_SKEWX;
    2940. 

  2940. 	} else if (!strcmp(attribute_content, "skewY")) {
    2941. 

  2941. 		*anim_transform_type = SVG_TRANSFORM_SKEWY;
    2942. 

  2942. 	}
    2943. 

  2943. }
    2944. 

  2944. 

  2945. static void svg_parse_focushighlight(SVG_FocusHighlight *fh, char *attribute_content)
    2946. 

  2946. {
    2947. 

  2947. 	if (!strcmp(attribute_content, "auto")) {
    2948. 

  2948. 		*fh = SVG_FOCUSHIGHLIGHT_AUTO;
    2949. 

  2949. 	} else if (!strcmp(attribute_content, "none")) {
    2950. 

  2950. 		*fh = SVG_FOCUSHIGHLIGHT_NONE;
    2951. 

  2951. 	}
    2952. 

  2952. }
    2953. 

  2953. 

  2954. static void svg_parse_focusable(SVG_Focusable *f, char *attribute_content)
    2955. 

  2955. {
    2956. 

  2956. 	if (!strcmp(attribute_content, "true")) {
    2957. 

  2957. 		*f = SVG_FOCUSABLE_TRUE;
    2958. 

  2958. 	} else if (!strcmp(attribute_content, "false")) {
    2959. 

  2959. 		*f = SVG_FOCUSABLE_FALSE;
    2960. 

  2960. 	} else {
    2961. 

  2961. 		*f = SVG_FOCUSABLE_AUTO;
    2962. 

  2962. 	}
    2963. 

  2963. }
    2964. 

  2964. 

  2965. static void svg_parse_initialvisibility(SVG_InitialVisibility *iv, char *attribute_content)
    2966. 

  2966. {
    2967. 

  2967. 	if (!strcmp(attribute_content, "whenStarted")) {
    2968. 

  2968. 		*iv = SVG_INITIALVISIBILTY_WHENSTARTED;
    2969. 

  2969. 	} else if (!strcmp(attribute_content, "always")) {
    2970. 

  2970. 		*iv = SVG_INITIALVISIBILTY_ALWAYS;
    2971. 

  2971. 	}
    2972. 

  2972. }
    2973. 

  2973. 

  2974. static void svg_parse_overlay(SVG_Overlay *o, char *attribute_content)
    2975. 

  2975. {
    2976. 

  2976. 	if (!strcmp(attribute_content, "none")) {
    2977. 

  2977. 		*o = SVG_OVERLAY_NONE;
    2978. 

  2978. 	} else if (!strcmp(attribute_content, "top")) {
    2979. 

  2979. 		*o = SVG_OVERLAY_TOP;
    2980. 

  2980. 	}
    2981. 

  2981. }
    2982. 

  2982. 

  2983. static void svg_parse_transformbehavior(SVG_TransformBehavior *tb, char *attribute_content)
    2984. 

  2984. {
    2985. 

  2985. 	if (!strcmp(attribute_content, "geometric")) {
    2986. 

  2986. 		*tb = SVG_TRANSFORMBEHAVIOR_GEOMETRIC;
    2987. 

  2987. 	} else if (!strcmp(attribute_content, "pinned")) {
    2988. 

  2988. 		*tb = SVG_TRANSFORMBEHAVIOR_PINNED;
    2989. 

  2989. 	} else if (!strcmp(attribute_content, "pinned90")) {
    2990. 

  2990. 		*tb = SVG_TRANSFORMBEHAVIOR_PINNED90;
    2991. 

  2991. 	} else if (!strcmp(attribute_content, "pinned180")) {
    2992. 

  2992. 		*tb = SVG_TRANSFORMBEHAVIOR_PINNED180;
    2993. 

  2993. 	} else if (!strcmp(attribute_content, "pinned270")) {
    2994. 

  2994. 		*tb = SVG_TRANSFORMBEHAVIOR_PINNED270;
    2995. 

  2995. 	}
    2996. 

  2996. }
    2997. 

  2997. 

  2998. static void svg_parse_focus(GF_Node *e,  SVG_Focus *o, char *attribute_content)
    2999. 

  2999. {
    3000. 

  3000. 	if (o->target.string) gf_free(o->target.string);
    3001. 

  3001. 	o->target.string = NULL;
    3002. 

  3002. 	o->target.target = NULL;
    3003. 

  3003. 

  3004. 	if (!strcmp(attribute_content, "self")) o->type = SVG_FOCUS_SELF;
    3005. 

  3005. 	else if (!strcmp(attribute_content, "auto")) o->type = SVG_FOCUS_AUTO;
    3006. 

  3006. 	else if (!strnicmp(attribute_content, "url(", 4)) {
    3007. 

  3007. 		char *sep = strrchr(attribute_content, ')');
    3008. 

  3008. 		if (sep) sep[0] = 0;
    3009. 

  3009. 		o->type = SVG_FOCUS_IRI;
    3010. 

  3010. 		svg_parse_iri(e, &o->target, attribute_content+4);
    3011. 

  3011. 		if (sep) sep[0] = ')';
    3012. 

  3012. 	}
    3013. 

  3013. }
    3014. 

  3014. 

  3015. /* end of Basic SVG datatype parsing functions */
    3016. 

  3016. 

  3017. void svg_parse_one_anim_value(GF_Node *n, SMIL_AnimateValue *anim_value, char *attribute_content, u8 anim_value_type)
    3018. 

  3018. {
    3019. 

  3019. 	GF_FieldInfo info;
    3020. 

  3020. 	info.fieldType = anim_value_type;
    3021. 

  3021. 	info.far_ptr = gf_svg_create_attribute_value(anim_value_type);
    3022. 

  3022. 	if (info.far_ptr) gf_svg_parse_attribute(n, &info, attribute_content, 0);
    3023. 

  3023. 

  3024. 	anim_value->value = info.far_ptr;
    3025. 

  3025. 	anim_value->type = anim_value_type;
    3026. 

  3026. }
    3027. 

  3027. 

  3028. void svg_parse_anim_values(GF_Node *n, SMIL_AnimateValues *anim_values, char *anim_values_string, u8 anim_value_type)
    3029. 

  3029. {
    3030. 

  3030. 	u32 i = 0;
    3031. 

  3031. 	char *str;
    3032. 

  3032. 	s32 psemi = -1;
    3033. 

  3033. 	GF_FieldInfo info;
    3034. 

  3034. 	info.fieldType = anim_value_type;
    3035. 

  3035. 	anim_values->type = anim_value_type;
    3036. 

  3036. 

  3037. 	str = anim_values_string;
    3038. 

  3038. 	while (1) {
    3039. 

  3039. 		if (str[i] == ';' || str[i] == 0) {
    3040. 

  3040. 			u32 single_value_len = 0;
    3041. 

  3041. 			char c;
    3042. 

  3042. 			single_value_len = i - (psemi+1);
    3043. 

  3043. 			c = str [ (psemi+1) + single_value_len];
    3044. 

  3044. 			str [ (psemi+1) + single_value_len] = 0;
    3045. 

  3045. 			info.far_ptr = gf_svg_create_attribute_value(anim_value_type);
    3046. 

  3046. 			if (info.far_ptr) {
    3047. 

  3047. 				gf_svg_parse_attribute(n, &info, str + (psemi+1), anim_value_type);
    3048. 

  3048. 				gf_list_add(anim_values->values, info.far_ptr);
    3049. 

  3049. 			}
    3050. 

  3050. 			str [ (psemi+1) + single_value_len] = c;
    3051. 

  3051. 			psemi = i;
    3052. 

  3052. 			if (!str[i]) return;
    3053. 

  3053. 		}
    3054. 

  3054. 		i++;
    3055. 

  3055. 	}
    3056. 

  3056. }
    3057. 

  3057. 

  3058. GF_Err laser_parse_choice(LASeR_Choice *choice, char *attribute_content)
    3059. 

  3059. {
    3060. 

  3060. 	if (!strcmp(attribute_content, "none")) {
    3061. 

  3061. 		choice->type = LASeR_CHOICE_NONE;
    3062. 

  3062. 	} else if (!strcmp(attribute_content, "all")) {
    3063. 

  3063. 		choice->type = LASeR_CHOICE_ALL;
    3064. 

  3064. 	} else {
    3065. 

  3065. 		choice->type = LASeR_CHOICE_N;
    3066. 

  3066. 		choice->choice_index = atoi(attribute_content);
    3067. 

  3067. 	}
    3068. 

  3068. 	return GF_OK;
    3069. 

  3069. }
    3070. 

  3070. 

  3071. GF_Err laser_parse_size(LASeR_Size *size, char *attribute_content)
    3072. 

  3072. {
    3073. 

  3073. 	char *str = attribute_content;
    3074. 

  3074. 	u32 i = 0;
    3075. 

  3075. 	i+=svg_parse_number(&(str[i]), &(size->width), 0);
    3076. 

  3076. 	i+=svg_parse_number(&(str[i]), &(size->height), 0);
    3077. 

  3077. 	return GF_OK;
    3078. 

  3078. }
    3079. 

  3079. 

  3080. GF_Err gf_svg_parse_element_id(GF_Node *n, const char *nodename, Bool warning_if_defined)
    3081. 

  3081. {
    3082. 

  3082. 	GF_SceneGraph *sg = gf_node_get_graph((GF_Node *)n);
    3083. 

  3083. 	u32 id = gf_sg_get_max_node_id(sg) + 1;
    3084. 

  3084. 	gf_node_set_id(n, id, nodename);
    3085. 

  3085. 	return GF_OK;
    3086. 

  3086. }
    3087. 

  3087. 

  3088. /* Parse an SVG attribute */
    3089. 

  3089. GF_EXPORT
    3090. 

  3090. GF_Err gf_svg_parse_attribute(GF_Node *n, GF_FieldInfo *info, char *attribute_content, u8 anim_value_type)
    3091. 

  3091. {
    3092. 

  3092.     /* for all attributes, except strings, apply some sort of white space normalization*/
    3093. 

  3093. 	if (info->fieldType != DOM_String_datatype && strlen(attribute_content)) {
    3094. 

  3094. 		u32 i, len;
    3095. 

  3095. 		/*remove spaces at the begining*/
    3096. 

  3096. 		while (attribute_content[0] && (strchr("\r\n\t ", attribute_content[0])))
    3097. 

  3097. 			attribute_content++;
    3098. 

  3098. 

  3099. 		/*change all special chars in spaces*/
    3100. 

  3100. 		i=0;
    3101. 

  3101. 		len = (u32) strlen(attribute_content);
    3102. 

  3102. 		while (i<len) {
    3103. 

  3103. 			if (strchr("\r\n\t", attribute_content[i]))
    3104. 

  3104. 				attribute_content[i] = ' ';
    3105. 

  3105. 			i++;
    3106. 

  3106. 		}
    3107. 

  3107. 		/*remove spaces in the end*/
    3108. 

  3108. 		while (len && attribute_content[len-1]==' ') {
    3109. 

  3109. 			attribute_content[len-1] = 0;
    3110. 

  3110. 			len--;
    3111. 

  3111. 		}
    3112. 

  3112. 	}
    3113. 

  3113. 

  3114. 	switch (info->fieldType) {
    3115. 

  3115. 	case SVG_Boolean_datatype:
    3116. 

  3116. 		svg_parse_boolean((SVG_Boolean *)info->far_ptr, attribute_content);
    3117. 

  3117. 	    break;
    3118. 

  3118. 	case SVG_Color_datatype:
    3119. 

  3119. 		svg_parse_color((SVG_Color *)info->far_ptr, attribute_content);
    3120. 

  3120. 	    break;
    3121. 

  3121. 	case SVG_Paint_datatype:
    3122. 

  3122. 		svg_parse_paint(n, (SVG_Paint *)info->far_ptr, attribute_content);
    3123. 

  3123. 		break;
    3124. 

  3124. 

  3125. /* beginning of keyword type parsing */
    3126. 

  3126. 	case SVG_FillRule_datatype:
    3127. 

  3127. 		svg_parse_clipfillrule((SVG_FillRule *)info->far_ptr, attribute_content);
    3128. 

  3128. 		break;
    3129. 

  3129. 	case SVG_StrokeLineJoin_datatype:
    3130. 

  3130. 		svg_parse_strokelinejoin((SVG_StrokeLineJoin *)info->far_ptr, attribute_content);
    3131. 

  3131. 		break;
    3132. 

  3132. 	case SVG_StrokeLineCap_datatype:
    3133. 

  3133. 		svg_parse_strokelinecap((SVG_StrokeLineCap *)info->far_ptr, attribute_content);
    3134. 

  3134. 		break;
    3135. 

  3135. 	case SVG_FontStyle_datatype:
    3136. 

  3136. 		svg_parse_fontstyle((SVG_FontStyle *)info->far_ptr, attribute_content);
    3137. 

  3137. 		break;
    3138. 

  3138. 	case SVG_FontWeight_datatype:
    3139. 

  3139. 		svg_parse_fontweight((SVG_FontWeight *)info->far_ptr, attribute_content);
    3140. 

  3140. 		break;
    3141. 

  3141. 	case SVG_FontVariant_datatype:
    3142. 

  3142. 		svg_parse_fontvariant((SVG_FontVariant *)info->far_ptr, attribute_content);
    3143. 

  3143. 		break;
    3144. 

  3144. 	case SVG_TextAnchor_datatype:
    3145. 

  3145. 		svg_parse_textanchor((SVG_TextAnchor *)info->far_ptr, attribute_content);
    3146. 

  3146. 		break;
    3147. 

  3147. 	case SVG_Display_datatype:
    3148. 

  3148. 		svg_parse_display((SVG_Display *)info->far_ptr, attribute_content);
    3149. 

  3149. 		break;
    3150. 

  3150. 	case SVG_Visibility_datatype:
    3151. 

  3151. 		svg_parse_visibility((SVG_Visibility *)info->far_ptr, attribute_content);
    3152. 

  3152. 		break;
    3153. 

  3153. 	case SVG_Overflow_datatype:
    3154. 

  3154. 		svg_parse_overflow((SVG_Overflow *)info->far_ptr, attribute_content);
    3155. 

  3155. 		break;
    3156. 

  3156. 	case SVG_ZoomAndPan_datatype:
    3157. 

  3157. 		svg_parse_zoomandpan((SVG_ZoomAndPan *)info->far_ptr, attribute_content);
    3158. 

  3158. 		break;
    3159. 

  3159. 	case SVG_DisplayAlign_datatype:
    3160. 

  3160. 		svg_parse_displayalign((SVG_DisplayAlign *)info->far_ptr, attribute_content);
    3161. 

  3161. 		break;
    3162. 

  3162. 	case SVG_TextAlign_datatype:
    3163. 

  3163. 		svg_parse_textalign((SVG_TextAlign *)info->far_ptr, attribute_content);
    3164. 

  3164. 		break;
    3165. 

  3165. 	case SVG_PointerEvents_datatype:
    3166. 

  3166. 		svg_parse_pointerevents((SVG_PointerEvents *)info->far_ptr, attribute_content);
    3167. 

  3167. 		break;
    3168. 

  3168. 	case SVG_RenderingHint_datatype:
    3169. 

  3169. 		svg_parse_renderinghint((SVG_RenderingHint *)info->far_ptr, attribute_content);
    3170. 

  3170. 		break;
    3171. 

  3171. 	case SVG_VectorEffect_datatype:
    3172. 

  3172. 		svg_parse_vectoreffect((SVG_VectorEffect *)info->far_ptr, attribute_content);
    3173. 

  3173. 		break;
    3174. 

  3174. 	case SVG_PlaybackOrder_datatype:
    3175. 

  3175. 		svg_parse_playbackorder((SVG_PlaybackOrder *)info->far_ptr, attribute_content);
    3176. 

  3176. 		break;
    3177. 

  3177. 	case SVG_TimelineBegin_datatype:
    3178. 

  3178. 		svg_parse_timelinebegin((SVG_TimelineBegin *)info->far_ptr, attribute_content);
    3179. 

  3179. 		break;
    3180. 

  3180. 	case XML_Space_datatype:
    3181. 

  3181. 		svg_parse_xmlspace((XML_Space *)info->far_ptr, attribute_content);
    3182. 

  3182. 		break;
    3183. 

  3183. 	case XMLEV_Propagate_datatype:
    3184. 

  3184. 		svg_parse_xmlev_propagate((XMLEV_Propagate *)info->far_ptr, attribute_content);
    3185. 

  3185. 		break;
    3186. 

  3186. 	case XMLEV_DefaultAction_datatype:
    3187. 

  3187. 		svg_parse_xmlev_defaultAction((XMLEV_DefaultAction *)info->far_ptr, attribute_content);
    3188. 

  3188. 		break;
    3189. 

  3189. 	case XMLEV_Phase_datatype:
    3190. 

  3190. 		svg_parse_xmlev_phase((XMLEV_Phase *)info->far_ptr, attribute_content);
    3191. 

  3191. 		break;
    3192. 

  3192. 	case SMIL_SyncBehavior_datatype:
    3193. 

  3193. 		smil_parse_syncBehaviorOrDefault((SMIL_SyncBehavior *)info->far_ptr, attribute_content);
    3194. 

  3194. 		break;
    3195. 

  3195. 	case SMIL_SyncTolerance_datatype:
    3196. 

  3196. 		smil_parse_syncToleranceOrDefault((SMIL_SyncTolerance *)info->far_ptr, attribute_content);
    3197. 

  3197. 		break;
    3198. 

  3198. 	case SMIL_AttributeType_datatype:
    3199. 

  3199. 		smil_parse_attributeType((SMIL_AttributeType *)info->far_ptr, attribute_content);
    3200. 

  3200. 		break;
    3201. 

  3201. 	case SMIL_CalcMode_datatype:
    3202. 

  3202. 		smil_parse_calcmode((SMIL_CalcMode *)info->far_ptr, attribute_content);
    3203. 

  3203. 		break;
    3204. 

  3204. 	case SMIL_Additive_datatype:
    3205. 

  3205. 		smil_parse_additive((SMIL_CalcMode *)info->far_ptr, attribute_content);
    3206. 

  3206. 		break;
    3207. 

  3207. 	case SMIL_Accumulate_datatype:
    3208. 

  3208. 		smil_parse_accumulate((SMIL_Accumulate *)info->far_ptr, attribute_content);
    3209. 

  3209. 		break;
    3210. 

  3210. 	case SMIL_Restart_datatype:
    3211. 

  3211. 		smil_parse_restart((SMIL_Restart *)info->far_ptr, attribute_content);
    3212. 

  3212. 		break;
    3213. 

  3213. 	case SMIL_Fill_datatype:
    3214. 

  3214. 		smil_parse_fill((SMIL_Fill *)info->far_ptr, attribute_content);
    3215. 

  3215. 		break;
    3216. 

  3216. 	case SVG_GradientUnit_datatype:
    3217. 

  3217. 		*((SVG_GradientUnit *)info->far_ptr) = !strcmp(attribute_content, "userSpaceOnUse") ? SVG_GRADIENTUNITS_USER : SVG_GRADIENTUNITS_OBJECT;
    3218. 

  3218. 		break;
    3219. 

  3219. 	case SVG_FocusHighlight_datatype:
    3220. 

  3220. 		svg_parse_focushighlight((SVG_FocusHighlight*)info->far_ptr, attribute_content);
    3221. 

  3221. 		break;
    3222. 

  3222. 	case SVG_Focusable_datatype:
    3223. 

  3223. 		svg_parse_focusable((SVG_Focusable*)info->far_ptr, attribute_content);
    3224. 

  3224. 		break;
    3225. 

  3225. 

  3226. 	case SVG_InitialVisibility_datatype:
    3227. 

  3227. 		svg_parse_initialvisibility((SVG_InitialVisibility*)info->far_ptr, attribute_content);
    3228. 

  3228. 		break;
    3229. 

  3229. 	case SVG_Overlay_datatype:
    3230. 

  3230. 		svg_parse_overlay((SVG_Overlay*)info->far_ptr, attribute_content);
    3231. 

  3231. 		break;
    3232. 

  3232. 	case SVG_TransformBehavior_datatype:
    3233. 

  3233. 		svg_parse_transformbehavior((SVG_TransformBehavior*)info->far_ptr, attribute_content);
    3234. 

  3234. 		break;
    3235. 

  3235. 	case SVG_SpreadMethod_datatype:
    3236. 

  3236. 		if (!strcmp(attribute_content, "reflect")) *(u8*)info->far_ptr = SVG_SPREAD_REFLECT;
    3237. 

  3237. 		else if (!strcmp(attribute_content, "repeat")) *(u8*)info->far_ptr = SVG_SPREAD_REPEAT;
    3238. 

  3238. 		else *(u8*)info->far_ptr = SVG_SPREAD_PAD;
    3239. 

  3239. 		break;
    3240. 

  3240. 	case SVG_Filter_TransferType_datatype:
    3241. 

  3241. 		if (!strcmp(attribute_content, "table")) *(u8*)info->far_ptr = SVG_FILTER_TRANSFER_TABLE;
    3242. 

  3242. 		else if (!strcmp(attribute_content, "discrete")) *(u8*)info->far_ptr = SVG_FILTER_TRANSFER_DISCRETE;
    3243. 

  3243. 		else if (!strcmp(attribute_content, "linear")) *(u8*)info->far_ptr = SVG_FILTER_TRANSFER_LINEAR;
    3244. 

  3244. 		else if (!strcmp(attribute_content, "gamma")) *(u8*)info->far_ptr = SVG_FILTER_TRANSFER_GAMMA;
    3245. 

  3245. 		else *(u8*)info->far_ptr = SVG_FILTER_TRANSFER_IDENTITY;
    3246. 

  3246. 		break;
    3247. 

  3247. 

  3248. /* end of keyword type parsing */
    3249. 

  3249. 

  3250. 	/* keyword | numbers (with possibly units) */
    3251. 

  3251. 	case SVG_Length_datatype:
    3252. 

  3252. 	case SVG_Coordinate_datatype:
    3253. 

  3253. 	case SVG_FontSize_datatype:
    3254. 

  3254. 	case SVG_Rotate_datatype:
    3255. 

  3255.     case SVG_Number_datatype:
    3256. 

  3256. 		svg_parse_length((SVG_Number*)info->far_ptr, attribute_content, 0);
    3257. 

  3257. 		break;
    3258. 

  3258. 

  3259. 	case SMIL_AnimateValue_datatype:
    3260. 

  3260. 		svg_parse_one_anim_value(n, (SMIL_AnimateValue*)info->far_ptr, attribute_content, anim_value_type);
    3261. 

  3261. 		break;
    3262. 

  3262. 	case SMIL_AnimateValues_datatype:
    3263. 

  3263. 		svg_parse_anim_values(n, (SMIL_AnimateValues*)info->far_ptr, attribute_content, anim_value_type);
    3264. 

  3264. 		break;
    3265. 

  3265. 

  3266. 	case XMLRI_datatype:
    3267. 

  3267. 		svg_parse_iri(n, (XMLRI*)info->far_ptr, attribute_content);
    3268. 

  3268. 		break;
    3269. 

  3269. 	case XML_IDREF_datatype:
    3270. 

  3270. 		svg_parse_idref(n, (XMLRI*)info->far_ptr, attribute_content);
    3271. 

  3271. 		break;
    3272. 

  3272. 	case SMIL_AttributeName_datatype:
    3273. 

  3273. 		((SMIL_AttributeName *)info->far_ptr)->name = gf_strdup(attribute_content);
    3274. 

  3274. 		break;
    3275. 

  3275. 	case SMIL_Times_datatype:
    3276. 

  3276. 		smil_parse_time_list(n, *(GF_List **)info->far_ptr, attribute_content);
    3277. 

  3277. 		break;
    3278. 

  3278. 	case SMIL_Duration_datatype:
    3279. 

  3279. 		smil_parse_min_max_dur_repeatdur((SMIL_Duration*)info->far_ptr, attribute_content);
    3280. 

  3280. 		break;
    3281. 

  3281. 	case SMIL_RepeatCount_datatype:
    3282. 

  3282. 		smil_parse_repeatcount((SMIL_RepeatCount*)info->far_ptr, attribute_content);
    3283. 

  3283. 		break;
    3284. 

  3284. 	case SVG_PathData_datatype:
    3285. 

  3285. 		svg_parse_path((SVG_PathData*)info->far_ptr, attribute_content);
    3286. 

  3286. 		break;
    3287. 

  3287. 	case SVG_Points_datatype:
    3288. 

  3288. 		svg_parse_points(*(GF_List **)(info->far_ptr), attribute_content);
    3289. 

  3289. 		break;
    3290. 

  3290. 	case SMIL_KeyTimes_datatype:
    3291. 

  3291. 	case SMIL_KeyPoints_datatype:
    3292. 

  3292. 	case SMIL_KeySplines_datatype:
    3293. 

  3293. 	case SVG_Numbers_datatype:
    3294. 

  3294. 		svg_parse_numbers(*(GF_List **)(info->far_ptr), attribute_content, 0);
    3295. 

  3295. 		break;
    3296. 

  3296. 	case SVG_Coordinates_datatype:
    3297. 

  3297. 		svg_parse_coordinates(*(GF_List **)(info->far_ptr), attribute_content);
    3298. 

  3298. 		break;
    3299. 

  3299. 	case SVG_ViewBox_datatype:
    3300. 

  3300. 		svg_parse_viewbox((SVG_ViewBox*)info->far_ptr, attribute_content);
    3301. 

  3301. 		break;
    3302. 

  3302. 	case SVG_StrokeDashArray_datatype:
    3303. 

  3303. 		svg_parse_strokedasharray((SVG_StrokeDashArray*)info->far_ptr, attribute_content);
    3304. 

  3304. 		break;
    3305. 

  3305. 	case SVG_FontFamily_datatype:
    3306. 

  3306. 		svg_parse_fontfamily((SVG_FontFamily*)info->far_ptr, attribute_content);
    3307. 

  3307. 		break;
    3308. 

  3308. 	case SVG_Motion_datatype:
    3309. 

  3309. 		svg_parse_point_into_matrix((GF_Matrix2D*)info->far_ptr, attribute_content);
    3310. 

  3310. 		break;
    3311. 

  3311. 	case SVG_Transform_datatype:
    3312. 

  3312. 		svg_parse_transform((SVG_Transform*)info->far_ptr, attribute_content);
    3313. 

  3313. 		break;
    3314. 

  3314. 	case SVG_Transform_Translate_datatype:
    3315. 

  3315. 		{
    3316. 

  3316. 			u32 i = 0;
    3317. 

  3317. 			SVG_Point *p = (SVG_Point *)info->far_ptr;;
    3318. 

  3318. 			i+=svg_parse_number(&(attribute_content[i]), &(p->x), 0);
    3319. 

  3319. 			if (attribute_content[i] == 0) {
    3320. 

  3320. 				p->y = 0;
    3321. 

  3321. 			} else {
    3322. 

  3322. 				i+=svg_parse_number(&(attribute_content[i]), &(p->y), 0);
    3323. 

  3323. 			}
    3324. 

  3324. 		}
    3325. 

  3325. 		break;
    3326. 

  3326. 	case SVG_Transform_Scale_datatype:
    3327. 

  3327. 		{
    3328. 

  3328. 			u32 i = 0;
    3329. 

  3329. 			SVG_Point *p = (SVG_Point *)info->far_ptr;;
    3330. 

  3330. 			i+=svg_parse_number(&(attribute_content[i]), &(p->x), 0);
    3331. 

  3331. 			if (attribute_content[i] == 0) {
    3332. 

  3332. 				p->y = p->x;
    3333. 

  3333. 			} else {
    3334. 

  3334. 				i+=svg_parse_number(&(attribute_content[i]), &(p->y), 0);
    3335. 

  3335. 			}
    3336. 

  3336. 		}
    3337. 

  3337. 		break;
    3338. 

  3338. 	case SVG_Transform_SkewX_datatype:
    3339. 

  3339. 	case SVG_Transform_SkewY_datatype:
    3340. 

  3340. 		{
    3341. 

  3341. 			Fixed *p = (Fixed *)info->far_ptr;
    3342. 

  3342. 			svg_parse_number(attribute_content, p, 1);
    3343. 

  3343. 		}
    3344. 

  3344. 		break;
    3345. 

  3345. 	case SVG_Transform_Rotate_datatype:
    3346. 

  3346. 		{
    3347. 

  3347. 			u32 i = 0;
    3348. 

  3348. 			SVG_Point_Angle *p = (SVG_Point_Angle *)info->far_ptr;;
    3349. 

  3349. 			i+=svg_parse_number(&(attribute_content[i]), &(p->angle), 1);
    3350. 

  3350. 			if (attribute_content[i] == 0) {
    3351. 

  3351. 				p->y = p->x = 0;
    3352. 

  3352. 			} else {
    3353. 

  3353. 				i+=svg_parse_number(&(attribute_content[i]), &(p->x), 0);
    3354. 

  3354. 				i+=svg_parse_number(&(attribute_content[i]), &(p->y), 0);
    3355. 

  3355. 			}
    3356. 

  3356. 		}
    3357. 

  3357. 		break;
    3358. 

  3358. 	case SVG_PreserveAspectRatio_datatype:
    3359. 

  3359. 		svg_parse_preserveaspectratio((SVG_PreserveAspectRatio*)info->far_ptr, attribute_content);
    3360. 

  3360. 		break;
    3361. 

  3361. 	case SVG_TransformType_datatype:
    3362. 

  3362. 		svg_parse_animatetransform_type((SVG_TransformType*)info->far_ptr, attribute_content);
    3363. 

  3363. 		break;
    3364. 

  3364. 

  3365. 	case SVG_ID_datatype:
    3366. 

  3366. 	case DOM_String_datatype:
    3367. 

  3367. 	case SVG_ContentType_datatype:
    3368. 

  3368. 	case SVG_LanguageID_datatype:
    3369. 

  3369. 		if (*(SVG_String *)info->far_ptr) gf_free(*(SVG_String *)info->far_ptr);
    3370. 

  3370. 

  3371. 		*(SVG_String *)info->far_ptr = gf_strdup(attribute_content);
    3372. 

  3372. 		break;
    3373. 

  3373. 

  3374. 	case DOM_StringList_datatype:
    3375. 

  3375. 		svg_parse_strings(*(GF_List **)info->far_ptr, attribute_content, 0);
    3376. 

  3376. 		break;
    3377. 

  3377. 	case XMLRI_List_datatype:
    3378. 

  3378. 		svg_parse_strings(*(GF_List **)info->far_ptr, attribute_content, 1);
    3379. 

  3379. 		break;
    3380. 

  3380. 

  3381. 	case XMLEV_Event_datatype:
    3382. 

  3382. 	{
    3383. 

  3383. 		XMLEV_Event *xml_ev = (XMLEV_Event *)info->far_ptr;
    3384. 

  3384. 		char *sep = strchr(attribute_content, '(');
    3385. 

  3385. 		if (sep) {
    3386. 

  3386. 			sep[0] = 0;
    3387. 

  3387. 			xml_ev->type = gf_dom_event_type_by_name(attribute_content);
    3388. 

  3388. 			sep[0] = '(';
    3389. 

  3389. 			if ((xml_ev->type == GF_EVENT_REPEAT) || (xml_ev->type == GF_EVENT_REPEAT_EVENT)) {
    3390. 

  3390. 				char _v;
    3391. 

  3391. 				sscanf(sep, "(%c)", &_v);
    3392. 

  3392. 				xml_ev->parameter = _v;
    3393. 

  3393. 			} else { /* key events ... */
    3394. 

  3394. 				char *sep2 = strchr(attribute_content, ')');
    3395. 

  3395. 				sep2[0] = 0;
    3396. 

  3396. 				xml_ev->parameter = gf_dom_get_key_type(sep+1);
    3397. 

  3397. 				sep2[0] = ')';
    3398. 

  3398. 			}
    3399. 

  3399. 		} else {
    3400. 

  3400. 			xml_ev->parameter = 0;
    3401. 

  3401. 			xml_ev->type = gf_dom_event_type_by_name(attribute_content);
    3402. 

  3402. 		}
    3403. 

  3403. 	}
    3404. 

  3404. 		break;
    3405. 

  3405. 

  3406. 	case SVG_Focus_datatype:
    3407. 

  3407. 		svg_parse_focus(n, (SVG_Focus*)info->far_ptr, attribute_content);
    3408. 

  3408. 		break;
    3409. 

  3409. 	case LASeR_Choice_datatype:
    3410. 

  3410. 		laser_parse_choice((LASeR_Choice*)info->far_ptr, attribute_content);
    3411. 

  3411. 		break;
    3412. 

  3412. 	case LASeR_Size_datatype:
    3413. 

  3413. 		laser_parse_size((LASeR_Size*)info->far_ptr, attribute_content);
    3414. 

  3414. 		break;
    3415. 

  3415. 	case SVG_Clock_datatype:
    3416. 

  3416. 		svg_parse_clock_value(attribute_content, (SVG_Clock*)info->far_ptr);
    3417. 

  3417. 		break;
    3418. 

  3418. 	case SVG_Unknown_datatype:
    3419. 

  3419. 		if (*(SVG_String *)info->far_ptr) gf_free(*(SVG_String *)info->far_ptr);
    3420. 

  3420. 		*(SVG_String *)info->far_ptr = gf_strdup(attribute_content);
    3421. 

  3421. 		break;
    3422. 

  3422. 	default:
    3423. 

  3423. 		GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("[SVG Parsing] Cannot parse attribute %s\n", info->name, gf_svg_attribute_type_to_string(info->fieldType)));
    3424. 

  3424. 		break;
    3425. 

  3425. 	}
    3426. 

  3426. 	return GF_OK;
    3427. 

  3427. }
    3428. 

  3428. 

  3429. void svg_parse_one_style(GF_Node *n, char *one_style)
    3430. 

  3430. {
    3431. 

  3431. 	GF_FieldInfo info;
    3432. 

  3432. 	char *c, sep;
    3433. 

  3433. 	u32 attributeNameLen;
    3434. 

  3434. 

  3435. 	while (*one_style == ' ') one_style++;
    3436. 

  3436. 	c = strchr(one_style, ':');
    3437. 

  3437. 	if (!c) return;
    3438. 

  3438. 	attributeNameLen = (u32) (c - one_style);
    3439. 

  3439. 	sep = one_style[attributeNameLen];
    3440. 

  3440. 	one_style[attributeNameLen] = 0;
    3441. 

  3441. 	while (strchr("\r\n\t ", one_style[0]))
    3442. 

  3442. 		one_style++;
    3443. 

  3443. 	if (!gf_node_get_field_by_name(n, one_style, &info)) {
    3444. 

  3444. 		c++;
    3445. 

  3445. 		gf_svg_parse_attribute(n, &info, c, 0);
    3446. 

  3446. 	} else {
    3447. 

  3447. 		GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Attribute %s does not belong to element %s.\n", one_style, gf_node_get_class_name(n)));
    3448. 

  3448. 	}
    3449. 

  3449. 	one_style[attributeNameLen] = sep;
    3450. 

  3450. }
    3451. 

  3451. 

  3452. void gf_svg_parse_style(GF_Node *n, char *style)
    3453. 

  3453. {
    3454. 

  3454. 	u32 i = 0;
    3455. 

  3455. 	char *str = style;
    3456. 

  3456. 	s32 psemi = -1;
    3457. 

  3457. 

  3458. 	while (1) {
    3459. 

  3459. 		if (str[i] == ';' || str[i] == 0) {
    3460. 

  3460. 			u32 single_value_len = 0;
    3461. 

  3461. 			single_value_len = i - (psemi+1);
    3462. 

  3462. 			if (single_value_len) {
    3463. 

  3463. 				char c = str[psemi+1 + single_value_len];
    3464. 

  3464. 				str[psemi+1 + single_value_len] = 0;
    3465. 

  3465. 				svg_parse_one_style(n, str + psemi+1);
    3466. 

  3466. 				str[psemi+1 + single_value_len] = c;
    3467. 

  3467. 				psemi = i;
    3468. 

  3468. 			}
    3469. 

  3469. 			if (!str[i]) return;
    3470. 

  3470. 		}
    3471. 

  3471. 		i++;
    3472. 

  3472. 	}
    3473. 

  3473. 

  3474. }
    3475. 

  3475. 

  3476. GF_EXPORT
    3477. 

  3477. void *gf_svg_create_attribute_value(u32 attribute_type)
    3478. 

  3478. {
    3479. 

  3479. 	switch (attribute_type) {
    3480. 

  3480. 	case SVG_Boolean_datatype:
    3481. 

  3481. 		{
    3482. 

  3482. 			SVG_Boolean *b;
    3483. 

  3483. 			GF_SAFEALLOC(b, SVG_Boolean)
    3484. 

  3484. 			return b;
    3485. 

  3485. 		}
    3486. 

  3486. 		break;
    3487. 

  3487. 	case SVG_Color_datatype:
    3488. 

  3488. 		{
    3489. 

  3489. 			SVG_Color *color;
    3490. 

  3490. 			GF_SAFEALLOC(color, SVG_Color)
    3491. 

  3491. 			return color;
    3492. 

  3492. 		}
    3493. 

  3493. 		break;
    3494. 

  3494. 	case SVG_Paint_datatype:
    3495. 

  3495. 		{
    3496. 

  3496. 			SVG_Paint *paint;
    3497. 

  3497. 			GF_SAFEALLOC(paint, SVG_Paint)
    3498. 

  3498. 			return paint;
    3499. 

  3499. 		}
    3500. 

  3500. 		break;
    3501. 

  3501. 

  3502. 	/* keyword types */
    3503. 

  3503. 	case SVG_FillRule_datatype:
    3504. 

  3504. 	case SVG_StrokeLineJoin_datatype:
    3505. 

  3505. 	case SVG_StrokeLineCap_datatype:
    3506. 

  3506. 	case SVG_FontStyle_datatype:
    3507. 

  3507. 	case SVG_FontWeight_datatype:
    3508. 

  3508. 	case SVG_FontVariant_datatype:
    3509. 

  3509. 	case SVG_TextAnchor_datatype:
    3510. 

  3510. 	case SVG_Display_datatype:
    3511. 

  3511. 	case SVG_Visibility_datatype:
    3512. 

  3512. 	case SVG_Overflow_datatype:
    3513. 

  3513. 	case SVG_ZoomAndPan_datatype:
    3514. 

  3514. 	case SVG_DisplayAlign_datatype:
    3515. 

  3515. 	case SVG_TextAlign_datatype:
    3516. 

  3516. 	case SVG_PointerEvents_datatype:
    3517. 

  3517. 	case SVG_RenderingHint_datatype:
    3518. 

  3518. 	case SVG_VectorEffect_datatype:
    3519. 

  3519. 	case SVG_PlaybackOrder_datatype:
    3520. 

  3520. 	case SVG_TimelineBegin_datatype:
    3521. 

  3521. 	case XML_Space_datatype:
    3522. 

  3522. 	case XMLEV_Propagate_datatype:
    3523. 

  3523. 	case XMLEV_DefaultAction_datatype:
    3524. 

  3524. 	case XMLEV_Phase_datatype:
    3525. 

  3525. 	case SMIL_SyncBehavior_datatype:
    3526. 

  3526. 	case SMIL_AttributeType_datatype:
    3527. 

  3527. 	case SMIL_CalcMode_datatype:
    3528. 

  3528. 	case SMIL_Additive_datatype:
    3529. 

  3529. 	case SMIL_Accumulate_datatype:
    3530. 

  3530. 	case SMIL_Restart_datatype:
    3531. 

  3531. 	case SMIL_Fill_datatype:
    3532. 

  3532. 	case SVG_TransformType_datatype:
    3533. 

  3533. 	case SVG_FocusHighlight_datatype:
    3534. 

  3534. 	case SVG_InitialVisibility_datatype:
    3535. 

  3535. 	case SVG_GradientUnit_datatype:
    3536. 

  3536. 	case SVG_Overlay_datatype:
    3537. 

  3537. 	case SVG_TransformBehavior_datatype:
    3538. 

  3538. 	case SVG_SpreadMethod_datatype:
    3539. 

  3539. 	case SVG_Focusable_datatype:
    3540. 

  3540. 	case SVG_Filter_TransferType_datatype:
    3541. 

  3541. 		{
    3542. 

  3542. 			u8 *keyword;
    3543. 

  3543. 			GF_SAFEALLOC(keyword, u8)
    3544. 

  3544. 			return keyword;
    3545. 

  3545. 		}
    3546. 

  3546. 		break;
    3547. 

  3547. 	case SMIL_SyncTolerance_datatype:
    3548. 

  3548. 		{
    3549. 

  3549. 			SMIL_SyncTolerance *st;
    3550. 

  3550. 			GF_SAFEALLOC(st, SMIL_SyncTolerance)
    3551. 

  3551. 			return st;
    3552. 

  3552. 		}
    3553. 

  3553. 		break;
    3554. 

  3554. 

  3555. 	/* inheritable floats */
    3556. 

  3556. 	case SVG_FontSize_datatype:
    3557. 

  3557. 	case SVG_Length_datatype:
    3558. 

  3558. 	case SVG_Coordinate_datatype:
    3559. 

  3559. 	case SVG_Rotate_datatype:
    3560. 

  3560. 	case SVG_Number_datatype:
    3561. 

  3561. 		{
    3562. 

  3562. 			SVG_Number *number;
    3563. 

  3563. 			GF_SAFEALLOC(number, SVG_Number)
    3564. 

  3564. 			return number;
    3565. 

  3565. 		}
    3566. 

  3566. 		break;
    3567. 

  3567. 

  3568. 	case SVG_StrokeDashArray_datatype:
    3569. 

  3569. 		{
    3570. 

  3570. 			SVG_StrokeDashArray *array;
    3571. 

  3571. 			GF_SAFEALLOC(array, SVG_StrokeDashArray)
    3572. 

  3572. 			return array;
    3573. 

  3573. 		}
    3574. 

  3574. 		break;
    3575. 

  3575. 

  3576. 	case SVG_Motion_datatype:
    3577. 

  3577. 		{
    3578. 

  3578. 			GF_Matrix2D *p;
    3579. 

  3579. 			GF_SAFEALLOC(p, GF_Matrix2D)
    3580. 

  3580. 			gf_mx2d_init(*p);
    3581. 

  3581. 			return p;
    3582. 

  3582. 		}
    3583. 

  3583. 		break;
    3584. 

  3584. 

  3585. 	case SVG_Transform_datatype:
    3586. 

  3586. 		{
    3587. 

  3587. 			SVG_Transform *p;
    3588. 

  3588. 			GF_SAFEALLOC(p, SVG_Transform)
    3589. 

  3589. 			gf_mx2d_init(p->mat);
    3590. 

  3590. 			return p;
    3591. 

  3591. 		}
    3592. 

  3592. 		break;
    3593. 

  3593. 

  3594. 	case SVG_Transform_Translate_datatype:
    3595. 

  3595. 	case SVG_Transform_Scale_datatype:
    3596. 

  3596. 		{
    3597. 

  3597. 			SVG_Point *p;
    3598. 

  3598. 			GF_SAFEALLOC(p, SVG_Point)
    3599. 

  3599. 			return p;
    3600. 

  3600. 		}
    3601. 

  3601. 		break;
    3602. 

  3602. 

  3603. 	case SVG_Transform_SkewX_datatype:
    3604. 

  3604. 	case SVG_Transform_SkewY_datatype:
    3605. 

  3605. 		{
    3606. 

  3606. 			Fixed *p;
    3607. 

  3607. 			GF_SAFEALLOC(p, Fixed)
    3608. 

  3608. 			return p;
    3609. 

  3609. 		}
    3610. 

  3610. 		break;
    3611. 

  3611. 

  3612. 	case SVG_Transform_Rotate_datatype:
    3613. 

  3613. 		{
    3614. 

  3614. 			SVG_Point_Angle *p;
    3615. 

  3615. 			GF_SAFEALLOC(p, SVG_Point_Angle)
    3616. 

  3616. 			return p;
    3617. 

  3617. 		}
    3618. 

  3618. 		break;
    3619. 

  3619. 

  3620. 	case SVG_ViewBox_datatype:
    3621. 

  3621. 		{
    3622. 

  3622. 			SVG_ViewBox *viewbox;
    3623. 

  3623. 			GF_SAFEALLOC(viewbox, SVG_ViewBox)
    3624. 

  3624. 			return viewbox;
    3625. 

  3625. 		}
    3626. 

  3626. 		break;
    3627. 

  3627. 	case XMLRI_datatype:
    3628. 

  3628. 	case XML_IDREF_datatype:
    3629. 

  3629. 		{
    3630. 

  3630. 			XMLRI *iri;
    3631. 

  3631. 			GF_SAFEALLOC(iri, XMLRI)
    3632. 

  3632. 			return iri;
    3633. 

  3633. 		}
    3634. 

  3634. 		break;
    3635. 

  3635. 	case SVG_FontFamily_datatype:
    3636. 

  3636. 		{
    3637. 

  3637. 			SVG_FontFamily *fontfamily;
    3638. 

  3638. 			GF_SAFEALLOC(fontfamily, SVG_FontFamily)
    3639. 

  3639. 			return fontfamily;
    3640. 

  3640. 		}
    3641. 

  3641. 		break;
    3642. 

  3642. 	case DOM_String_datatype:
    3643. 

  3643. 	case SVG_ContentType_datatype:
    3644. 

  3644. 	case SVG_LanguageID_datatype:
    3645. 

  3645. 	case SVG_ID_datatype:
    3646. 

  3646. 		{
    3647. 

  3647. 			SVG_String *string;
    3648. 

  3648. 			GF_SAFEALLOC(string, SVG_String)
    3649. 

  3649. 			return string;
    3650. 

  3650. 		}
    3651. 

  3651. 		break;
    3652. 

  3652. 	case DOM_StringList_datatype:
    3653. 

  3653. 	case XMLRI_List_datatype:
    3654. 

  3654. 	case SVG_Points_datatype:
    3655. 

  3655. 	case SVG_Coordinates_datatype:
    3656. 

  3656. 	case SMIL_Times_datatype:
    3657. 

  3657. 	case SMIL_KeySplines_datatype:
    3658. 

  3658. 	case SMIL_KeyTimes_datatype:
    3659. 

  3659. 	case SMIL_KeyPoints_datatype:
    3660. 

  3660. 	case SVG_Numbers_datatype:
    3661. 

  3661. 		{
    3662. 

  3662. 			ListOfXXX *list;
    3663. 

  3663. 			GF_SAFEALLOC(list, ListOfXXX)
    3664. 

  3664. 			*list = gf_list_new();
    3665. 

  3665. 			return list;
    3666. 

  3666. 		}
    3667. 

  3667. 		break;
    3668. 

  3668. 	case SVG_PreserveAspectRatio_datatype:
    3669. 

  3669. 		{
    3670. 

  3670. 			SVG_PreserveAspectRatio *par;
    3671. 

  3671. 			GF_SAFEALLOC(par, SVG_PreserveAspectRatio)
    3672. 

  3672. 			return par;
    3673. 

  3673. 		}
    3674. 

  3674. 		break;
    3675. 

  3675. 	case SVG_PathData_datatype:
    3676. 

  3676. 		{
    3677. 

  3677. 			SVG_PathData *path;
    3678. 

  3678. 			GF_SAFEALLOC(path, SVG_PathData);
    3679. 

  3679. #if USE_GF_PATH
    3680. 

  3680. 			gf_path_reset(path);
    3681. 

  3681. 			path->fineness = FIX_ONE;
    3682. 

  3682. #else
    3683. 

  3683. 			path->commands = gf_list_new();
    3684. 

  3684. 			path->points = gf_list_new();
    3685. 

  3685. #endif
    3686. 

  3686. 			return path;
    3687. 

  3687. 		}
    3688. 

  3688. 		break;
    3689. 

  3689. 	case LASeR_Choice_datatype:
    3690. 

  3690. 		{
    3691. 

  3691. 			LASeR_Choice *ch;
    3692. 

  3692. 			GF_SAFEALLOC(ch, LASeR_Choice)
    3693. 

  3693. 			return ch;
    3694. 

  3694. 		}
    3695. 

  3695. 	case SVG_Focus_datatype:
    3696. 

  3696. 		{
    3697. 

  3697. 			SVG_Focus *foc;
    3698. 

  3698. 			GF_SAFEALLOC(foc, SVG_Focus)
    3699. 

  3699. 			return foc;
    3700. 

  3700. 		}
    3701. 

  3701. 	case SMIL_AttributeName_datatype:
    3702. 

  3702. 		{
    3703. 

  3703. 			SMIL_AttributeName *an;
    3704. 

  3704. 			GF_SAFEALLOC(an, SMIL_AttributeName)
    3705. 

  3705. 			return an;
    3706. 

  3706. 		}
    3707. 

  3707. 	case SMIL_RepeatCount_datatype:
    3708. 

  3708. 		{
    3709. 

  3709. 			SMIL_RepeatCount *rc;
    3710. 

  3710. 			GF_SAFEALLOC(rc, SMIL_RepeatCount)
    3711. 

  3711. 			return rc;
    3712. 

  3712. 		}
    3713. 

  3713. 	case SMIL_Duration_datatype:
    3714. 

  3714. 		{
    3715. 

  3715. 			SMIL_Duration *sd;
    3716. 

  3716. 			GF_SAFEALLOC(sd, SMIL_Duration)
    3717. 

  3717. 			return sd;
    3718. 

  3718. 		}
    3719. 

  3719. 	case SMIL_AnimateValue_datatype:
    3720. 

  3720. 		{
    3721. 

  3721. 			SMIL_AnimateValue *av;
    3722. 

  3722. 			GF_SAFEALLOC(av, SMIL_AnimateValue)
    3723. 

  3723. 			return av;
    3724. 

  3724. 		}
    3725. 

  3725. 		break;
    3726. 

  3726. 	case SMIL_AnimateValues_datatype:
    3727. 

  3727. 		{
    3728. 

  3728. 			SMIL_AnimateValues *av;
    3729. 

  3729. 			GF_SAFEALLOC(av, SMIL_AnimateValues)
    3730. 

  3730. 			av->values = gf_list_new();
    3731. 

  3731. 			return av;
    3732. 

  3732. 		}
    3733. 

  3733. 		break;
    3734. 

  3734. 	case SVG_Clock_datatype:
    3735. 

  3735. 		{
    3736. 

  3736. 			SVG_Clock *ck;
    3737. 

  3737. 			GF_SAFEALLOC(ck, SVG_Clock)
    3738. 

  3738. 			return ck;
    3739. 

  3739. 		}
    3740. 

  3740. 		break;
    3741. 

  3741. 

  3742. 	case XMLEV_Event_datatype:
    3743. 

  3743. 		{
    3744. 

  3744. 			XMLEV_Event *e;
    3745. 

  3745. 			GF_SAFEALLOC(e, XMLEV_Event);
    3746. 

  3746. 			return e;
    3747. 

  3747. 		}
    3748. 

  3748. 		break;
    3749. 

  3749. 	case LASeR_Size_datatype:
    3750. 

  3750. 		{
    3751. 

  3751. 			LASeR_Size *s;
    3752. 

  3752. 			GF_SAFEALLOC(s, LASeR_Size);
    3753. 

  3753. 			return s;
    3754. 

  3754. 		}
    3755. 

  3755. 		break;
    3756. 

  3756. 

  3757. 	case 0:
    3758. 

  3758. 		{
    3759. 

  3759. 			SVG_String *string;
    3760. 

  3760. 			GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("[SVG Attributes] Unspecified attribute type - defaulting to string.\n"));
    3761. 

  3761. 			GF_SAFEALLOC(string, SVG_String);
    3762. 

  3762. 			return string;
    3763. 

  3763. 		}
    3764. 

  3764. 

  3765. 

  3766. 	default:
    3767. 

  3767. 		GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Attributes] Cannot create attribute value: Type %s not supported.\n", gf_svg_attribute_type_to_string(attribute_type)));
    3768. 

  3768. 		break;
    3769. 

  3769. 	}
    3770. 

  3770. 	return NULL;
    3771. 

  3771. }
    3772. 

  3772. 

  3773. static char *svg_dump_color(SVG_Color *col)
    3774. 

  3774. {
    3775. 

  3775. 	char *res;
    3776. 

  3776. 	if (col->type == SVG_COLOR_CURRENTCOLOR) return gf_strdup("currentColor");
    3777. 

  3777. 	else if (col->type == SVG_COLOR_INHERIT) return gf_strdup("inherit");
    3778. 

  3778. 	else if (col->type !=SVG_COLOR_RGBCOLOR) {
    3779. 

  3779. 		u32 i, count;
    3780. 

  3780. 		count = sizeof(system_colors) / sizeof(struct sys_col);
    3781. 

  3781. 		for (i=0; i<count; i++) {
    3782. 

  3782. 			if (col->type == system_colors[i].type) {
    3783. 

  3783. 				return gf_strdup(system_colors[i].name);
    3784. 

  3784. 			}
    3785. 

  3785. 		}
    3786. 

  3786. 	} else {
    3787. 

  3787. 		u32 i, count = sizeof(predefined_colors) / sizeof(struct predef_col);
    3788. 

  3788. 		u32 r, g, b;
    3789. 

  3789. 		r = FIX2INT(255*col->red);
    3790. 

  3790. 		g = FIX2INT(255*col->green);
    3791. 

  3791. 		b = FIX2INT(255*col->blue);
    3792. 

  3792. 		for (i=0; i<count; i++) {
    3793. 

  3793. 			if (
    3794. 

  3794. 				(r == predefined_colors[i].r)
    3795. 

  3795. 				&& (g == predefined_colors[i].g)
    3796. 

  3796. 				&& (b == predefined_colors[i].b)
    3797. 

  3797. 			) {
    3798. 

  3798. 				return gf_strdup(predefined_colors[i].name);
    3799. 

  3799. 			}
    3800. 

  3800. 		}
    3801. 

  3801. 		res = gf_malloc(sizeof(char)*8);
    3802. 

  3802. 		sprintf(res, "#%02X%02X%02X", r, g, b);
    3803. 

  3803. 		/*compress it...*/
    3804. 

  3804. 		if ( (res[1]==res[2]) && (res[3]==res[4]) && (res[5]==res[6]) )
    3805. 

  3805. 			sprintf(res, "#%c%c%c", res[1], res[3], res[5]);
    3806. 

  3806. 		return res;
    3807. 

  3807. 	}
    3808. 

  3808. 	return NULL;
    3809. 

  3809. }
    3810. 

  3810. 

  3811. static char *svg_dump_number(SVG_Number *l)
    3812. 

  3812. {
    3813. 

  3813. 	char tmp[100];
    3814. 

  3814. 	if (l->type==SVG_NUMBER_INHERIT) return gf_strdup("inherit");
    3815. 

  3815. 	else if (l->type == SVG_NUMBER_AUTO) return gf_strdup("auto");
    3816. 

  3816. 	else if (l->type == SVG_NUMBER_AUTO_REVERSE) return gf_strdup("auto-reverse");
    3817. 

  3817. 	else {
    3818. 

  3818. 		sprintf(tmp, "%g", FIX2FLT(l->value) );
    3819. 

  3819. 		if (l->type == SVG_NUMBER_PERCENTAGE) strcat(tmp, "%");
    3820. 

  3820. 		else if (l->type == SVG_NUMBER_EMS) strcat(tmp, "em");
    3821. 

  3821. 		else if (l->type == SVG_NUMBER_EXS) strcat(tmp, "ex");
    3822. 

  3822. 		else if (l->type == SVG_NUMBER_PX) strcat(tmp, "px");
    3823. 

  3823. 		else if (l->type == SVG_NUMBER_CM) strcat(tmp, "cm");
    3824. 

  3824. 		else if (l->type == SVG_NUMBER_MM) strcat(tmp, "mm");
    3825. 

  3825. 		else if (l->type == SVG_NUMBER_IN) strcat(tmp, "in");
    3826. 

  3826. 		else if (l->type == SVG_NUMBER_PT) strcat(tmp, "pt");
    3827. 

  3827. 		else if (l->type == SVG_NUMBER_PC) strcat(tmp, "pc");
    3828. 

  3828. 

  3829. 		return gf_strdup(tmp);
    3830. 

  3830. 	}
    3831. 

  3831. }
    3832. 

  3832. 

  3833. static char *svg_dump_iri(XMLRI*iri)
    3834. 

  3834. {
    3835. 

  3835. 	if (iri->type == XMLRI_ELEMENTID) {
    3836. 

  3836. 		const char *name;
    3837. 

  3837. 		char *res;
    3838. 

  3838. 		name = gf_node_get_name((GF_Node *)iri->target);
    3839. 

  3839. 

  3840. 		if (name) {
    3841. 

  3841. 			res = gf_malloc(sizeof(char)*(strlen(name)+2));
    3842. 

  3842. 			sprintf(res, "#%s", name);
    3843. 

  3843. 		} else if (iri->target) {
    3844. 

  3844. 			res = gf_malloc(sizeof(char)*32);
    3845. 

  3845. 			sprintf(res, "#N%d", gf_node_get_id((GF_Node *)iri->target) - 1);
    3846. 

  3846. 		} else {
    3847. 

  3847. 			res = gf_strdup("");
    3848. 

  3848. 		}
    3849. 

  3849. 		return res;
    3850. 

  3850. 	}
    3851. 

  3851. 	else if ((iri->type == XMLRI_STRING) && iri->string)
    3852. 

  3852. 		return gf_strdup(iri->string);
    3853. 

  3853. 	else
    3854. 

  3854. 		return gf_strdup("");
    3855. 

  3855. }
    3856. 

  3856. 

  3857. static char *svg_dump_idref(XMLRI*iri)
    3858. 

  3858. {
    3859. 

  3859. 	const char *name;
    3860. 

  3860. 	if (iri->target) {
    3861. 

  3861. 		name = gf_node_get_name((GF_Node *)iri->target);
    3862. 

  3862. 		if (name) return gf_strdup(name);
    3863. 

  3863. 		else {
    3864. 

  3864. 			char tmp[50];
    3865. 

  3865. 			sprintf(tmp, "N%d", gf_node_get_id((GF_Node *)iri->target) - 1);
    3866. 

  3866. 			return gf_strdup(tmp);
    3867. 

  3867. 		}
    3868. 

  3868. 	}
    3869. 

  3869. 	if (iri->string) return gf_strdup(iri->string);
    3870. 

  3870. 	return gf_strdup("");
    3871. 

  3871. }
    3872. 

  3872. 

  3873. #if USE_GF_PATH
    3874. 

  3874. static char *svg_dump_path(SVG_PathData *path)
    3875. 

  3875. {
    3876. 

  3876. 	char szT[1000];
    3877. 

  3877. 	GF_Point2D *pt, last_pt, *ct1, *ct2, *end;
    3878. 

  3878. 	u32 i, *contour;
    3879. 

  3879. 	char *res = gf_malloc(sizeof(char));
    3880. 

  3880. 	res[0] = 0;
    3881. 

  3881. 

  3882. 	contour = path->contours;
    3883. 

  3883. 	last_pt.x = last_pt.y = 0;
    3884. 

  3884. 

  3885. 	for (i=0; i<path->n_points; ) {
    3886. 

  3886. 		szT[0] = 0;
    3887. 

  3887. 

  3888. 		switch (path->tags[i]) {
    3889. 

  3889. 		case GF_PATH_CURVE_ON:
    3890. 

  3890. 		case GF_PATH_CLOSE:
    3891. 

  3891. 			pt = &path->points[i];
    3892. 

  3892. 			if (!i || (*contour == i-1) ) {
    3893. 

  3893. 				sprintf(szT, "M%g %g", FIX2FLT(pt->x), FIX2FLT(pt->y));
    3894. 

  3894. 				if (i) contour++;
    3895. 

  3895. 			} else if (path->tags[i]==GF_PATH_CLOSE) {
    3896. 

  3896. 				sprintf(szT, "z");
    3897. 

  3897. 			} else {
    3898. 

  3898. 				if (i && (last_pt.x==pt->x)) sprintf(szT, "V%g", FIX2FLT(pt->y));
    3899. 

  3899. 				else if (i && (last_pt.y==pt->y)) sprintf(szT, "H%g", FIX2FLT(pt->x));
    3900. 

  3900. 				else sprintf(szT, "L%g %g", FIX2FLT(pt->x), FIX2FLT(pt->y));
    3901. 

  3901. 			}
    3902. 

  3902. 			last_pt = *pt;
    3903. 

  3903. 			i++;
    3904. 

  3904. 			break;
    3905. 

  3905. 		case GF_PATH_CURVE_CONIC:
    3906. 

  3906. 			ct1 = &path->points[i];
    3907. 

  3907. 			end = &path->points[i+1];
    3908. 

  3908. 			sprintf(szT, "Q%g %g %g %g", FIX2FLT(ct1->x), FIX2FLT(ct1->y), FIX2FLT(end->x), FIX2FLT(end->y));
    3909. 

  3909. 

  3910. 			last_pt = *end;
    3911. 

  3911. 			if (path->tags[i+2]==GF_PATH_CLOSE)  {
    3912. 

  3912. 				strcat(szT, "z");
    3913. 

  3913. 			}
    3914. 

  3914. 			i+=2;
    3915. 

  3915. 			break;
    3916. 

  3916. 		case GF_PATH_CURVE_CUBIC:
    3917. 

  3917. 			ct1 = &path->points[i];
    3918. 

  3918. 			ct2 = &path->points[i+1];
    3919. 

  3919. 			end = &path->points[i+2];
    3920. 

  3920. 			sprintf(szT, "C%g %g %g %g %g %g", FIX2FLT(ct1->x), FIX2FLT(ct1->y), FIX2FLT(ct2->x), FIX2FLT(ct2->y), FIX2FLT(end->x), FIX2FLT(end->y));
    3921. 

  3921. 			last_pt = *end;
    3922. 

  3922. 			if (path->tags[i+2]==GF_PATH_CLOSE) {
    3923. 

  3923. 				strcat(szT, "z");
    3924. 

  3924. 			}
    3925. 

  3925. 			i+=3;
    3926. 

  3926. 			break;
    3927. 

  3927. 		}
    3928. 

  3928. 		if (szT[0]) {
    3929. 

  3929. 			res = gf_realloc(res, sizeof(char)*(strlen(szT)+strlen(res)+1));
    3930. 

  3930. 			strcat(res, szT);
    3931. 

  3931. 		}
    3932. 

  3932. 	}
    3933. 

  3933. 	return res;
    3934. 

  3934. }
    3935. 

  3935. #else
    3936. 

  3936. static void svg_dump_point(SVG_Point *pt, char *attValue)
    3937. 

  3937. {
    3938. 

  3938. 	if (pt) sprintf(attValue, "%g %g ", FIX2FLT(pt->x), FIX2FLT(pt->y) );
    3939. 

  3939. }
    3940. 

  3940. static void svg_dump_path(SVG_PathData *path, char *attValue)
    3941. 

  3941. {
    3942. 

  3942. 	char szT[1000];
    3943. 

  3943. 	u32 i, pt_i, count;
    3944. 

  3944. 	count = gf_list_count(path->commands);
    3945. 

  3945. 	pt_i = 0;
    3946. 

  3946. 	strcpy(attValue, "");
    3947. 

  3947. 	for (i = 0; i < count; i++) {
    3948. 

  3948. 		u8 command = *(u8 *)gf_list_get(path->commands, i);
    3949. 

  3949. 		switch(command) {
    3950. 

  3950. 		case SVG_PATHCOMMAND_M:
    3951. 

  3951. 			strcat(attValue, "M");
    3952. 

  3952. 			svg_dump_point((SVG_Point*)gf_list_get(path->points, pt_i), szT);
    3953. 

  3953. 			strcat(attValue, szT);
    3954. 

  3954. 			pt_i++;
    3955. 

  3955. 			break;
    3956. 

  3956. 		case SVG_PATHCOMMAND_L:
    3957. 

  3957. 			strcat(attValue, "L");
    3958. 

  3958. 			svg_dump_point((SVG_Point*)gf_list_get(path->points, pt_i), szT);
    3959. 

  3959. 			strcat(attValue, szT);
    3960. 

  3960. 			pt_i++;
    3961. 

  3961. 			break;
    3962. 

  3962. 		case SVG_PATHCOMMAND_C:
    3963. 

  3963. 			strcat(attValue, "C");
    3964. 

  3964. 			svg_dump_point((SVG_Point*)gf_list_get(path->points, pt_i), szT);
    3965. 

  3965. 			strcat(attValue, szT);
    3966. 

  3966. 			pt_i++;
    3967. 

  3967. 			svg_dump_point((SVG_Point*)gf_list_get(path->points, pt_i), szT);
    3968. 

  3968. 			strcat(attValue, szT);
    3969. 

  3969. 			pt_i++;
    3970. 

  3970. 			svg_dump_point((SVG_Point*)gf_list_get(path->points, pt_i), szT);
    3971. 

  3971. 			strcat(attValue, szT);
    3972. 

  3972. 			pt_i++;
    3973. 

  3973. 			break;
    3974. 

  3974. 		case SVG_PATHCOMMAND_S:
    3975. 

  3975. 			strcat(attValue, "S");
    3976. 

  3976. 			svg_dump_point((SVG_Point*)gf_list_get(path->points, pt_i), szT);
    3977. 

  3977. 			strcat(attValue, szT);
    3978. 

  3978. 			pt_i++;
    3979. 

  3979. 			svg_dump_point((SVG_Point*)gf_list_get(path->points, pt_i), szT);
    3980. 

  3980. 			strcat(attValue, szT);
    3981. 

  3981. 			pt_i++;
    3982. 

  3982. 			break;
    3983. 

  3983. 		case SVG_PATHCOMMAND_Q:
    3984. 

  3984. 			strcat(attValue, "Q");
    3985. 

  3985. 			svg_dump_point((SVG_Point*)gf_list_get(path->points, pt_i), szT);
    3986. 

  3986. 			strcat(attValue, szT);
    3987. 

  3987. 			pt_i++;
    3988. 

  3988. 			svg_dump_point((SVG_Point*)gf_list_get(path->points, pt_i), szT);
    3989. 

  3989. 			strcat(attValue, szT);
    3990. 

  3990. 			pt_i++;
    3991. 

  3991. 			break;
    3992. 

  3992. 		case SVG_PATHCOMMAND_T:
    3993. 

  3993. 			strcat(attValue, "T");
    3994. 

  3994. 			svg_dump_point((SVG_Point*)gf_list_get(path->points, pt_i), szT);
    3995. 

  3995. 			strcat(attValue, szT);
    3996. 

  3996. 			pt_i++;
    3997. 

  3997. 			break;
    3998. 

  3998. 		case SVG_PATHCOMMAND_A:
    3999. 

  3999. 			strcat(attValue, "A");
    4000. 

  4000. 			svg_dump_point((SVG_Point*)gf_list_get(path->points, pt_i), szT);
    4001. 

  4001. 			strcat(attValue, szT);
    4002. 

  4002. 			pt_i++;
    4003. 

  4003. 			strcat(attValue, "0 0 0 ");
    4004. 

  4004. 			svg_dump_point((SVG_Point*)gf_list_get(path->points, pt_i), szT);
    4005. 

  4005. 			strcat(attValue, szT);
    4006. 

  4006. 			pt_i++;
    4007. 

  4007. 			break;
    4008. 

  4008. 		case SVG_PATHCOMMAND_Z:
    4009. 

  4009. 			strcat(attValue, "Z");
    4010. 

  4010. 			break;
    4011. 

  4011. 		default:
    4012. 

  4012. 			GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("[SVG Dumping] unknown path command %d\n", command));
    4013. 

  4013. 			break;
    4014. 

  4014. 		}
    4015. 

  4015. 	}
    4016. 

  4016. }
    4017. 

  4017. #endif
    4018. 

  4018. 

  4019. static void svg_dump_access_key(XMLEV_Event *evt, char *attValue)
    4020. 

  4020. {
    4021. 

  4021. 	u32 i, count;
    4022. 

  4022. 	strcpy(attValue, "accessKey(");
    4023. 

  4023. 	count = sizeof(predefined_key_identifiers) / sizeof(struct predef_keyid);
    4024. 

  4024. 	for (i=0; i<count; i++) {
    4025. 

  4025. 		if (evt->parameter == predefined_key_identifiers[i].key_code) {
    4026. 

  4026. 			strcat(attValue, predefined_key_identifiers[i].name);
    4027. 

  4027. 			break;
    4028. 

  4028. 		}
    4029. 

  4029. 	}
    4030. 

  4030. 	/* OLD LASeR CODE
    4031. 

  4031. 	switch (evt->parameter) {
    4032. 

  4032. 	case 0: strcat(attValue, "UP"); break;
    4033. 

  4033. 	case 1: strcat(attValue, "DOWN"); break;
    4034. 

  4034. 	case 2: strcat(attValue, "LEFT"); break;
    4035. 

  4035. 	case 3: strcat(attValue, "RIGHT"); break;
    4036. 

  4036. 	case 4: strcat(attValue, "FIRE"); break;
    4037. 

  4037. 	case 5: strcat(attValue, "NO_KEY"); break;
    4038. 

  4038. 	case 6: strcat(attValue, "ANY_KEY"); break;
    4039. 

  4039. 	case 7: strcat(attValue, "SOFT_KEY_1"); break;
    4040. 

  4040. 	case 8: strcat(attValue, "SOFT_KEY_2"); break;
    4041. 

  4041. 	case 35: strcat(attValue, "#"); break;
    4042. 

  4042. 	case 42: strcat(attValue, "*"); break;
    4043. 

  4043. 	case 48: strcat(attValue, "0"); break;
    4044. 

  4044. 	case 49: strcat(attValue, "1"); break;
    4045. 

  4045. 	case 50: strcat(attValue, "2"); break;
    4046. 

  4046. 	case 51: strcat(attValue, "3"); break;
    4047. 

  4047. 	case 52: strcat(attValue, "4"); break;
    4048. 

  4048. 	case 53: strcat(attValue, "5"); break;
    4049. 

  4049. 	case 54: strcat(attValue, "6"); break;
    4050. 

  4050. 	case 55: strcat(attValue, "7"); break;
    4051. 

  4051. 	case 56: strcat(attValue, "8"); break;
    4052. 

  4052. 	case 57: strcat(attValue, "9"); break;
    4053. 

  4053. 	*/
    4054. 

  4054. 	strcat(attValue, ")");
    4055. 

  4055. }
    4056. 

  4056. 

  4057. static char *gf_svg_dump_matrix(GF_Matrix2D *matrix)
    4058. 

  4058. {
    4059. 

  4059. 	char attValue[1024];
    4060. 

  4060. 	attValue[0]=0;
    4061. 

  4061. 	/*try to do a simple decomposition...*/
    4062. 

  4062. 	if (!matrix->m[1] && !matrix->m[3]) {
    4063. 

  4063. 		if (matrix->m[2] != 0 || matrix->m[5] != 0) sprintf(attValue, "translate(%g,%g)", FIX2FLT(matrix->m[2]), FIX2FLT(matrix->m[5]) );
    4064. 

  4064. 		if ((matrix->m[0]!=FIX_ONE) || (matrix->m[4]!=FIX_ONE)) {
    4065. 

  4065. 			char szT[1024];
    4066. 

  4066. 			if ((matrix->m[0]==-FIX_ONE) && (matrix->m[4]==-FIX_ONE)) {
    4067. 

  4067. 				strcpy(szT, " rotate(180)");
    4068. 

  4068. 			} else {
    4069. 

  4069. 				sprintf(szT, " scale(%g,%g)", FIX2FLT(matrix->m[0]), FIX2FLT(matrix->m[4]) );
    4070. 

  4070. 			}
    4071. 

  4071. 			strcat(attValue, szT);
    4072. 

  4072. 		}
    4073. 

  4073. 	} else if (matrix->m[1] == - matrix->m[3]) {
    4074. 

  4074. 		Fixed angle = gf_asin(matrix->m[3]);
    4075. 

  4075. 		Fixed cos_a = gf_cos(angle);
    4076. 

  4076. 		if (ABS(cos_a)>FIX_EPSILON) {
    4077. 

  4077. 			Fixed sx, sy;
    4078. 

  4078. 			sx = gf_divfix(matrix->m[0], cos_a);
    4079. 

  4079. 			sy = gf_divfix(matrix->m[4], cos_a);
    4080. 

  4080. 			angle = gf_divfix(180*angle, GF_PI);
    4081. 

  4081. 			if ((sx==sy) && ( ABS(FIX_ONE - ABS(sx) ) < FIX_ONE/100)) {
    4082. 

  4082. 				if (matrix->m[2] != 0 || matrix->m[5] != 0)
    4083. 

  4083. 					sprintf(attValue, "translate(%g,%g) rotate(%g)", FIX2FLT(matrix->m[2]), FIX2FLT(matrix->m[5]), FIX2FLT(gf_divfix(angle*180, GF_PI) ) );
    4084. 

  4084. 				else
    4085. 

  4085. 					sprintf(attValue, "rotate(%g)", FIX2FLT(gf_divfix(angle*180, GF_PI) ) );
    4086. 

  4086. 			} else {
    4087. 

  4087. 				if (matrix->m[2] != 0 || matrix->m[5] != 0)
    4088. 

  4088. 					sprintf(attValue, "translate(%g,%g) scale(%g,%g) rotate(%g)", FIX2FLT(matrix->m[2]), FIX2FLT(matrix->m[5]), FIX2FLT(sx), FIX2FLT(sy), FIX2FLT(gf_divfix(angle*180, GF_PI) ) );
    4089. 

  4089. 				else
    4090. 

  4090. 					sprintf(attValue, "scale(%g,%g) rotate(%g)", FIX2FLT(sx), FIX2FLT(sy), FIX2FLT(gf_divfix(angle*180, GF_PI) ) );
    4091. 

  4091. 			}
    4092. 

  4092. 		} else {
    4093. 

  4093. 			Fixed a = angle;
    4094. 

  4094. 			if (a<0) a += GF_2PI;
    4095. 

  4095. 			if (matrix->m[2] != 0 || matrix->m[5] != 0)
    4096. 

  4096. 				sprintf(attValue, "translate(%g,%g) rotate(%g)", FIX2FLT(matrix->m[2]), FIX2FLT(matrix->m[5]), FIX2FLT(gf_divfix(a*180, GF_PI) ) );
    4097. 

  4097. 			else
    4098. 

  4098. 				sprintf(attValue, "rotate(%g)", FIX2FLT(gf_divfix(a*180, GF_PI) ) );
    4099. 

  4099. 		}
    4100. 

  4100. 	}
    4101. 

  4101. 	/*default*/
    4102. 

  4102. 	if (!strlen(attValue))
    4103. 

  4103. 		sprintf(attValue, "matrix(%g %g %g %g %g %g)", FIX2FLT(matrix->m[0]), FIX2FLT(matrix->m[3]), FIX2FLT(matrix->m[1]), FIX2FLT(matrix->m[4]), FIX2FLT(matrix->m[2]), FIX2FLT(matrix->m[5]) );
    4104. 

  4104. 

  4105. 	return gf_strdup(attValue);
    4106. 

  4106. }
    4107. 

  4107. 

  4108. char *gf_svg_dump_attribute(GF_Node *elt, GF_FieldInfo *info)
    4109. 

  4109. {
    4110. 

  4110. 	char tmp[1024];
    4111. 

  4111. 	u8 intVal;
    4112. 

  4112. 

  4113. 	if (!info->far_ptr) return gf_strdup("");
    4114. 

  4114. 	intVal = *(u8 *)info->far_ptr;
    4115. 

  4115. 

  4116. 	switch (info->fieldType) {
    4117. 

  4117. 	case SVG_Boolean_datatype:
    4118. 

  4118. 		return gf_strdup( *(SVG_Boolean *)info->far_ptr ? "true" : "false");
    4119. 

  4119. 

  4120. 	case SVG_Color_datatype:
    4121. 

  4121. 		return svg_dump_color((SVG_Color *)info->far_ptr);
    4122. 

  4122. 

  4123. 	case SVG_Paint_datatype:
    4124. 

  4124. 	{
    4125. 

  4125. 		SVG_Paint *paint = (SVG_Paint *)info->far_ptr;
    4126. 

  4126. 		if (paint->type == SVG_PAINT_NONE) return gf_strdup("none");
    4127. 

  4127. 		else if (paint->type == SVG_PAINT_INHERIT) return gf_strdup("inherit");
    4128. 

  4128. 		else if (paint->type == SVG_PAINT_URI) {
    4129. 

  4129. 			char *tmp = svg_dump_iri(&paint->iri);
    4130. 

  4130. 			char *res = gf_malloc(sizeof(char)*(strlen(tmp)+6));
    4131. 

  4131. 			sprintf(res, "url(%s)", tmp);
    4132. 

  4132. 			gf_free(tmp);
    4133. 

  4133. 			return res;
    4134. 

  4134. 		} else {
    4135. 

  4135. 			return svg_dump_color(&paint->color);
    4136. 

  4136. 		}
    4137. 

  4137. 	}
    4138. 

  4138. 		break;
    4139. 

  4139. 

  4140. /* beginning of keyword type parsing */
    4141. 

  4141. 	case SVG_FillRule_datatype:
    4142. 

  4142. 		if (intVal == SVG_FILLRULE_INHERIT) return gf_strdup("inherit");
    4143. 

  4143. 		else if (intVal == SVG_FILLRULE_NONZERO) return gf_strdup("nonzero");
    4144. 

  4144. 		else return gf_strdup("evenodd");
    4145. 

  4145. 		break;
    4146. 

  4146. 

  4147. 	case SVG_StrokeLineJoin_datatype:
    4148. 

  4148. 		if (intVal==SVG_STROKELINEJOIN_INHERIT) return gf_strdup("inherit");
    4149. 

  4149. 		else if (intVal==SVG_STROKELINEJOIN_MITER) return gf_strdup("miter");
    4150. 

  4150. 		else if (intVal==SVG_STROKELINEJOIN_ROUND) return gf_strdup("round");
    4151. 

  4151. 		else if (intVal==SVG_STROKELINEJOIN_BEVEL) return gf_strdup("bevel");
    4152. 

  4152. 		break;
    4153. 

  4153. 	case SVG_StrokeLineCap_datatype:
    4154. 

  4154. 		if (intVal==SVG_STROKELINECAP_INHERIT) return gf_strdup("inherit");
    4155. 

  4155. 		else if (intVal==SVG_STROKELINECAP_BUTT) return gf_strdup("butt");
    4156. 

  4156. 		else if (intVal==SVG_STROKELINECAP_ROUND) return gf_strdup("round");
    4157. 

  4157. 		else if (intVal==SVG_STROKELINECAP_SQUARE) return gf_strdup("square");
    4158. 

  4158. 		break;
    4159. 

  4159. 	case SVG_FontStyle_datatype:
    4160. 

  4160. 		if (intVal==SVG_FONTSTYLE_INHERIT) return gf_strdup("inherit");
    4161. 

  4161. 		else if (intVal==SVG_FONTSTYLE_NORMAL) return gf_strdup("normal");
    4162. 

  4162. 		else if (intVal==SVG_FONTSTYLE_ITALIC) return gf_strdup("italic");
    4163. 

  4163. 		else if (intVal==SVG_FONTSTYLE_OBLIQUE) return gf_strdup("oblique");
    4164. 

  4164. 		break;
    4165. 

  4165. 	case SVG_FontWeight_datatype:
    4166. 

  4166. 		if (intVal==SVG_FONTWEIGHT_INHERIT) return gf_strdup("inherit");
    4167. 

  4167. 		else if (intVal==SVG_FONTWEIGHT_NORMAL) return gf_strdup("normal");
    4168. 

  4168. 		else if (intVal==SVG_FONTWEIGHT_BOLD) return gf_strdup("bold");
    4169. 

  4169. 		else if (intVal==SVG_FONTWEIGHT_BOLDER) return gf_strdup("bolder");
    4170. 

  4170. 		else if (intVal==SVG_FONTWEIGHT_LIGHTER) return gf_strdup("lighter");
    4171. 

  4171. 		else if (intVal==SVG_FONTWEIGHT_100) return gf_strdup("100");
    4172. 

  4172. 		else if (intVal==SVG_FONTWEIGHT_200) return gf_strdup("200");
    4173. 

  4173. 		else if (intVal==SVG_FONTWEIGHT_300) return gf_strdup("300");
    4174. 

  4174. 		else if (intVal==SVG_FONTWEIGHT_400) return gf_strdup("400");
    4175. 

  4175. 		else if (intVal==SVG_FONTWEIGHT_500) return gf_strdup("500");
    4176. 

  4176. 		else if (intVal==SVG_FONTWEIGHT_600) return gf_strdup("600");
    4177. 

  4177. 		else if (intVal==SVG_FONTWEIGHT_700) return gf_strdup("700");
    4178. 

  4178. 		else if (intVal==SVG_FONTWEIGHT_800) return gf_strdup("800");
    4179. 

  4179. 		else if (intVal==SVG_FONTWEIGHT_900) return gf_strdup("900");
    4180. 

  4180. 		break;
    4181. 

  4181. 	case SVG_FontVariant_datatype:
    4182. 

  4182. 		if (intVal==SVG_FONTVARIANT_INHERIT) return gf_strdup("inherit");
    4183. 

  4183. 		else if (intVal==SVG_FONTVARIANT_NORMAL) return gf_strdup("normal");
    4184. 

  4184. 		else if (intVal==SVG_FONTVARIANT_SMALLCAPS) return gf_strdup("small-caps");
    4185. 

  4185. 		break;
    4186. 

  4186. 	case SVG_TextAnchor_datatype:
    4187. 

  4187. 		if (intVal==SVG_TEXTANCHOR_INHERIT) return gf_strdup("inherit");
    4188. 

  4188. 		else if (intVal==SVG_TEXTANCHOR_START) return gf_strdup("start");
    4189. 

  4189. 		else if (intVal==SVG_TEXTANCHOR_MIDDLE) return gf_strdup("middle");
    4190. 

  4190. 		else if (intVal==SVG_TEXTANCHOR_END) return gf_strdup("end");
    4191. 

  4191. 		break;
    4192. 

  4192. 	case SVG_Display_datatype:
    4193. 

  4193. 		if (intVal==SVG_DISPLAY_INHERIT) return gf_strdup("inherit");
    4194. 

  4194. 		else if (intVal==SVG_DISPLAY_NONE) return gf_strdup("none");
    4195. 

  4195. 		else if (intVal==SVG_DISPLAY_INLINE) return gf_strdup("inline");
    4196. 

  4196. 		else if (intVal==SVG_DISPLAY_BLOCK) return gf_strdup("block");
    4197. 

  4197. 		else if (intVal==SVG_DISPLAY_LIST_ITEM) return gf_strdup("list-item");
    4198. 

  4198. 		else if (intVal==SVG_DISPLAY_RUN_IN) return gf_strdup("run-in");
    4199. 

  4199. 		else if (intVal==SVG_DISPLAY_COMPACT) return gf_strdup("compact");
    4200. 

  4200. 		else if (intVal==SVG_DISPLAY_MARKER) return gf_strdup("marker");
    4201. 

  4201. 		else if (intVal==SVG_DISPLAY_TABLE) return gf_strdup("table");
    4202. 

  4202. 		else if (intVal==SVG_DISPLAY_INLINE_TABLE) return gf_strdup("inline-table");
    4203. 

  4203. 		else if (intVal==SVG_DISPLAY_TABLE_ROW_GROUP) return gf_strdup("table-row-group");
    4204. 

  4204. 		else if (intVal==SVG_DISPLAY_TABLE_HEADER_GROUP) return gf_strdup("table-header-group");
    4205. 

  4205. 		else if (intVal==SVG_DISPLAY_TABLE_FOOTER_GROUP) return gf_strdup("table-footer-group");
    4206. 

  4206. 		else if (intVal==SVG_DISPLAY_TABLE_ROW) return gf_strdup("table-row");
    4207. 

  4207. 		else if (intVal==SVG_DISPLAY_TABLE_COLUMN_GROUP) return gf_strdup("table-column-group");
    4208. 

  4208. 		else if (intVal==SVG_DISPLAY_TABLE_COLUMN) return gf_strdup("table-column");
    4209. 

  4209. 		else if (intVal==SVG_DISPLAY_TABLE_CELL) return gf_strdup("table-cell");
    4210. 

  4210. 		else if (intVal==SVG_DISPLAY_TABLE_CAPTION) return gf_strdup("table-caption");
    4211. 

  4211. 		break;
    4212. 

  4212. 	case SVG_Visibility_datatype:
    4213. 

  4213. 		if (intVal==SVG_VISIBILITY_INHERIT) return gf_strdup("inherit");
    4214. 

  4214. 		else if (intVal==SVG_VISIBILITY_VISIBLE) return gf_strdup("visible");
    4215. 

  4215. 		else if (intVal==SVG_VISIBILITY_HIDDEN) return gf_strdup("hidden");
    4216. 

  4216. 		else if (intVal==SVG_VISIBILITY_COLLAPSE) return gf_strdup("collapse");
    4217. 

  4217. 		break;
    4218. 

  4218. 	case SVG_Overflow_datatype:
    4219. 

  4219. 		if (intVal==SVG_OVERFLOW_INHERIT) return gf_strdup("inherit");
    4220. 

  4220. 		else if (intVal==SVG_OVERFLOW_VISIBLE) return gf_strdup("visible");
    4221. 

  4221. 		else if (intVal==SVG_OVERFLOW_HIDDEN) return gf_strdup("hidden");
    4222. 

  4222. 		else if (intVal==SVG_OVERFLOW_SCROLL) return gf_strdup("scroll");
    4223. 

  4223. 		else if (intVal==SVG_OVERFLOW_AUTO) return gf_strdup("auto");
    4224. 

  4224. 		break;
    4225. 

  4225. 	case SVG_ZoomAndPan_datatype:
    4226. 

  4226. 		if (intVal==SVG_ZOOMANDPAN_DISABLE) return gf_strdup("disable");
    4227. 

  4227. 		else return gf_strdup("magnify");
    4228. 

  4228. 		break;
    4229. 

  4229. 	case SVG_DisplayAlign_datatype:
    4230. 

  4230. 		if (intVal==SVG_DISPLAYALIGN_INHERIT) return gf_strdup("inherit");
    4231. 

  4231. 		else if (intVal==SVG_DISPLAYALIGN_AUTO) return gf_strdup("auto");
    4232. 

  4232. 		else if (intVal==SVG_DISPLAYALIGN_BEFORE) return gf_strdup("before");
    4233. 

  4233. 		else if (intVal==SVG_DISPLAYALIGN_CENTER) return gf_strdup("center");
    4234. 

  4234. 		else if (intVal==SVG_DISPLAYALIGN_AFTER) return gf_strdup("after");
    4235. 

  4235. 		break;
    4236. 

  4236. 	case SVG_TextAlign_datatype:
    4237. 

  4237. 		if (intVal==SVG_TEXTALIGN_INHERIT) return gf_strdup("inherit");
    4238. 

  4238. 		else if (intVal==SVG_TEXTALIGN_START) return gf_strdup("start");
    4239. 

  4239. 		else if (intVal==SVG_TEXTALIGN_CENTER) return gf_strdup("center");
    4240. 

  4240. 		else if (intVal==SVG_TEXTALIGN_END) return gf_strdup("end");
    4241. 

  4241. 		break;
    4242. 

  4242. 	case SVG_PointerEvents_datatype:
    4243. 

  4243. 		if (intVal==SVG_POINTEREVENTS_INHERIT) return gf_strdup("inherit");
    4244. 

  4244. 		else if (intVal==SVG_POINTEREVENTS_VISIBLEPAINTED) return gf_strdup("visiblePainted");
    4245. 

  4245. 		else if (intVal==SVG_POINTEREVENTS_VISIBLEFILL) return gf_strdup("visibleFill");
    4246. 

  4246. 		else if (intVal==SVG_POINTEREVENTS_VISIBLESTROKE) return gf_strdup("visibleStroke");
    4247. 

  4247. 		else if (intVal==SVG_POINTEREVENTS_VISIBLE) return gf_strdup("visible");
    4248. 

  4248. 		else if (intVal==SVG_POINTEREVENTS_PAINTED) return gf_strdup("painted");
    4249. 

  4249. 		else if (intVal==SVG_POINTEREVENTS_FILL) return gf_strdup("fill");
    4250. 

  4250. 		else if (intVal==SVG_POINTEREVENTS_STROKE) return gf_strdup("stroke");
    4251. 

  4251. 		else if (intVal==SVG_POINTEREVENTS_ALL) return gf_strdup("all");
    4252. 

  4252. 		else if (intVal==SVG_POINTEREVENTS_NONE) return gf_strdup("none");
    4253. 

  4253. 		else if (intVal==SVG_POINTEREVENTS_BOUNDINGBOX) return gf_strdup("boundingBox");
    4254. 

  4254. 		break;
    4255. 

  4255. 	case SVG_RenderingHint_datatype:
    4256. 

  4256. 		if (intVal==SVG_RENDERINGHINT_INHERIT) return gf_strdup("inherit");
    4257. 

  4257. 		else if (intVal==SVG_RENDERINGHINT_AUTO) return gf_strdup("auto");
    4258. 

  4258. 		else if (intVal==SVG_RENDERINGHINT_OPTIMIZEQUALITY) return gf_strdup("optimizeQuality");
    4259. 

  4259. 		else if (intVal==SVG_RENDERINGHINT_OPTIMIZESPEED) return gf_strdup("optimizeSpeed");
    4260. 

  4260. 		else if (intVal==SVG_RENDERINGHINT_OPTIMIZELEGIBILITY) return gf_strdup("optimizeLegibility");
    4261. 

  4261. 		else if (intVal==SVG_RENDERINGHINT_CRISPEDGES) return gf_strdup("crispEdges");
    4262. 

  4262. 		else if (intVal==SVG_RENDERINGHINT_GEOMETRICPRECISION) return gf_strdup("geometricPrecision");
    4263. 

  4263. 		break;
    4264. 

  4264. 	case SVG_VectorEffect_datatype:
    4265. 

  4265. 		if (intVal==SVG_VECTOREFFECT_INHERIT) return gf_strdup("inherit");
    4266. 

  4266. 		else if (intVal==SVG_VECTOREFFECT_NONE) return gf_strdup("none");
    4267. 

  4267. 		else if (intVal==SVG_VECTOREFFECT_NONSCALINGSTROKE) return gf_strdup("non-scaling-stroke");
    4268. 

  4268. 		break;
    4269. 

  4269. 	case SVG_PlaybackOrder_datatype:
    4270. 

  4270. 		if (intVal== SVG_PLAYBACKORDER_FORWARDONLY) return gf_strdup("forwardOnly");
    4271. 

  4271. 		else if (intVal== SVG_PLAYBACKORDER_ALL) return gf_strdup("all");
    4272. 

  4272. 		break;
    4273. 

  4273. 	case SVG_TimelineBegin_datatype:
    4274. 

  4274. 		if (intVal== SVG_TIMELINEBEGIN_ONSTART) return gf_strdup("onStart");
    4275. 

  4275. 		else if (intVal== SVG_TIMELINEBEGIN_ONLOAD) return gf_strdup("onLoad");
    4276. 

  4276. 		break;
    4277. 

  4277. 	case XML_Space_datatype:
    4278. 

  4278. 		if (intVal==XML_SPACE_DEFAULT) return gf_strdup("default");
    4279. 

  4279. 		else if (intVal==XML_SPACE_PRESERVE) return gf_strdup("preserve");
    4280. 

  4280. 		break;
    4281. 

  4281. 	case XMLEV_Propagate_datatype:
    4282. 

  4282. 		if (intVal==XMLEVENT_PROPAGATE_CONTINUE) return gf_strdup("continue");
    4283. 

  4283. 		else if (intVal==XMLEVENT_PROPAGATE_STOP) return gf_strdup("stop");
    4284. 

  4284. 		break;
    4285. 

  4285. 	case XMLEV_DefaultAction_datatype:
    4286. 

  4286. 		if (intVal==XMLEVENT_DEFAULTACTION_CANCEL) return gf_strdup("cancel");
    4287. 

  4287. 		else if (intVal==XMLEVENT_DEFAULTACTION_PERFORM) return gf_strdup("perform");
    4288. 

  4288. 		break;
    4289. 

  4289. 	case XMLEV_Phase_datatype:
    4290. 

  4290. 		if (intVal==XMLEVENT_PHASE_DEFAULT) return gf_strdup("default");
    4291. 

  4291. 		else if (intVal==XMLEVENT_PHASE_CAPTURE) return gf_strdup("capture");
    4292. 

  4292. 		break;
    4293. 

  4293. 	case SMIL_SyncBehavior_datatype:
    4294. 

  4294. 		if (intVal==SMIL_SYNCBEHAVIOR_INHERIT) return gf_strdup("inherit");
    4295. 

  4295. 		else if (intVal==SMIL_SYNCBEHAVIOR_DEFAULT) return gf_strdup("default");
    4296. 

  4296. 		else if (intVal==SMIL_SYNCBEHAVIOR_LOCKED) return gf_strdup("locked");
    4297. 

  4297. 		else if (intVal==SMIL_SYNCBEHAVIOR_CANSLIP) return gf_strdup("canSlip");
    4298. 

  4298. 		else if (intVal==SMIL_SYNCBEHAVIOR_INDEPENDENT) return gf_strdup("independent");
    4299. 

  4299. 		break;
    4300. 

  4300. 	case SMIL_SyncTolerance_datatype:
    4301. 

  4301. 		if (((SMIL_SyncTolerance*)info->far_ptr)->type==SMIL_SYNCTOLERANCE_INHERIT) return gf_strdup("inherit");
    4302. 

  4302. 		else if (((SMIL_SyncTolerance*)info->far_ptr)->type==SMIL_SYNCTOLERANCE_DEFAULT) return gf_strdup("default");
    4303. 

  4303. 		else if (((SMIL_SyncTolerance*)info->far_ptr)->type==SMIL_SYNCBEHAVIOR_LOCKED) {
    4304. 

  4304. 			sprintf(tmp, "%g", ((SMIL_SyncTolerance*)info->far_ptr)->value);
    4305. 

  4305. 			return gf_strdup(tmp);
    4306. 

  4306. 		}
    4307. 

  4307. 		break;
    4308. 

  4308. 	case SMIL_AttributeType_datatype:
    4309. 

  4309. 		if (intVal==SMIL_ATTRIBUTETYPE_AUTO) return gf_strdup("auto");
    4310. 

  4310. 		else if (intVal==SMIL_ATTRIBUTETYPE_XML) return gf_strdup("XML");
    4311. 

  4311. 		else if (intVal==SMIL_ATTRIBUTETYPE_CSS) return gf_strdup("CSS");
    4312. 

  4312. 		break;
    4313. 

  4313. 	case SMIL_CalcMode_datatype:
    4314. 

  4314. 		if (intVal==SMIL_CALCMODE_DISCRETE) return gf_strdup("discrete");
    4315. 

  4315. 		else if (intVal==SMIL_CALCMODE_LINEAR) return gf_strdup("linear");
    4316. 

  4316. 		else if (intVal==SMIL_CALCMODE_PACED) return gf_strdup("paced");
    4317. 

  4317. 		else if (intVal==SMIL_CALCMODE_SPLINE) return gf_strdup("spline");
    4318. 

  4318. 		break;
    4319. 

  4319. 	case SMIL_Additive_datatype:
    4320. 

  4320. 		if (intVal==SMIL_ADDITIVE_REPLACE) return gf_strdup("replace");
    4321. 

  4321. 		else if (intVal==SMIL_ADDITIVE_SUM) return gf_strdup("sum");
    4322. 

  4322. 		break;
    4323. 

  4323. 	case SMIL_Accumulate_datatype:
    4324. 

  4324. 		if (intVal==SMIL_ACCUMULATE_NONE) return gf_strdup("none");
    4325. 

  4325. 		else if (intVal==SMIL_ACCUMULATE_SUM) return gf_strdup("sum");
    4326. 

  4326. 		break;
    4327. 

  4327. 	case SMIL_Restart_datatype:
    4328. 

  4328. 		if (intVal==SMIL_RESTART_ALWAYS) return gf_strdup("always");
    4329. 

  4329. 		else if (intVal==SMIL_RESTART_WHENNOTACTIVE) return gf_strdup("whenNotActive");
    4330. 

  4330. 		else if (intVal==SMIL_RESTART_NEVER) return gf_strdup("never");
    4331. 

  4331. 		break;
    4332. 

  4332. 	case SMIL_Fill_datatype:
    4333. 

  4333. 		if (intVal==SMIL_FILL_FREEZE) return gf_strdup("freeze");
    4334. 

  4334. 		else if (intVal==SMIL_FILL_REMOVE) return gf_strdup("remove");
    4335. 

  4335. 		break;
    4336. 

  4336. 

  4337. 	case SVG_GradientUnit_datatype:
    4338. 

  4338. 		if (intVal==SVG_GRADIENTUNITS_USER) return gf_strdup("userSpaceOnUse");
    4339. 

  4339. 		else if (intVal==SVG_GRADIENTUNITS_OBJECT) return gf_strdup("objectBoundingBox");
    4340. 

  4340. 		break;
    4341. 

  4341. 	case SVG_InitialVisibility_datatype:
    4342. 

  4342. 		if (intVal==SVG_INITIALVISIBILTY_WHENSTARTED) return gf_strdup("whenStarted");
    4343. 

  4343. 		else if (intVal==SVG_INITIALVISIBILTY_ALWAYS) return gf_strdup("always");
    4344. 

  4344. 		break;
    4345. 

  4345. 	case SVG_FocusHighlight_datatype:
    4346. 

  4346. 		if (intVal==SVG_FOCUSHIGHLIGHT_AUTO) return gf_strdup("auto");
    4347. 

  4347. 		else if (intVal==SVG_FOCUSHIGHLIGHT_NONE) return gf_strdup("none");
    4348. 

  4348. 		break;
    4349. 

  4349. 	case SVG_Overlay_datatype:
    4350. 

  4350. 		if (intVal==SVG_OVERLAY_NONE) return gf_strdup("none");
    4351. 

  4351. 		else if (intVal==SVG_OVERLAY_TOP) return gf_strdup("top");
    4352. 

  4352. 		break;
    4353. 

  4353. 	case SVG_TransformBehavior_datatype:
    4354. 

  4354. 		if (intVal==SVG_TRANSFORMBEHAVIOR_GEOMETRIC) return gf_strdup("geometric");
    4355. 

  4355. 		else if (intVal==SVG_TRANSFORMBEHAVIOR_PINNED) return gf_strdup("pinned");
    4356. 

  4356. 		else if (intVal==SVG_TRANSFORMBEHAVIOR_PINNED90) return gf_strdup("pinned90");
    4357. 

  4357. 		else if (intVal==SVG_TRANSFORMBEHAVIOR_PINNED180) return gf_strdup("pinned180");
    4358. 

  4358. 		else if (intVal==SVG_TRANSFORMBEHAVIOR_PINNED270) return gf_strdup("pinned270");
    4359. 

  4359. 		break;
    4360. 

  4360. 	case SVG_SpreadMethod_datatype:
    4361. 

  4361. 		if (intVal==SVG_SPREAD_REFLECT) return gf_strdup("reflect");
    4362. 

  4362. 		else if (intVal==SVG_SPREAD_REPEAT) return gf_strdup("repeat");
    4363. 

  4363. 		else return gf_strdup("pad");
    4364. 

  4364. 		break;
    4365. 

  4365. 

  4366. 	case SVG_Filter_TransferType_datatype:
    4367. 

  4367. 		if (intVal==SVG_FILTER_TRANSFER_TABLE) return gf_strdup("table");
    4368. 

  4368. 		else if (intVal==SVG_FILTER_TRANSFER_DISCRETE) return gf_strdup("discrete");
    4369. 

  4369. 		else if (intVal==SVG_FILTER_TRANSFER_LINEAR) return gf_strdup("linear");
    4370. 

  4370. 		else if (intVal==SVG_FILTER_TRANSFER_GAMMA) return gf_strdup("gamma");
    4371. 

  4371. 		else return gf_strdup("identity");
    4372. 

  4372. 		break;
    4373. 

  4373. 

  4374. 	case LASeR_Choice_datatype:
    4375. 

  4375. 		if (intVal==LASeR_CHOICE_ALL) return gf_strdup("all");
    4376. 

  4376. 		else if (intVal==LASeR_CHOICE_NONE) return gf_strdup("none");
    4377. 

  4377. 		else if (intVal==LASeR_CHOICE_N) {
    4378. 

  4378. 			sprintf(tmp, "%d", ((LASeR_Choice *)info->far_ptr)->choice_index);
    4379. 

  4379. 			return gf_strdup(tmp);
    4380. 

  4380. 		}
    4381. 

  4381. 		break;
    4382. 

  4382. 	case LASeR_Size_datatype:
    4383. 

  4383. 		sprintf(tmp, "%g %g", FIX2FLT(((LASeR_Size *)info->far_ptr)->width), FIX2FLT(((LASeR_Size *)info->far_ptr)->height));
    4384. 

  4384. 		return gf_strdup(tmp);
    4385. 

  4385. /* end of keyword type parsing */
    4386. 

  4386. 

  4387. 	/* inheritable floats */
    4388. 

  4388. 	case SVG_FontSize_datatype:
    4389. 

  4389. 	case SVG_Length_datatype:
    4390. 

  4390. 	case SVG_Coordinate_datatype:
    4391. 

  4391. 	case SVG_Rotate_datatype:
    4392. 

  4392. 	case SVG_Number_datatype:
    4393. 

  4393. #if DUMP_COORDINATES
    4394. 

  4394. 		return svg_dump_number((SVG_Number *)info->far_ptr);
    4395. 

  4395. #endif
    4396. 

  4396. 

  4397. 	case XMLRI_datatype:
    4398. 

  4398. 		return svg_dump_iri((XMLRI*)info->far_ptr);
    4399. 

  4399. 	case XML_IDREF_datatype:
    4400. 

  4400. 		return svg_dump_idref((XMLRI*)info->far_ptr);
    4401. 

  4401. 	case XMLRI_List_datatype:
    4402. 

  4402. 	{
    4403. 

  4403. 		GF_List *l = *(GF_List **)info->far_ptr;
    4404. 

  4404. 		u32 i, count = gf_list_count(l);
    4405. 

  4405. 		char *attVal = gf_malloc(sizeof(char));
    4406. 

  4406. 		attVal[0] = 0;
    4407. 

  4407. 		for (i=0; i<count; i++) {
    4408. 

  4408. 			u32 len;
    4409. 

  4409. 			char *szT;
    4410. 

  4410. 			XMLRI *iri = (XMLRI *)gf_list_get(l, i);
    4411. 

  4411. 			szT = svg_dump_iri(iri);
    4412. 

  4412. 			len = (u32) strlen(szT);
    4413. 

  4413. 			if (len) {
    4414. 

  4414. 				attVal = gf_realloc(attVal, sizeof(char)*(len+strlen(attVal)+ (i ? 2 : 1) ));
    4415. 

  4415. 				if (i) strcat(attVal, " ");
    4416. 

  4416. 				strcat(attVal, szT);
    4417. 

  4417. 			}
    4418. 

  4418. 			gf_free(szT);
    4419. 

  4419. 		}
    4420. 

  4420. 		return attVal;
    4421. 

  4421. 	}
    4422. 

  4422. 		break;
    4423. 

  4423. 

  4424. 	case SVG_PathData_datatype:
    4425. 

  4425. #if DUMP_COORDINATES
    4426. 

  4426. 		return svg_dump_path((SVG_PathData *)info->far_ptr);
    4427. 

  4427. #endif
    4428. 

  4428. 		break;
    4429. 

  4429. 	case SVG_Points_datatype:
    4430. 

  4430. 	{
    4431. 

  4431. #if DUMP_COORDINATES
    4432. 

  4432. 		GF_List *l = *(GF_List **) info->far_ptr;
    4433. 

  4433. 		u32 i = 0;
    4434. 

  4434. 		u32 count = gf_list_count(l);
    4435. 

  4435. 		char *attVal = gf_malloc(sizeof(char));
    4436. 

  4436. 		attVal[0] = 0;
    4437. 

  4437. 		for (i=0; i<count; i++) {
    4438. 

  4438. 			char szT[200];
    4439. 

  4439. 			SVG_Point *p = (SVG_Point *)gf_list_get(l, i);
    4440. 

  4440. 			sprintf(szT, "%g %g", FIX2FLT(p->x), FIX2FLT(p->y));
    4441. 

  4441. 			attVal = gf_realloc(attVal, sizeof(char)*(strlen(szT)+strlen(attVal)+ (i ? 2 : 1) ));
    4442. 

  4442. 			if (i) strcat(attVal, " ");
    4443. 

  4443. 			strcat(attVal, szT);
    4444. 

  4444. 		}
    4445. 

  4445. 		return attVal;
    4446. 

  4446. #endif
    4447. 

  4447. 	}
    4448. 

  4448. 		break;
    4449. 

  4449. 	case SMIL_KeyTimes_datatype:
    4450. 

  4450. 	case SMIL_KeyPoints_datatype:
    4451. 

  4451. 	case SMIL_KeySplines_datatype:
    4452. 

  4452. 	{
    4453. 

  4453. 		GF_List *l = *(GF_List **) info->far_ptr;
    4454. 

  4454. 		u32 i = 0;
    4455. 

  4455. 		u32 count = gf_list_count(l);
    4456. 

  4456. 		char *attVal = gf_malloc(sizeof(char));
    4457. 

  4457. 		attVal[0] = 0;
    4458. 

  4458. 		for (i=0; i<count; i++) {
    4459. 

  4459. 			char szT[1000];
    4460. 

  4460. 			Fixed *p = (Fixed *)gf_list_get(l, i);
    4461. 

  4461. 			sprintf(szT, "%g", FIX2FLT(*p));
    4462. 

  4462. 			attVal = gf_realloc(attVal, sizeof(char)*(strlen(szT)+strlen(attVal)+ (i ? 2 : 1) ));
    4463. 

  4463. 			if (i) strcat(attVal, " ");
    4464. 

  4464. 			strcat(attVal, szT);
    4465. 

  4465. 		}
    4466. 

  4466. 		return attVal;
    4467. 

  4467. 	}
    4468. 

  4468. 		break;
    4469. 

  4469. 	case SVG_Coordinates_datatype:
    4470. 

  4470. 	{
    4471. 

  4471. #if DUMP_COORDINATES
    4472. 

  4472. 		GF_List *l = *(GF_List **) info->far_ptr;
    4473. 

  4473. 		u32 i = 0;
    4474. 

  4474. 		u32 count = gf_list_count(l);
    4475. 

  4475. 		char *attVal = gf_malloc(sizeof(char));
    4476. 

  4476. 		attVal[0]=0;
    4477. 

  4477. 		for (i=0; i<count; i++) {
    4478. 

  4478. 			char *szT;
    4479. 

  4479. 			SVG_Coordinate *p = (SVG_Coordinate *)gf_list_get(l, i);
    4480. 

  4480. 			szT = svg_dump_number((SVG_Length *)p);
    4481. 

  4481. 			attVal = gf_realloc(attVal, sizeof(char)*(strlen(szT)+strlen(attVal)+ (i ? 2 : 1) ));
    4482. 

  4482. 			if (i) strcat(attVal, " ");
    4483. 

  4483. 			strcat(attVal, szT);
    4484. 

  4484. 			gf_free(szT);
    4485. 

  4485. 		}
    4486. 

  4486. 		return attVal;
    4487. 

  4487. #endif
    4488. 

  4488. 	}
    4489. 

  4489. 		break;
    4490. 

  4490. 	case SVG_ViewBox_datatype:
    4491. 

  4491. 	{
    4492. 

  4492. 		SVG_ViewBox *v = (SVG_ViewBox *)info->far_ptr;
    4493. 

  4493. 		if (v->is_set) {
    4494. 

  4494. 			sprintf(tmp, "%g %g %g %g", FIX2FLT(v->x), FIX2FLT(v->y), FIX2FLT(v->width), FIX2FLT(v->height) );
    4495. 

  4495. 			return gf_strdup(tmp);
    4496. 

  4496. 		} else
    4497. 

  4497. 			return gf_strdup("none");
    4498. 

  4498. 	}
    4499. 

  4499. 		break;
    4500. 

  4500. 	case SVG_StrokeDashArray_datatype:
    4501. 

  4501. 	{
    4502. 

  4502. 		SVG_StrokeDashArray *p = (SVG_StrokeDashArray *)info->far_ptr;
    4503. 

  4503. 		if (p->type==SVG_STROKEDASHARRAY_NONE) return gf_strdup("none");
    4504. 

  4504. 		else if (p->type==SVG_STROKEDASHARRAY_INHERIT) return gf_strdup("inherit");
    4505. 

  4505. 		else if (p->type==SVG_STROKEDASHARRAY_ARRAY) {
    4506. 

  4506. 			u32 i = 0;
    4507. 

  4507. 			char *attVal = gf_malloc(sizeof(char));
    4508. 

  4508. 			attVal[0] = 0;
    4509. 

  4509. 			for (i=0; i<p->array.count; i++) {
    4510. 

  4510. 				char *szT;
    4511. 

  4511.                 SVG_Length l;
    4512. 

  4512.                 l.type = p->array.units[i];
    4513. 

  4513.                 l.value = p->array.vals[i];
    4514. 

  4514. 				szT = svg_dump_number(&l);
    4515. 

  4515. 				attVal = gf_realloc(attVal, sizeof(char)*(strlen(szT)+strlen(attVal)+ (i ? 2 : 1) ));
    4516. 

  4516. 				if (i) strcat(attVal, " ");
    4517. 

  4517. 				strcat(attVal, szT);
    4518. 

  4518. 			}
    4519. 

  4519. 			return attVal;
    4520. 

  4520. 		}
    4521. 

  4521. 	}
    4522. 

  4522. 		break;
    4523. 

  4523. 	case SVG_FontFamily_datatype:
    4524. 

  4524. 	{
    4525. 

  4525. 		SVG_FontFamily *f = (SVG_FontFamily *)info->far_ptr;
    4526. 

  4526. 		return gf_strdup( (f->type==SVG_FONTFAMILY_INHERIT) ? "inherit" : (const char *) f->value);
    4527. 

  4527. 	}
    4528. 

  4528. 

  4529. 	case SVG_PreserveAspectRatio_datatype:
    4530. 

  4530. 	{
    4531. 

  4531. 		SVG_PreserveAspectRatio *par = (SVG_PreserveAspectRatio *)info->far_ptr;
    4532. 

  4532. 		tmp[0] = 0;
    4533. 

  4533. 		if (par->defer) strcat(tmp, "defer ");
    4534. 

  4534. 		if (par->align == SVG_PRESERVEASPECTRATIO_NONE) strcat(tmp, "none");
    4535. 

  4535. 		else if (par->align == SVG_PRESERVEASPECTRATIO_XMINYMIN) strcat(tmp, "xMinYMin");
    4536. 

  4536. 		else if (par->align == SVG_PRESERVEASPECTRATIO_XMIDYMIN) strcat(tmp, "xMidYMin");
    4537. 

  4537. 		else if (par->align == SVG_PRESERVEASPECTRATIO_XMAXYMIN) strcat(tmp, "xMaxYMin");
    4538. 

  4538. 		else if (par->align == SVG_PRESERVEASPECTRATIO_XMINYMID) strcat(tmp, "xMinYMid");
    4539. 

  4539. 		else if (par->align == SVG_PRESERVEASPECTRATIO_XMIDYMID) strcat(tmp, "xMidYMid");
    4540. 

  4540. 		else if (par->align == SVG_PRESERVEASPECTRATIO_XMAXYMID) strcat(tmp, "xMaxYMid");
    4541. 

  4541. 		else if (par->align == SVG_PRESERVEASPECTRATIO_XMINYMAX) strcat(tmp, "xMinYMax");
    4542. 

  4542. 		else if (par->align == SVG_PRESERVEASPECTRATIO_XMIDYMAX) strcat(tmp, "xMidYMax");
    4543. 

  4543. 		else if (par->align == SVG_PRESERVEASPECTRATIO_XMAXYMAX) strcat(tmp, "xMaxYMax");
    4544. 

  4544. 		if (par->meetOrSlice== SVG_MEETORSLICE_SLICE) strcat(tmp, " slice");
    4545. 

  4545. 

  4546. 		return gf_strdup(tmp);
    4547. 

  4547. 	}
    4548. 

  4548. 

  4549. 	case SVG_Clock_datatype:
    4550. 

  4550. 		sprintf(tmp, "%g", * (SVG_Clock *)info->far_ptr );
    4551. 

  4551. 		return gf_strdup(tmp);
    4552. 

  4552. 

  4553. 	case SVG_ID_datatype:
    4554. 

  4554. 	case SVG_LanguageID_datatype:
    4555. 

  4555. 	case SVG_GradientOffset_datatype:
    4556. 

  4556. 	case DOM_String_datatype:
    4557. 

  4557. 	case SVG_ContentType_datatype:
    4558. 

  4558. 		if (*(SVG_String *)info->far_ptr)
    4559. 

  4559. 			return gf_strdup( *(SVG_String *)info->far_ptr );
    4560. 

  4560. 		break;
    4561. 

  4561. 

  4562. 	case SVG_Focus_datatype:
    4563. 

  4563. 	{
    4564. 

  4564. 		SVG_Focus *foc = (SVG_Focus *)info->far_ptr;
    4565. 

  4565. 		if (foc->type==SVG_FOCUS_SELF) return gf_strdup("self");
    4566. 

  4566. 		else if (foc->type==SVG_FOCUS_AUTO) return gf_strdup("auto");
    4567. 

  4567. 		else {
    4568. 

  4568. 			sprintf(tmp, "#%s", foc->target.string);
    4569. 

  4569. 			return gf_strdup(tmp);
    4570. 

  4570. 		}
    4571. 

  4571. 	}
    4572. 

  4572. 		break;
    4573. 

  4573. 	case SVG_Focusable_datatype:
    4574. 

  4574. 	{
    4575. 

  4575. 		SVG_Focusable *f = (SVG_Focusable *)info->far_ptr;
    4576. 

  4576. 		if (*f == SVG_FOCUSABLE_TRUE) return gf_strdup("true");
    4577. 

  4577. 		else if (*f == SVG_FOCUSABLE_FALSE) return gf_strdup("false");
    4578. 

  4578. 		else return gf_strdup("auto");
    4579. 

  4579. 	}
    4580. 

  4580. 

  4581. 	case DOM_StringList_datatype:
    4582. 

  4582. 	{
    4583. 

  4583. 		GF_List *l1 = *(GF_List **) info->far_ptr;
    4584. 

  4584. 		u32 i = 0;
    4585. 

  4585. 		u32 count = gf_list_count(l1);
    4586. 

  4586. 		char *attVal = gf_malloc(sizeof(char));
    4587. 

  4587. 		attVal[0] =  0;
    4588. 

  4588. 		for (i=0; i<count; i++) {
    4589. 

  4589. 			char *p1 = (char *)gf_list_get(l1, i);
    4590. 

  4590. 			attVal = gf_realloc(attVal, sizeof(char)*(strlen(p1)+strlen(attVal)+ (i ? 2 : 1) ));
    4591. 

  4591. 			if (i) strcat(attVal, " ");
    4592. 

  4592. 			strcat(attVal, p1);
    4593. 

  4593. 		}
    4594. 

  4594. 		return attVal;
    4595. 

  4595. 	}
    4596. 

  4596. 

  4597. 	case SVG_Numbers_datatype:
    4598. 

  4598. 	{
    4599. 

  4599. #if DUMP_COORDINATES
    4600. 

  4600. 		GF_List *l1 = *(GF_List **) info->far_ptr;
    4601. 

  4601. 		u32 i = 0;
    4602. 

  4602. 		u32 count = gf_list_count(l1);
    4603. 

  4603. 		char *attVal = gf_malloc(sizeof(char));
    4604. 

  4604. 		attVal[0]=0;
    4605. 

  4605. 		for (i=0; i<count; i++) {
    4606. 

  4606. 			char *szT;
    4607. 

  4607. 			SVG_Number *p = (SVG_Number *)gf_list_get(l1, i);
    4608. 

  4608. 			szT = svg_dump_number(p);
    4609. 

  4609. 			attVal = gf_realloc(attVal, sizeof(char)*(strlen(szT)+strlen(attVal)+ (i ? 2 : 1) ));
    4610. 

  4610. 			if (i) strcat(attVal, " ");
    4611. 

  4611. 			strcat(attVal, szT);
    4612. 

  4612. 			gf_free(szT);
    4613. 

  4613. 		}
    4614. 

  4614. 		return attVal;
    4615. 

  4615. #endif
    4616. 

  4616. 	}
    4617. 

  4617. 		break;
    4618. 

  4618. 

  4619. 	case SVG_Motion_datatype:
    4620. 

  4620. 		{
    4621. 

  4621. #if DUMP_COORDINATES
    4622. 

  4622. 			GF_Matrix2D *m = (GF_Matrix2D *)info->far_ptr;
    4623. 

  4623. 			sprintf(tmp, "%g %g", FIX2FLT(m->m[2]), FIX2FLT(m->m[5]));
    4624. 

  4624. 			return gf_strdup(tmp);
    4625. 

  4625. #endif
    4626. 

  4626. 		}
    4627. 

  4627. 		break;
    4628. 

  4628. 

  4629. 	case SVG_Transform_datatype:
    4630. 

  4630. 		{
    4631. 

  4631. 			SVG_Transform *t= (SVG_Transform *)info->far_ptr;
    4632. 

  4632. 			if (t->is_ref) {
    4633. 

  4633. 				sprintf(tmp, "ref(svg,%g,%g)", FIX2FLT(t->mat.m[2]), FIX2FLT(t->mat.m[5]) );
    4634. 

  4634. 				return gf_strdup(tmp);
    4635. 

  4635. 			} else {
    4636. 

  4636. 				return gf_svg_dump_matrix(&t->mat);
    4637. 

  4637. 			}
    4638. 

  4638. 		}
    4639. 

  4639. 		break;
    4640. 

  4640. 

  4641. 	case SVG_Transform_Translate_datatype:
    4642. 

  4642. 		{
    4643. 

  4643. 			SVG_Point *pt = (SVG_Point *)info->far_ptr;
    4644. 

  4644. #if DUMP_COORDINATES
    4645. 

  4645. 			sprintf(tmp, "%g %g", FIX2FLT(pt->x), FIX2FLT(pt->y) );
    4646. 

  4646. 			return gf_strdup(tmp);
    4647. 

  4647. #endif
    4648. 

  4648. 		}
    4649. 

  4649. 		break;
    4650. 

  4650. 

  4651. 	case SVG_Transform_Scale_datatype:
    4652. 

  4652. 		{
    4653. 

  4653. 			SVG_Point *pt = (SVG_Point *)info->far_ptr;
    4654. 

  4654. #if DUMP_COORDINATES
    4655. 

  4655. 			if (pt->x == pt->y) {
    4656. 

  4656. 				sprintf(tmp, "%g", FIX2FLT(pt->x));
    4657. 

  4657. 			} else {
    4658. 

  4658. 				sprintf(tmp, "%g %g", FIX2FLT(pt->x), FIX2FLT(pt->y) );
    4659. 

  4659. 			}
    4660. 

  4660. 			return gf_strdup(tmp);
    4661. 

  4661. #endif
    4662. 

  4662. 		}
    4663. 

  4663. 		break;
    4664. 

  4664. 

  4665. 	case SVG_Transform_SkewX_datatype:
    4666. 

  4666. 	case SVG_Transform_SkewY_datatype:
    4667. 

  4667. 		{
    4668. 

  4668. 			Fixed *f = (Fixed *)info->far_ptr;
    4669. 

  4669. #if DUMP_COORDINATES
    4670. 

  4670. 			sprintf(tmp, "%g", FIX2FLT( 180 * gf_divfix(*f, GF_PI) ));
    4671. 

  4671. 			return gf_strdup(tmp);
    4672. 

  4672. #endif
    4673. 

  4673. 		}
    4674. 

  4674. 		break;
    4675. 

  4675. 

  4676. 	case SVG_Transform_Rotate_datatype:
    4677. 

  4677. 		{
    4678. 

  4678. 			SVG_Point_Angle *pt = (SVG_Point_Angle *)info->far_ptr;
    4679. 

  4679. #if DUMP_COORDINATES
    4680. 

  4680. 			if (pt->x || pt->y) {
    4681. 

  4681. 				sprintf(tmp, "%g %g %g", FIX2FLT( 180 * gf_divfix(pt->angle, GF_PI) ), FIX2FLT(pt->x), FIX2FLT(pt->y) );
    4682. 

  4682. 			} else {
    4683. 

  4683. 				sprintf(tmp, "%g", FIX2FLT(gf_divfix(180 * pt->angle, GF_PI) ));
    4684. 

  4684. 			}
    4685. 

  4685. 			return gf_strdup(tmp);
    4686. 

  4686. #endif
    4687. 

  4687. 		}
    4688. 

  4688. 		break;
    4689. 

  4689. 

  4690. 	case SMIL_AttributeName_datatype:
    4691. 

  4691. 	{
    4692. 

  4692. 		SMIL_AttributeName *att_name = (SMIL_AttributeName *) info->far_ptr;
    4693. 

  4693. 		if (att_name->name)
    4694. 

  4694. 			return gf_strdup(att_name->name);
    4695. 

  4695. 

  4696. 		if (att_name->tag)
    4697. 

  4697. 			return gf_strdup( gf_svg_get_attribute_name(elt, att_name->tag) );
    4698. 

  4698. 	}
    4699. 

  4699. 		break;
    4700. 

  4700. 

  4701. 	case SMIL_Times_datatype:
    4702. 

  4702. 	{
    4703. 

  4703. 		u32 i, count;
    4704. 

  4704. 		GF_Node *par = gf_node_get_parent((GF_Node *)elt, 0);
    4705. 

  4705. 		GF_List *l = *(GF_List **) info->far_ptr;
    4706. 

  4706. 		char *attVal = gf_malloc(sizeof(char));
    4707. 

  4707. 		attVal[0] = 0;
    4708. 

  4708. 		count = gf_list_count(l);
    4709. 

  4709. 		for (i=0; i<count; i++) {
    4710. 

  4710. 			char szBuf[1000];
    4711. 

  4711. 			SMIL_Time *t = (SMIL_Time *)gf_list_get(l, i);
    4712. 

  4712. 			szBuf[0] = 0;
    4713. 

  4713. 			if (t->type == GF_SMIL_TIME_CLOCK) {
    4714. 

  4714. 				sprintf(szBuf, "%gs", t->clock);
    4715. 

  4715. 			} else if (t->type==GF_SMIL_TIME_INDEFINITE) {
    4716. 

  4716. 				strcpy(szBuf, "indefinite");
    4717. 

  4717. 			} else if (t->type==GF_SMIL_TIME_WALLCLOCK) {
    4718. 

  4718. 				u32 h, m, s;
    4719. 

  4719. 				/*TODO - day month and year*/
    4720. 

  4720. 				h = (u32) t->clock * 3600;
    4721. 

  4721. 				m = (u32) (t->clock * 60 - 60*h);
    4722. 

  4722. 				s = (u32) (t->clock - 3600*h - 60*m);
    4723. 

  4723. 				sprintf(szBuf, "wallclock(%d:%d:%d)", h, m, s);
    4724. 

  4724. 			}
    4725. 

  4725. 			else if (t->type==GF_SMIL_TIME_EVENT) {
    4726. 

  4726. 				if (t->event.type == GF_EVENT_KEYDOWN) {
    4727. 

  4727. 					svg_dump_access_key(&t->event, szBuf);
    4728. 

  4728. 				} else {
    4729. 

  4729. 					if (t->element_id) {
    4730. 

  4730. 						strcpy(szBuf, t->element_id);
    4731. 

  4731. 						strcat(szBuf, ".");
    4732. 

  4732. 					} else if (t->element && (t->element!=par) && gf_node_get_id(t->element) ) {
    4733. 

  4733. 						const char *name = gf_node_get_name(t->element);
    4734. 

  4734. 						if (name) {
    4735. 

  4735. 							strcpy(szBuf, name);
    4736. 

  4736. 						} else {
    4737. 

  4737. 							sprintf(szBuf, "N%d", gf_node_get_id(t->element)-1 );
    4738. 

  4738. 						}
    4739. 

  4739. 						strcat(szBuf, ".");
    4740. 

  4740. 					}
    4741. 

  4741. 					strcat(szBuf, gf_dom_event_get_name(t->event.type));
    4742. 

  4742. 				}
    4743. 

  4743. 				if (t->clock) {
    4744. 

  4744. 					char szCk[40];
    4745. 

  4745. 					sprintf(szCk, "+%gs", t->clock);
    4746. 

  4746. 					strcat(szBuf, szCk);
    4747. 

  4747. 				}
    4748. 

  4748. 			}
    4749. 

  4749. 			if (szBuf[0]) {
    4750. 

  4750. 				attVal = gf_realloc(attVal, sizeof(char)*(strlen(attVal)+strlen(szBuf)+ (i ? 2 : 1) ));
    4751. 

  4751. 				if ( strlen(attVal) ) strcat(attVal, ";");
    4752. 

  4752. 				strcat(attVal, szBuf);
    4753. 

  4753. 			}
    4754. 

  4754. 		}
    4755. 

  4755. 		return attVal;
    4756. 

  4756. 	}
    4757. 

  4757. 		break;
    4758. 

  4758. 	case SMIL_Duration_datatype:
    4759. 

  4759. 	{
    4760. 

  4760. 		SMIL_Duration *dur = (SMIL_Duration *)info->far_ptr;
    4761. 

  4761. 		if (dur->type == SMIL_DURATION_INDEFINITE) return gf_strdup("indefinite");
    4762. 

  4762. 		else if (dur->type == SMIL_DURATION_MEDIA) return gf_strdup("media");
    4763. 

  4763. 		else if (dur->type == SMIL_DURATION_DEFINED) {
    4764. 

  4764. 			sprintf(tmp, "%gs", dur->clock_value);
    4765. 

  4765. 			return gf_strdup(tmp);
    4766. 

  4766. 		} else {
    4767. 

  4767. 			GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("[SVG Dumping] smil duration not assigned\n"));
    4768. 

  4768. 		}
    4769. 

  4769. 	}
    4770. 

  4770. 		break;
    4771. 

  4771. 	case SMIL_RepeatCount_datatype:
    4772. 

  4772. 	{
    4773. 

  4773. 		SMIL_RepeatCount *rep = (SMIL_RepeatCount *)info->far_ptr;
    4774. 

  4774. 		if (rep->type == SMIL_REPEATCOUNT_INDEFINITE) return gf_strdup("indefinite");
    4775. 

  4775. 		else if (rep->type == SMIL_REPEATCOUNT_DEFINED) {
    4776. 

  4776. 			sprintf(tmp, "%g", FIX2FLT(rep->count) );
    4777. 

  4777. 			return gf_strdup(tmp);
    4778. 

  4778. 		}
    4779. 

  4779. 		else {
    4780. 

  4780. 			GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("[SVG Dumping] smil repeat count not assigned\n"));
    4781. 

  4781. 		}
    4782. 

  4782. 	}
    4783. 

  4783. 		break;
    4784. 

  4784. 	case SVG_TransformType_datatype:
    4785. 

  4785. 	{
    4786. 

  4786. 		SVG_TransformType tr = *(SVG_TransformType *)info->far_ptr;
    4787. 

  4787. 		if (tr == SVG_TRANSFORM_MATRIX) return gf_strdup("matrix");
    4788. 

  4788. 		else if (tr == SVG_TRANSFORM_SCALE) return gf_strdup("scale");
    4789. 

  4789. 		else if (tr == SVG_TRANSFORM_ROTATE) return gf_strdup("rotate");
    4790. 

  4790. 		else if (tr == SVG_TRANSFORM_TRANSLATE) return gf_strdup("translate");
    4791. 

  4791. 		else if (tr == SVG_TRANSFORM_SKEWX) return gf_strdup("skewX");
    4792. 

  4792. 		else if (tr == SVG_TRANSFORM_SKEWY) return gf_strdup("skewY");
    4793. 

  4793. 	}
    4794. 

  4794. 		break;
    4795. 

  4795. 

  4796. 	case SMIL_AnimateValue_datatype:
    4797. 

  4797. 	{
    4798. 

  4798. 		GF_FieldInfo a_fi;
    4799. 

  4799. 		SMIL_AnimateValue*av = (SMIL_AnimateValue*)info->far_ptr;
    4800. 

  4800. 		a_fi.fieldIndex = 0;
    4801. 

  4801. 		a_fi.fieldType = av->type;
    4802. 

  4802. 		a_fi.name = info->name;
    4803. 

  4803. 		a_fi.far_ptr = av->value;
    4804. 

  4804. 		return gf_svg_dump_attribute(elt, &a_fi);
    4805. 

  4805. 	}
    4806. 

  4806. 		break;
    4807. 

  4807. 	case SMIL_AnimateValues_datatype:
    4808. 

  4808. 	{
    4809. 

  4809. 		GF_FieldInfo a_fi;
    4810. 

  4810. 		u32 i, count;
    4811. 

  4811. 		SMIL_AnimateValues *av = (SMIL_AnimateValues*)info->far_ptr;
    4812. 

  4812. 		char *attVal = gf_malloc(sizeof(char));
    4813. 

  4813. 		attVal[0] = 0;
    4814. 

  4814. 		if (av->type) {
    4815. 

  4815. 			count = gf_list_count(av->values);
    4816. 

  4816. 			a_fi.fieldIndex = 0;
    4817. 

  4817. 			a_fi.fieldType = av->type;
    4818. 

  4818. 			a_fi.name = info->name;
    4819. 

  4819. 			for (i=0; i<count; i++) {
    4820. 

  4820. 				char *szBuf;
    4821. 

  4821. 				a_fi.far_ptr = gf_list_get(av->values, i);
    4822. 

  4822. 				szBuf = gf_svg_dump_attribute(elt, &a_fi);
    4823. 

  4823. 

  4824. 				attVal = gf_realloc(attVal, sizeof(char)*(strlen(attVal)+strlen(szBuf)+ (i ? 2 : 1) ));
    4825. 

  4825. 				if (i) strcat(attVal, ";");
    4826. 

  4826. 				strcat(attVal, szBuf);
    4827. 

  4827. 				gf_free(szBuf);
    4828. 

  4828. 			}
    4829. 

  4829. 		}
    4830. 

  4830. 		return attVal;
    4831. 

  4831. 	}
    4832. 

  4832. 

  4833. 	case XMLEV_Event_datatype:
    4834. 

  4834. 	{
    4835. 

  4835. 		XMLEV_Event *d = (XMLEV_Event *)info->far_ptr;
    4836. 

  4836. 		if (d->parameter) {
    4837. 

  4837. 			svg_dump_access_key(d, tmp);
    4838. 

  4838. 		} else {
    4839. 

  4839. 			strcpy(tmp, gf_dom_event_get_name(d->type));
    4840. 

  4840. 		}
    4841. 

  4841. 		return gf_strdup(tmp);
    4842. 

  4842. 	}
    4843. 

  4843. 	default:
    4844. 

  4844. 		GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("[SVG Dumping] field %s of type %s not supported\n", info->name, gf_svg_attribute_type_to_string(info->fieldType)));
    4845. 

  4845. 		break;
    4846. 

  4846. 	}
    4847. 

  4847. 	return gf_strdup("");
    4848. 

  4848. }
    4849. 

  4849. 

  4850. char *gf_svg_dump_attribute_indexed(GF_Node *elt, GF_FieldInfo *info)
    4851. 

  4851. {
    4852. 

  4852. 	char tmp[1024];
    4853. 

  4853. 

  4854. 	switch (info->fieldType) {
    4855. 

  4855. 	case SVG_PointerEvents_datatype:
    4856. 

  4856. 		break;
    4857. 

  4857. 	case XMLRI_List_datatype:
    4858. 

  4858. 		return gf_strdup( (char *) info->far_ptr);
    4859. 

  4859. 

  4860. 	case SVG_Points_datatype:
    4861. 

  4861. 	{
    4862. 

  4862. #if DUMP_COORDINATES
    4863. 

  4863. 		SVG_Point *p = (SVG_Point *)info->far_ptr;
    4864. 

  4864. 		sprintf(tmp, "%g %g", FIX2FLT(p->x), FIX2FLT(p->y));
    4865. 

  4865. 		return gf_strdup(tmp);
    4866. 

  4866. #endif
    4867. 

  4867. 	}
    4868. 

  4868. 		break;
    4869. 

  4869. 	case SMIL_KeyPoints_datatype:
    4870. 

  4870. 	case SMIL_KeyTimes_datatype:
    4871. 

  4871. 	case SMIL_KeySplines_datatype:
    4872. 

  4872. 	{
    4873. 

  4873. 		Fixed *p = (Fixed *)info->far_ptr;
    4874. 

  4874. 		sprintf(tmp, "%g", FIX2FLT(*p));
    4875. 

  4875. 		return gf_strdup(tmp);
    4876. 

  4876. 	}
    4877. 

  4877. 		break;
    4878. 

  4878. 	case SVG_Coordinates_datatype:
    4879. 

  4879. #if DUMP_COORDINATES
    4880. 

  4880. 		return svg_dump_number((SVG_Length *) (SVG_Coordinate *)info->far_ptr);
    4881. 

  4881. #endif
    4882. 

  4882. 		break;
    4883. 

  4883. 	case SVG_ViewBox_datatype:
    4884. 

  4884. 	{
    4885. 

  4885. 		Fixed *v = (Fixed *)info->far_ptr;
    4886. 

  4886. 		sprintf(tmp, "%g", FIX2FLT(*v));
    4887. 

  4887. 		return gf_strdup(tmp);
    4888. 

  4888. 	}
    4889. 

  4889. 		break;
    4890. 

  4890. 	case SVG_StrokeDashArray_datatype:
    4891. 

  4891. 	{
    4892. 

  4892.         /*TODO: fix this: should be an SVG_Length*/
    4893. 

  4893. 		Fixed *p = (Fixed *)info->far_ptr;
    4894. 

  4894. 		sprintf(tmp, "%g", FIX2FLT(*p));
    4895. 

  4895. 		return gf_strdup(tmp);
    4896. 

  4896. 	}
    4897. 

  4897. 		break;
    4898. 

  4898. 	case SMIL_Times_datatype:
    4899. 

  4899. 	{
    4900. 

  4900. 		SMIL_Time *t = (SMIL_Time *)info->far_ptr;
    4901. 

  4901. 		if (t->type == GF_SMIL_TIME_CLOCK) {
    4902. 

  4902. 			sprintf(tmp, "%gs", t->clock);
    4903. 

  4903. 		} else if (t->type==GF_SMIL_TIME_INDEFINITE) {
    4904. 

  4904. 			strcpy(tmp, "indefinite");
    4905. 

  4905. 		} else if (t->type==GF_SMIL_TIME_WALLCLOCK) {
    4906. 

  4906. 			u32 h, m, s;
    4907. 

  4907. 			/*TODO - day month and year*/
    4908. 

  4908. 			h = (u32) t->clock * 3600;
    4909. 

  4909. 			m = (u32) (t->clock * 60 - 60*h);
    4910. 

  4910. 			s = (u32) (t->clock - 3600*h - 60*m);
    4911. 

  4911. 			sprintf(tmp, "wallclock(%d:%d:%d)", h, m, s);
    4912. 

  4912. 		}
    4913. 

  4913. 		else if (t->type==GF_SMIL_TIME_EVENT) {
    4914. 

  4914. 			GF_Node *par = gf_node_get_parent((GF_Node *)elt, 0);
    4915. 

  4915. 			if (t->event.type == GF_EVENT_KEYDOWN) {
    4916. 

  4916. 				svg_dump_access_key(&t->event, tmp);
    4917. 

  4917. 			} else {
    4918. 

  4918. 				strcpy(tmp, "");
    4919. 

  4919. 				if (t->element_id) {
    4920. 

  4920. 					strcat(tmp, t->element_id);
    4921. 

  4921. 					strcat(tmp, ".");
    4922. 

  4922. 				} else if (t->element && (t->element!=par) && gf_node_get_id(t->element) ) {
    4923. 

  4923. 					const char *name = gf_node_get_name(t->element);
    4924. 

  4924. 					if (name) {
    4925. 

  4925. 						strcat(tmp, name);
    4926. 

  4926. 					} else {
    4927. 

  4927. 						sprintf(tmp, "N%d", gf_node_get_id(t->element)-1 );
    4928. 

  4928. 					}
    4929. 

  4929. 					strcat(tmp, ".");
    4930. 

  4930. 				}
    4931. 

  4931. 				strcat(tmp, gf_dom_event_get_name(t->event.type));
    4932. 

  4932. 			}
    4933. 

  4933. 			if (t->clock) {
    4934. 

  4934. 				char szBuf[100];
    4935. 

  4935. 				sprintf(szBuf, "+%gs", t->clock);
    4936. 

  4936. 				strcat(tmp, szBuf);
    4937. 

  4937. 			}
    4938. 

  4938. 		}
    4939. 

  4939. 		return gf_strdup(tmp);
    4940. 

  4940. 	}
    4941. 

  4941. 

  4942. 	default:
    4943. 

  4943. 		GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("[SVG Dumping] indexed field %s of type %s not supported\n", info->name, gf_svg_attribute_type_to_string(info->fieldType)));
    4944. 

  4944. 		break;
    4945. 

  4945. 	}
    4946. 

  4946. 	return gf_strdup("");
    4947. 

  4947. }
    4948. 

  4948. 

  4949. static Bool svg_viewbox_equal(SVG_ViewBox *v1, SVG_ViewBox *v2)
    4950. 

  4950. {
    4951. 

  4951. 	if (v1->is_set != v2->is_set) return 0;
    4952. 

  4952. 	if (!v1->is_set)
    4953. 

  4953. 		return 1;
    4954. 

  4954. 	else {
    4955. 

  4955. 		if ( (v1->x == v2->x)  && (v1->y == v2->y) && (v1->width == v2->width) && (v1->height == v2->height) )
    4956. 

  4956. 			return 1;
    4957. 

  4957. 		else
    4958. 

  4958. 			return 0;
    4959. 

  4959. 	}
    4960. 

  4960. }
    4961. 

  4961. 

  4962. static Bool svg_colors_equal(SVG_Color *c1, SVG_Color *c2)
    4963. 

  4963. {
    4964. 

  4964. 	if (c1->type != c2->type) return 0;
    4965. 

  4965. 	if (c1->red != c2->red) return 0;
    4966. 

  4966. 	if (c1->green != c2->green) return 0;
    4967. 

  4967. 	if (c1->blue != c2->blue) return 0;
    4968. 

  4968. 	return 1;
    4969. 

  4969. }
    4970. 

  4970. static Bool svg_numbers_equal(SVG_Length *l1, SVG_Length *l2)
    4971. 

  4971. {
    4972. 

  4972. 	if (l1->type!=l2->type) return 0;
    4973. 

  4973. 	if (l1->type >= SVG_NUMBER_INHERIT) return 1;
    4974. 

  4974. 	return (l1->value==l2->value) ? 1 : 0;
    4975. 

  4975. }
    4976. 

  4976. static Bool svg_iris_equal(XMLRI*iri1, XMLRI*iri2)
    4977. 

  4977. {
    4978. 

  4978. 	u32 type1, type2;
    4979. 

  4979. 	type1 = iri1->type;
    4980. 

  4980. 	type2 = iri2->type;
    4981. 

  4981. 	/*ignore undef hrefs, these are internall ones*/
    4982. 

  4982. 	if ((iri1->type == XMLRI_ELEMENTID) && iri1->target) {
    4983. 

  4983. 		if (!gf_node_get_id((GF_Node *)iri1->target)) type1 = 0;
    4984. 

  4984. 	}
    4985. 

  4985. 	if ((iri2->type == XMLRI_ELEMENTID) && iri2->target) {
    4986. 

  4986. 		if (!gf_node_get_id((GF_Node *)iri2->target)) type2 = 0;
    4987. 

  4987. 	}
    4988. 

  4988. 	if (type1 != type2) return 0;
    4989. 

  4989. 	if ((type1 == XMLRI_ELEMENTID) && (iri1->target == iri2->target) ) return 1;
    4990. 

  4990. 	if (iri1->string && iri2->string && !strcmp(iri1->string, iri2->string)) return 1;
    4991. 

  4991. 	if (!iri1->string && !iri2->string) return 1;
    4992. 

  4992. 	return 0;
    4993. 

  4993. }
    4994. 

  4994. static Bool svg_matrices_equal(GF_Matrix2D *m1, GF_Matrix2D *m2)
    4995. 

  4995. {
    4996. 

  4996. 	if (m1->m[0] != m2->m[0]) return 0;
    4997. 

  4997. 	if (m1->m[1] != m2->m[1]) return 0;
    4998. 

  4998. 	if (m1->m[2] != m2->m[2]) return 0;
    4999. 

  4999. 	if (m1->m[3] != m2->m[3]) return 0;
    5000. 

  5000. 	if (m1->m[4] != m2->m[4]) return 0;
    5001. 

  5001. 	if (m1->m[5] != m2->m[5]) return 0;
    5002. 

  5002. 	return 1;
    5003. 

  5003. }
    5004. 

  5004. 

  5005. Bool gf_svg_attributes_equal(GF_FieldInfo *f1, GF_FieldInfo *f2)
    5006. 

  5006. {
    5007. 

  5007. 	u32 v1, v2;
    5008. 

  5008. 	if (f1->fieldType!=f2->fieldType) return 0;
    5009. 

  5009. 	if (f1->far_ptr && !f2->far_ptr) return 0;
    5010. 

  5010. 	if (f2->far_ptr && !f1->far_ptr) return 0;
    5011. 

  5011. 	if (!f1->far_ptr) return 1;
    5012. 

  5012. 	v1 = *(u8 *)f1->far_ptr;
    5013. 

  5013. 	v2 = *(u8 *)f2->far_ptr;
    5014. 

  5014. 

  5015. 	switch (f1->fieldType) {
    5016. 

  5016. 	case SVG_Boolean_datatype:
    5017. 

  5017. 	case SVG_FillRule_datatype:
    5018. 

  5018. 	case SVG_StrokeLineJoin_datatype:
    5019. 

  5019. 	case SVG_StrokeLineCap_datatype:
    5020. 

  5020. 	case SVG_FontStyle_datatype:
    5021. 

  5021. 	case SVG_FontWeight_datatype:
    5022. 

  5022. 	case SVG_FontVariant_datatype:
    5023. 

  5023. 	case SVG_TextAnchor_datatype:
    5024. 

  5024. 	case SVG_Display_datatype:
    5025. 

  5025. 	case SVG_Visibility_datatype:
    5026. 

  5026. 	case SVG_GradientUnit_datatype:
    5027. 

  5027. 	case SVG_PreserveAspectRatio_datatype:
    5028. 

  5028. 	case XML_Space_datatype:
    5029. 

  5029. 	case XMLEV_Propagate_datatype:
    5030. 

  5030. 	case XMLEV_DefaultAction_datatype:
    5031. 

  5031. 	case XMLEV_Phase_datatype:
    5032. 

  5032. 	case SMIL_SyncBehavior_datatype:
    5033. 

  5033. 	case SMIL_AttributeType_datatype:
    5034. 

  5034. 	case SMIL_CalcMode_datatype:
    5035. 

  5035. 	case SMIL_Additive_datatype:
    5036. 

  5036. 	case SMIL_Accumulate_datatype:
    5037. 

  5037. 	case SMIL_Restart_datatype:
    5038. 

  5038. 	case SMIL_Fill_datatype:
    5039. 

  5039. 	case SVG_Overflow_datatype:
    5040. 

  5040. 	case SVG_ZoomAndPan_datatype:
    5041. 

  5041. 	case SVG_DisplayAlign_datatype:
    5042. 

  5042. 	case SVG_TextAlign_datatype:
    5043. 

  5043. 	case SVG_PointerEvents_datatype:
    5044. 

  5044. 	case SVG_RenderingHint_datatype:
    5045. 

  5045. 	case SVG_VectorEffect_datatype:
    5046. 

  5046. 	case SVG_PlaybackOrder_datatype:
    5047. 

  5047. 	case SVG_TimelineBegin_datatype:
    5048. 

  5048. 	case SVG_FocusHighlight_datatype:
    5049. 

  5049. 	case SVG_TransformType_datatype:
    5050. 

  5050. 	case SVG_Overlay_datatype:
    5051. 

  5051. 	case SVG_TransformBehavior_datatype:
    5052. 

  5052. 	case SVG_SpreadMethod_datatype:
    5053. 

  5053. 	case SVG_InitialVisibility_datatype:
    5054. 

  5054. 	case LASeR_Choice_datatype:
    5055. 

  5055. 		return (v1==v2) ? 1 : 0;
    5056. 

  5056. 	case SVG_Color_datatype:
    5057. 

  5057. 		return svg_colors_equal((SVG_Color *)f1->far_ptr, (SVG_Color *)f2->far_ptr);
    5058. 

  5058. 	case SMIL_SyncTolerance_datatype:
    5059. 

  5059. 	{
    5060. 

  5060. 		SMIL_SyncTolerance *st1 = (SMIL_SyncTolerance*)f1->far_ptr;
    5061. 

  5061. 		SMIL_SyncTolerance *st2 = (SMIL_SyncTolerance*)f2->far_ptr;
    5062. 

  5062. 		if (st1->type!=st2->type) return 0;
    5063. 

  5063. 		if ((st1->type==SMIL_SYNCTOLERANCE_VALUE) && (st1->value!=st2->value)) return 0;
    5064. 

  5064. 		return 1;
    5065. 

  5065. 	}
    5066. 

  5066. 

  5067. 	case SVG_Paint_datatype:
    5068. 

  5068. 	{
    5069. 

  5069. 		SVG_Paint *p1 = (SVG_Paint *)f1->far_ptr;
    5070. 

  5070. 		SVG_Paint *p2 = (SVG_Paint *)f2->far_ptr;
    5071. 

  5071. 		if (p1->type != p2->type) return 0;
    5072. 

  5072. 		if (p1->type==SVG_PAINT_COLOR) return svg_colors_equal(&p1->color, &p2->color);
    5073. 

  5073. 		else if (p1->type==SVG_PAINT_URI) return svg_iris_equal(&p1->iri, &p2->iri);
    5074. 

  5074. 		return 1;
    5075. 

  5075. 	}
    5076. 

  5076. 		break;
    5077. 

  5077. 

  5078. 	case SVG_FontSize_datatype:
    5079. 

  5079. 	case SVG_Length_datatype:
    5080. 

  5080. 	case SVG_Coordinate_datatype:
    5081. 

  5081. 	case SVG_Rotate_datatype:
    5082. 

  5082. 	case SVG_Number_datatype:
    5083. 

  5083. 		return svg_numbers_equal((SVG_Number *)f1->far_ptr, (SVG_Number *)f2->far_ptr);
    5084. 

  5084. 	case XMLRI_datatype:
    5085. 

  5085. 		return svg_iris_equal((XMLRI*)f1->far_ptr, (XMLRI*)f2->far_ptr);
    5086. 

  5086. 	case XMLRI_List_datatype:
    5087. 

  5087. 	{
    5088. 

  5088. 		GF_List *l1 = *(GF_List **)f1->far_ptr;
    5089. 

  5089. 		GF_List *l2 = *(GF_List **)f2->far_ptr;
    5090. 

  5090. 		u32 i, count = gf_list_count(l1);
    5091. 

  5091. 		if (gf_list_count(l2)!=count) return 0;
    5092. 

  5092. 		for (i=0; i<count; i++) {
    5093. 

  5093. 			if (!svg_iris_equal((XMLRI*)gf_list_get(l1, i), (XMLRI*)gf_list_get(l2, i) )) return 0;
    5094. 

  5094. 		}
    5095. 

  5095. 		return 1;
    5096. 

  5096. 	}
    5097. 

  5097. 

  5098. 	case SVG_PathData_datatype:
    5099. 

  5099. 	{
    5100. 

  5100. 		SVG_PathData *d1 = (SVG_PathData *)f1->far_ptr;
    5101. 

  5101. 		SVG_PathData *d2 = (SVG_PathData *)f2->far_ptr;
    5102. 

  5102. 		u32 i;
    5103. 

  5103. 		/*FIXME - be less lazy..*/
    5104. 

  5104. #if USE_GF_PATH
    5105. 

  5105. 		if (d1->n_points != d2->n_points) return 0;
    5106. 

  5106. 		if (d1->n_contours != d2->n_contours) return 0;
    5107. 

  5107. 		for (i=0; i<d1->n_points; i++) {
    5108. 

  5108. 			if (d1->points[i].x != d2->points[i].x) return 0;
    5109. 

  5109. 			if (d1->points[i].y != d2->points[i].y) return 0;
    5110. 

  5110. 		}
    5111. 

  5111. 		for (i=0; i<d1->n_points; i++) {
    5112. 

  5112. 			if (d1->tags[i] != d2->tags[i]) return 0;
    5113. 

  5113. 		}
    5114. 

  5114. 		for (i=0; i<d1->n_contours; i++) {
    5115. 

  5115. 			if (d1->contours[i] != d2->contours[i]) return 0;
    5116. 

  5116. 		}
    5117. 

  5117. 		return 1;
    5118. 

  5118. #else
    5119. 

  5119. 		if (!gf_list_count(d1->commands) && !gf_list_count(d2->commands)) return 1;
    5120. 

  5120. #endif
    5121. 

  5121. 		return 0;
    5122. 

  5122. 	}
    5123. 

  5123. 	case SVG_Points_datatype:
    5124. 

  5124. 	{
    5125. 

  5125. 		GF_List *l1 = *(GF_List **) f1->far_ptr;
    5126. 

  5126. 		GF_List *l2 = *(GF_List **) f2->far_ptr;
    5127. 

  5127. 		u32 i = 0;
    5128. 

  5128. 		u32 count = gf_list_count(l1);
    5129. 

  5129. 		if (gf_list_count(l2)!=count) return 0;
    5130. 

  5130. 		for (i=0; i<count; i++) {
    5131. 

  5131. 			SVG_Point *p1 = (SVG_Point *)gf_list_get(l1, i);
    5132. 

  5132. 			SVG_Point *p2 = (SVG_Point *)gf_list_get(l2, i);
    5133. 

  5133. 			if (p1->x != p2->x) return 0;
    5134. 

  5134. 			if (p1->y != p2->y) return 0;
    5135. 

  5135. 		}
    5136. 

  5136. 		return 1;
    5137. 

  5137. 	}
    5138. 

  5138. 	case SMIL_KeyTimes_datatype:
    5139. 

  5139. 	case SMIL_KeyPoints_datatype:
    5140. 

  5140. 	case SMIL_KeySplines_datatype:
    5141. 

  5141. 	{
    5142. 

  5142. 		GF_List *l1 = *(GF_List **) f1->far_ptr;
    5143. 

  5143. 		GF_List *l2 = *(GF_List **) f2->far_ptr;
    5144. 

  5144. 		u32 i = 0;
    5145. 

  5145. 		u32 count = gf_list_count(l1);
    5146. 

  5146. 		if (gf_list_count(l2)!=count) return 0;
    5147. 

  5147. 		for (i=0; i<count; i++) {
    5148. 

  5148. 			Fixed *p1 = (Fixed *)gf_list_get(l1, i);
    5149. 

  5149. 			Fixed *p2 = (Fixed *)gf_list_get(l2, i);
    5150. 

  5150. 			if (*p1 != *p2) return 0;
    5151. 

  5151. 		}
    5152. 

  5152. 		return 1;
    5153. 

  5153. 	}
    5154. 

  5154. 	case SVG_Coordinates_datatype:
    5155. 

  5155. 	{
    5156. 

  5156. 		GF_List *l1 = *(GF_List **) f1->far_ptr;
    5157. 

  5157. 		GF_List *l2 = *(GF_List **) f2->far_ptr;
    5158. 

  5158. 		u32 i = 0;
    5159. 

  5159. 		u32 count = gf_list_count(l1);
    5160. 

  5160. 		if (gf_list_count(l2) != count) return 0;
    5161. 

  5161. 		for (i=0; i<count; i++) {
    5162. 

  5162. 			SVG_Coordinate *p1 = (SVG_Coordinate *)gf_list_get(l1, i);
    5163. 

  5163. 			SVG_Coordinate *p2 = (SVG_Coordinate *)gf_list_get(l2, i);
    5164. 

  5164. 			if (!svg_numbers_equal(p1, p2)) return 0;
    5165. 

  5165. 		}
    5166. 

  5166. 		return 1;
    5167. 

  5167. 	}
    5168. 

  5168. 	case SVG_ViewBox_datatype:
    5169. 

  5169. 	{
    5170. 

  5170. 		SVG_ViewBox *v1 = (SVG_ViewBox *)f1->far_ptr;
    5171. 

  5171. 		SVG_ViewBox *v2 = (SVG_ViewBox *)f2->far_ptr;
    5172. 

  5172. 		return svg_viewbox_equal(v1, v2);
    5173. 

  5173. 	}
    5174. 

  5174. 	case SVG_StrokeDashArray_datatype:
    5175. 

  5175. 	{
    5176. 

  5176. 		SVG_StrokeDashArray *p1 = (SVG_StrokeDashArray *)f1->far_ptr;
    5177. 

  5177. 		SVG_StrokeDashArray *p2 = (SVG_StrokeDashArray *)f2->far_ptr;
    5178. 

  5178. 		if (p1->type!=p2->type) return 0;
    5179. 

  5179. 		if (p1->type==SVG_STROKEDASHARRAY_ARRAY) {
    5180. 

  5180. 			u32 i = 0;
    5181. 

  5181. 			if (p1->array.count != p2->array.count) return 0;
    5182. 

  5182. 			for (i=0; i<p1->array.count; i++) {
    5183. 

  5183. 				if (p1->array.units[i] != p2->array.units[i]) return 0;
    5184. 

  5184. 				if (p1->array.vals[i] != p2->array.vals[i]) return 0;
    5185. 

  5185. 			}
    5186. 

  5186. 		}
    5187. 

  5187. 		return 1;
    5188. 

  5188. 	}
    5189. 

  5189. 	case SVG_FontFamily_datatype:
    5190. 

  5190. 	{
    5191. 

  5191. 		SVG_FontFamily *ff1 = (SVG_FontFamily *)f1->far_ptr;
    5192. 

  5192. 		SVG_FontFamily *ff2 = (SVG_FontFamily *)f2->far_ptr;
    5193. 

  5193. 		if (ff1->type!=ff2->type) return 0;
    5194. 

  5194. 		if (ff1->type==SVG_FONTFAMILY_INHERIT) return 1;
    5195. 

  5195. 		return (ff1->value && ff2->value && !strcmp(ff1->value, ff2->value)) ? 1 : 0;
    5196. 

  5196. 	}
    5197. 

  5197. 

  5198. 	case SVG_Clock_datatype:
    5199. 

  5199. 		return (* (SVG_Clock *)f1->far_ptr == * (SVG_Clock *)f2->far_ptr) ? 1 : 0;
    5200. 

  5200. 

  5201. 	/* required for animateMotion */
    5202. 

  5202. 	case SVG_Motion_datatype:
    5203. 

  5203. 		return svg_matrices_equal((GF_Matrix2D*)f1->far_ptr, (GF_Matrix2D*)f2->far_ptr);
    5204. 

  5204. 

  5205. 	case SVG_Transform_datatype:
    5206. 

  5206. 		{
    5207. 

  5207. 			SVG_Transform *t1 = (SVG_Transform *)f1->far_ptr;
    5208. 

  5208. 			SVG_Transform *t2 = (SVG_Transform *)f2->far_ptr;
    5209. 

  5209. 			if (t1->is_ref == t2->is_ref)
    5210. 

  5210. 				return svg_matrices_equal(&t1->mat, &t2->mat);
    5211. 

  5211. 			else
    5212. 

  5212. 				return 0;
    5213. 

  5213. 		}
    5214. 

  5214. 

  5215. 	case SVG_Transform_Translate_datatype:
    5216. 

  5216. 	case SVG_Transform_Scale_datatype:
    5217. 

  5217. 		{
    5218. 

  5218. 			SVG_Point *p1 = (SVG_Point *)f1->far_ptr;
    5219. 

  5219. 			SVG_Point *p2 = (SVG_Point *)f2->far_ptr;
    5220. 

  5220. 			if (p1->x != p2->x) return 0;
    5221. 

  5221. 			if (p1->y != p2->y) return 0;
    5222. 

  5222. 			return 1;
    5223. 

  5223. 		}
    5224. 

  5224. 

  5225. 	case SVG_Transform_SkewX_datatype:
    5226. 

  5226. 	case SVG_Transform_SkewY_datatype:
    5227. 

  5227. 		{
    5228. 

  5228. 			Fixed *p1 = (Fixed *)f1->far_ptr;
    5229. 

  5229. 			Fixed *p2 = (Fixed *)f2->far_ptr;
    5230. 

  5230. 			return (*p1 == *p2);
    5231. 

  5231. 		}
    5232. 

  5232. 

  5233. 	case SVG_Transform_Rotate_datatype:
    5234. 

  5234. 		{
    5235. 

  5235. 			SVG_Point_Angle *p1 = (SVG_Point_Angle *)f1->far_ptr;
    5236. 

  5236. 			SVG_Point_Angle *p2 = (SVG_Point_Angle *)f2->far_ptr;
    5237. 

  5237. 			if (p1->x != p2->x) return 0;
    5238. 

  5238. 			if (p1->y != p2->y) return 0;
    5239. 

  5239. 			if (p1->angle != p2->angle) return 0;
    5240. 

  5240. 			return 1;
    5241. 

  5241. 		}
    5242. 

  5242. 

  5243. 

  5244. 	case SVG_ID_datatype:
    5245. 

  5245. 	case SVG_LanguageID_datatype:
    5246. 

  5246. 	case SVG_GradientOffset_datatype:
    5247. 

  5247. 	case DOM_String_datatype:
    5248. 

  5248. 	case SVG_ContentType_datatype:
    5249. 

  5249. 	{
    5250. 

  5250. 		char *str1 = *(SVG_String *)f1->far_ptr;
    5251. 

  5251. 		char *str2 = *(SVG_String *)f2->far_ptr;
    5252. 

  5252. 		if (!str1 && !str2) return 1;
    5253. 

  5253. 		return (str1 && str2 && !strcmp(str1, str2)) ? 1 : 0;
    5254. 

  5254. 	}
    5255. 

  5255. 

  5256. 	case SVG_Focus_datatype:
    5257. 

  5257. 	{
    5258. 

  5258. 		SVG_Focus *foc1 = (SVG_Focus *) f1->far_ptr;
    5259. 

  5259. 		SVG_Focus *foc2 = (SVG_Focus *)f2->far_ptr;
    5260. 

  5260. 		if (foc1->type!=foc2->type) return 0;
    5261. 

  5261. 		if (foc1->type != SVG_FOCUS_IRI) return 1;
    5262. 

  5262. 		return (foc1->target.string && foc2->target.string && !strcmp(foc1->target.string, foc2->target.string)) ? 1 : 0;
    5263. 

  5263. 	}
    5264. 

  5264. 		break;
    5265. 

  5265. 

  5266. 	case DOM_StringList_datatype:
    5267. 

  5267. 	{
    5268. 

  5268. 		GF_List *l1 = *(GF_List **) f1->far_ptr;
    5269. 

  5269. 		GF_List *l2 = *(GF_List **) f2->far_ptr;
    5270. 

  5270. 		u32 i = 0;
    5271. 

  5271. 		u32 count = gf_list_count(l1);
    5272. 

  5272. 		if (gf_list_count(l2) != count) return 0;
    5273. 

  5273. 		for (i=0; i<count; i++) {
    5274. 

  5274. 			char *p1 = (char *)gf_list_get(l1, i);
    5275. 

  5275. 			char *p2 = (char *)gf_list_get(l2, i);
    5276. 

  5276. 			if (strcmp(p1, p2)) return 0;
    5277. 

  5277. 		}
    5278. 

  5278. 		return 1;
    5279. 

  5279. 	}
    5280. 

  5280. 	case SVG_Numbers_datatype:
    5281. 

  5281. 	{
    5282. 

  5282. 		GF_List *l1 = *(GF_List **) f1->far_ptr;
    5283. 

  5283. 		GF_List *l2 = *(GF_List **) f2->far_ptr;
    5284. 

  5284. 		u32 i = 0;
    5285. 

  5285. 		u32 count = gf_list_count(l1);
    5286. 

  5286. 		if (gf_list_count(l2) != count) return 0;
    5287. 

  5287. 		for (i=0; i<count; i++) {
    5288. 

  5288. 			SVG_Number *p1 = (SVG_Number *)gf_list_get(l1, i);
    5289. 

  5289. 			SVG_Number *p2 = (SVG_Number *)gf_list_get(l2, i);
    5290. 

  5290. 			if (!svg_numbers_equal(p1, p2)) return 0;
    5291. 

  5291. 		}
    5292. 

  5292. 		return 1;
    5293. 

  5293. 	}
    5294. 

  5294. 	case SMIL_Times_datatype:
    5295. 

  5295. 	{
    5296. 

  5296. 		GF_List *l1 = *(GF_List **) f1->far_ptr;
    5297. 

  5297. 		GF_List *l2 = *(GF_List **) f2->far_ptr;
    5298. 

  5298. 		u32 i = 0;
    5299. 

  5299. 		u32 count = gf_list_count(l1);
    5300. 

  5300. 		if (gf_list_count(l2) != count) return 0;
    5301. 

  5301. 		for (i=0; i<count; i++) {
    5302. 

  5302. 			SMIL_Time *p1 = (SMIL_Time *)gf_list_get(l1, i);
    5303. 

  5303. 			SMIL_Time *p2 = (SMIL_Time *)gf_list_get(l2, i);
    5304. 

  5304. 			if (p1->type != p2->type) return 0;
    5305. 

  5305. 			if (p1->clock != p2->clock) return 0;
    5306. 

  5306. 			if (p1->type==GF_SMIL_TIME_EVENT) {
    5307. 

  5307. 				if (p1->event.type != p2->event.type) return 0;
    5308. 

  5308. 				if (p1->event.parameter != p2->event.parameter) return 0;
    5309. 

  5309. 			}
    5310. 

  5310. 		}
    5311. 

  5311. 		return 1;
    5312. 

  5312. 	}
    5313. 

  5313. 	case SMIL_Duration_datatype:
    5314. 

  5314. 	{
    5315. 

  5315. 		SMIL_Duration *d1 = (SMIL_Duration *)f1->far_ptr;
    5316. 

  5316. 		SMIL_Duration *d2 = (SMIL_Duration *)f2->far_ptr;
    5317. 

  5317. 		if (d1->type != d2->type) return 0;
    5318. 

  5318. 		if (d1->clock_value != d2->clock_value) return 0;
    5319. 

  5319. 		return 1;
    5320. 

  5320. 	}
    5321. 

  5321. 	case SMIL_RepeatCount_datatype:
    5322. 

  5322. 	{
    5323. 

  5323. 		SMIL_RepeatCount *d1 = (SMIL_RepeatCount *)f1->far_ptr;
    5324. 

  5324. 		SMIL_RepeatCount *d2 = (SMIL_RepeatCount *)f2->far_ptr;
    5325. 

  5325. 		if (d1->type != d2->type) return 0;
    5326. 

  5326. 		if (d1->count != d2->count) return 0;
    5327. 

  5327. 		return 1;
    5328. 

  5328. 	}
    5329. 

  5329. 

  5330. 	case SMIL_AttributeName_datatype:
    5331. 

  5331. 	{
    5332. 

  5332. 		SMIL_AttributeName *att1 = (SMIL_AttributeName *) f1->far_ptr;
    5333. 

  5333. 		SMIL_AttributeName *att2 = (SMIL_AttributeName *) f2->far_ptr;
    5334. 

  5334. 		/*TODO check me...*/
    5335. 

  5335. 		if (att2->field_ptr == att1->field_ptr) return 1;
    5336. 

  5336. 		return 0;
    5337. 

  5337. 	}
    5338. 

  5338. 

  5339. 	case SMIL_AnimateValue_datatype:
    5340. 

  5340. 	{
    5341. 

  5341. 		SMIL_AnimateValue *av1 = (SMIL_AnimateValue*)f1->far_ptr;
    5342. 

  5342. 		SMIL_AnimateValue *av2 = (SMIL_AnimateValue*)f2->far_ptr;
    5343. 

  5343. 		if (av1->value != av2->value) return 0;
    5344. 

  5344. 		return 1;
    5345. 

  5345. 	}
    5346. 

  5346. 		break;
    5347. 

  5347. 

  5348. 	case SMIL_AnimateValues_datatype:
    5349. 

  5349. 	{
    5350. 

  5350. 		u32 count;
    5351. 

  5351. 		SMIL_AnimateValues *av1 = (SMIL_AnimateValues*)f1->far_ptr;
    5352. 

  5352. 		SMIL_AnimateValues *av2 = (SMIL_AnimateValues*)f2->far_ptr;
    5353. 

  5353. 		if (av1->type != av2->type) return 0;
    5354. 

  5354. 		if ( (count = gf_list_count(av1->values) ) != gf_list_count(av1->values)) return 0;
    5355. 

  5355. 		return count ? 0 : 1;
    5356. 

  5356. 	}
    5357. 

  5357. 	case XMLEV_Event_datatype:
    5358. 

  5358. 	{
    5359. 

  5359. 		XMLEV_Event *d1 = (XMLEV_Event *)f1->far_ptr;
    5360. 

  5360. 		XMLEV_Event *d2 = (XMLEV_Event *)f2->far_ptr;
    5361. 

  5361. 		if (d1->type != d2->type) return 0;
    5362. 

  5362. 		if (d1->parameter != d2->parameter) return 0;
    5363. 

  5363. 		return 1;
    5364. 

  5364. 	}
    5365. 

  5365. 	case LASeR_Size_datatype:
    5366. 

  5366. 	{
    5367. 

  5367. 		LASeR_Size *sz1 = (LASeR_Size *)f1->far_ptr;
    5368. 

  5368. 		LASeR_Size *sz2 = (LASeR_Size *)f2->far_ptr;
    5369. 

  5369. 		if (sz1->width != sz2->width) return 0;
    5370. 

  5370. 		if (sz1->height != sz2->height) return 0;
    5371. 

  5371. 		return 1;
    5372. 

  5372. 	}
    5373. 

  5373. 	default:
    5374. 

  5374. 		GF_LOG(GF_LOG_WARNING, GF_LOG_INTERACT, ("[SVG Attributes] comparaison for field %s of type %s not supported\n", f1->name, gf_svg_attribute_type_to_string(f1->fieldType)));
    5375. 

  5375. 		return 0;
    5376. 

  5376. 	}
    5377. 

  5377. }
    5378. 

  5378. 

  5379. static void svg_color_clamp(SVG_Color *a)
    5380. 

  5380. {
    5381. 

  5381. 	a->red   = MAX(0, MIN(FIX_ONE, a->red));
    5382. 

  5382. 	a->green = MAX(0, MIN(FIX_ONE, a->green));
    5383. 

  5383. 	a->blue  = MAX(0, MIN(FIX_ONE, a->blue));
    5384. 

  5384. }
    5385. 

  5385. 

  5386. static GF_Err svg_color_muladd(Fixed alpha, SVG_Color *a, Fixed beta, SVG_Color *b, SVG_Color *c, Bool clamp)
    5387. 

  5387. {
    5388. 

  5388. 	if (a->type != SVG_COLOR_RGBCOLOR || b->type != SVG_COLOR_RGBCOLOR) {
    5389. 

  5389. 		GF_LOG(GF_LOG_ERROR, GF_LOG_INTERACT, ("[SVG Attributes] only RGB colors are additive\n"));
    5390. 

  5390. 		return GF_BAD_PARAM;
    5391. 

  5391. 	}
    5392. 

  5392. 	c->type = SVG_COLOR_RGBCOLOR;
    5393. 

  5393. 	c->red	 = gf_mulfix(alpha, a->red) + gf_mulfix(beta, b->red);
    5394. 

  5394. 	c->green = gf_mulfix(alpha, a->green) + gf_mulfix(beta, b->green);
    5395. 

  5395. 	c->blue  = gf_mulfix(alpha, a->blue) + gf_mulfix(beta, b->blue);
    5396. 

  5396. 	if (clamp) svg_color_clamp(c);
    5397. 

  5397. 	return GF_OK;
    5398. 

  5398. }
    5399. 

  5399. 

  5400. static GF_Err svg_number_muladd(Fixed alpha, SVG_Number *a, Fixed beta, SVG_Number *b, SVG_Number *c)
    5401. 

  5401. {
    5402. 

  5402. 	if (a->type != b->type) {
    5403. 

  5403. 		GF_LOG(GF_LOG_ERROR, GF_LOG_INTERACT, ("[SVG Attributes] cannot add lengths of mismatching types\n"));
    5404. 

  5404. 		return GF_BAD_PARAM;
    5405. 

  5405. 	}
    5406. 

  5406. 	if (a->type == SVG_NUMBER_INHERIT || a->type == SVG_NUMBER_AUTO) {
    5407. 

  5407. 		GF_LOG(GF_LOG_ERROR, GF_LOG_INTERACT, ("[SVG Attributes] cannot add lengths\n"));
    5408. 

  5408. 		return GF_BAD_PARAM;
    5409. 

  5409. 	}
    5410. 

  5410. 	c->value = gf_mulfix(alpha, a->value) + gf_mulfix(beta, b->value);
    5411. 

  5411. 	return GF_OK;
    5412. 

  5412. }
    5413. 

  5413. 

  5414. static GF_Err svg_viewbox_muladd(Fixed alpha, SVG_ViewBox *a, Fixed beta, SVG_ViewBox *b, SVG_ViewBox *c)
    5415. 

  5415. {
    5416. 

  5416. 	c->is_set = 1;
    5417. 

  5417. 	c->x = gf_mulfix(alpha, a->x) + gf_mulfix(beta, b->x);
    5418. 

  5418. 	c->y = gf_mulfix(alpha, a->y) + gf_mulfix(beta, b->y);
    5419. 

  5419. 	c->width = gf_mulfix(alpha, a->width) + gf_mulfix(beta, b->width);
    5420. 

  5420. 	c->height= gf_mulfix(alpha, a->height) + gf_mulfix(beta, b->height);
    5421. 

  5421. 	return GF_OK;
    5422. 

  5422. }
    5423. 

  5423. 

  5424. static GF_Err svg_point_muladd(Fixed alpha, SVG_Point *pta, Fixed beta, SVG_Point *ptb, SVG_Point *ptc)
    5425. 

  5425. {
    5426. 

  5426. 	ptc->x = gf_mulfix(alpha, pta->x) + gf_mulfix(beta, ptb->x);
    5427. 

  5427. 	ptc->y = gf_mulfix(alpha, pta->y) + gf_mulfix(beta, ptb->y);
    5428. 

  5428. 	return GF_OK;
    5429. 

  5429. }
    5430. 

  5430. 

  5431. static GF_Err svg_point_angle_muladd(Fixed alpha, SVG_Point_Angle *pta, Fixed beta, SVG_Point_Angle *ptb, SVG_Point_Angle *ptc)
    5432. 

  5432. {
    5433. 

  5433. 	ptc->x = gf_mulfix(alpha, pta->x) + gf_mulfix(beta, ptb->x);
    5434. 

  5434. 	ptc->y = gf_mulfix(alpha, pta->y) + gf_mulfix(beta, ptb->y);
    5435. 

  5435. 	ptc->angle = gf_mulfix(alpha, pta->angle) + gf_mulfix(beta, ptb->angle);
    5436. 

  5436. 	return GF_OK;
    5437. 

  5437. }
    5438. 

  5438. 

  5439. static GF_Err svg_points_muladd(Fixed alpha, SVG_Points *a, Fixed beta, SVG_Points *b, SVG_Points *c)
    5440. 

  5440. {
    5441. 

  5441. 	u32 a_count = gf_list_count(*a);
    5442. 

  5442. 	u32 i;
    5443. 

  5443. 

  5444. 	if (a_count != gf_list_count(*b)) return GF_BAD_PARAM;
    5445. 

  5445. 

  5446. 	while (gf_list_count(*c)) {
    5447. 

  5447. 		SVG_Point *ptc = (SVG_Point *)gf_list_get(*c, 0);
    5448. 

  5448. 		gf_list_rem(*c, 0);
    5449. 

  5449. 		gf_free(ptc);
    5450. 

  5450. 	}
    5451. 

  5451. 	for (i = 0; i < a_count; i ++) {
    5452. 

  5452. 		SVG_Point *ptc;
    5453. 

  5453. 		SVG_Point *pta = (SVG_Point *)gf_list_get(*a, i);
    5454. 

  5454. 		SVG_Point *ptb = (SVG_Point *)gf_list_get(*b, i);
    5455. 

  5455. 		GF_SAFEALLOC(ptc, SVG_Point)
    5456. 

  5456. 		svg_point_muladd(alpha, pta, beta, ptb, ptc);
    5457. 

  5457. 		gf_list_add(*c, ptc);
    5458. 

  5458. 	}
    5459. 

  5459. 

  5460. 	return GF_OK;
    5461. 

  5461. }
    5462. 

  5462. 

  5463. static GF_Err svg_points_copy(SVG_Points *a, SVG_Points *b)
    5464. 

  5464. {
    5465. 

  5465. 	u32 i, count;
    5466. 

  5466. 

  5467. 	count = gf_list_count(*a);
    5468. 

  5468. 	for (i = 0; i < count; i++) {
    5469. 

  5469. 		SVG_Point *pt = (SVG_Point *)gf_list_get(*a, i);
    5470. 

  5470. 		gf_free(pt);
    5471. 

  5471. 	}
    5472. 

  5472. 	gf_list_reset(*a);
    5473. 

  5473. 

  5474. 	count = gf_list_count(*b);
    5475. 

  5475. 	for (i = 0; i < count; i ++) {
    5476. 

  5476. 		SVG_Point *ptb = (SVG_Point *)gf_list_get(*b, i);
    5477. 

  5477. 		SVG_Point *pta;
    5478. 

  5478. 		GF_SAFEALLOC(pta, SVG_Point)
    5479. 

  5479. 		*pta = *ptb;
    5480. 

  5480. 		gf_list_add(*a, pta);
    5481. 

  5481. 	}
    5482. 

  5482. 	return GF_OK;
    5483. 

  5483. 

  5484. }
    5485. 

  5485. 

  5486. static GF_Err svg_numbers_muladd(Fixed alpha, SVG_Numbers *a, Fixed beta, SVG_Numbers *b, SVG_Numbers *c)
    5487. 

  5487. {
    5488. 

  5488. 	u32 a_count = gf_list_count(*a);
    5489. 

  5489. 	u32 i;
    5490. 

  5490. 

  5491. 	if (a_count != gf_list_count(*b)) return GF_BAD_PARAM;
    5492. 

  5492. 

  5493. 	gf_list_reset(*c);
    5494. 

  5494. 	for (i = 0; i < a_count; i ++) {
    5495. 

  5495. 		SVG_Number *nc;
    5496. 

  5496. 		SVG_Number *na = (SVG_Number *)gf_list_get(*a, i);
    5497. 

  5497. 		SVG_Number *nb = (SVG_Number *)gf_list_get(*b, i);
    5498. 

  5498. 		GF_SAFEALLOC(nc, SVG_Number)
    5499. 

  5499. 		svg_number_muladd(alpha, na, beta, nb, nc);
    5500. 

  5500. 		gf_list_add(*c, nc);
    5501. 

  5501. 	}
    5502. 

  5502. 	return GF_OK;
    5503. 

  5503. }
    5504. 

  5504. 

  5505. static GF_Err svg_numbers_copy(SVG_Numbers *a, SVG_Numbers *b)
    5506. 

  5506. {
    5507. 

  5507. 	u32 i, count;
    5508. 

  5508. 

  5509. 	count = gf_list_count(*a);
    5510. 

  5510. 	for (i = 0; i < count; i++) {
    5511. 

  5511. 		SVG_Coordinate *c = (SVG_Coordinate *)gf_list_get(*a, i);
    5512. 

  5512. 		gf_free(c);
    5513. 

  5513. 	}
    5514. 

  5514. 	gf_list_reset(*a);
    5515. 

  5515. 

  5516. 	count = gf_list_count(*b);
    5517. 

  5517. 	for (i = 0; i < count; i ++) {
    5518. 

  5518. 		SVG_Number *na;
    5519. 

  5519. 		GF_SAFEALLOC(na, SVG_Number)
    5520. 

  5520. 		*na = *(SVG_Number *)gf_list_get(*b, i);
    5521. 

  5521. 		gf_list_add(*a, na);
    5522. 

  5522. 	}
    5523. 

  5523. 	return GF_OK;
    5524. 

  5524. }
    5525. 

  5525. 

  5526. #if USE_GF_PATH
    5527. 

  5527. static GF_Err svg_path_copy(SVG_PathData *a, SVG_PathData *b)
    5528. 

  5528. {
    5529. 

  5529. 	if (a->contours) gf_free(a->contours);
    5530. 

  5530. 	if (a->points) gf_free(a->points);
    5531. 

  5531. 	if (a->tags) gf_free(a->tags);
    5532. 

  5532. 

  5533. 	a->contours = (u32 *)gf_malloc(sizeof(u32)*b->n_contours);
    5534. 

  5534. 	a->points = (GF_Point2D *) gf_malloc(sizeof(GF_Point2D)*b->n_points);
    5535. 

  5535. 	a->tags = (u8 *) gf_malloc(sizeof(u8)*b->n_points);
    5536. 

  5536. 	memcpy(a->contours, b->contours, sizeof(u32)*b->n_contours);
    5537. 

  5537. 	a->n_contours = b->n_contours;
    5538. 

  5538. 	memcpy(a->points, b->points, sizeof(GF_Point2D)*b->n_points);
    5539. 

  5539. 	memcpy(a->tags, b->tags, sizeof(u8)*b->n_points);
    5540. 

  5540. 	a->n_alloc_points = a->n_points = b->n_points;
    5541. 

  5541. 	a->flags = b->flags;
    5542. 

  5542. 	a->bbox = b->bbox;
    5543. 

  5543. 	a->fineness = b->fineness;
    5544. 

  5544. 	return GF_OK;
    5545. 

  5545. }
    5546. 

  5546. #else
    5547. 

  5547. static GF_Err svg_path_copy(SVG_PathData *a, SVG_PathData *b)
    5548. 

  5548. {
    5549. 

  5549. 	u32 i, count;
    5550. 

  5550. 	count = gf_list_count(a->commands);
    5551. 

  5551. 	for (i = 0; i < count; i++) {
    5552. 

  5552. 		u8 *command = (u8 *)gf_list_get(a->commands, i);
    5553. 

  5553. 		gf_free(command);
    5554. 

  5554. 	}
    5555. 

  5555. 	gf_list_reset(a->commands);
    5556. 

  5556. 	count = gf_list_count(a->points);
    5557. 

  5557. 	for (i = 0; i < count; i++) {
    5558. 

  5558. 		SVG_Point *pt = (SVG_Point *)gf_list_get(a->points, i);
    5559. 

  5559. 		gf_free(pt);
    5560. 

  5560. 	}
    5561. 

  5561. 	gf_list_reset(a->points);
    5562. 

  5562. 

  5563. 	count = gf_list_count(b->commands);
    5564. 

  5564. 	for (i = 0; i < count; i ++) {
    5565. 

  5565. 		u8 *nc = (u8 *)gf_malloc(sizeof(u8));
    5566. 

  5566. 		*nc = *(u8*)gf_list_get(b->commands, i);
    5567. 

  5567. 		gf_list_add(a->commands, nc);
    5568. 

  5568. 	}
    5569. 

  5569. 	count = gf_list_count(b->points);
    5570. 

  5570. 	for (i = 0; i < count; i ++) {
    5571. 

  5571. 		SVG_Point *pta;
    5572. 

  5572. 		GF_SAFEALLOC(pta, SVG_Point)
    5573. 

  5573. 		*pta = *(SVG_Point *)gf_list_get(b->points, i);
    5574. 

  5574. 		gf_list_add(a->points, pta);
    5575. 

  5575. 	}
    5576. 

  5576. 	return GF_OK;
    5577. 

  5577. }
    5578. 

  5578. #endif
    5579. 

  5579. 

  5580. #if USE_GF_PATH
    5581. 

  5581. static GF_Err svg_path_muladd(Fixed alpha, SVG_PathData *a, Fixed beta, SVG_PathData *b, SVG_PathData *c)
    5582. 

  5582. {
    5583. 

  5583. 	u32 i;
    5584. 

  5584. 

  5585. 	if (a->n_points != b->n_points) return GF_BAD_PARAM;
    5586. 

  5586. 	gf_path_reset(c);
    5587. 

  5587. 	svg_path_copy(c, a);
    5588. 

  5588. 

  5589. 	for (i=0; i<a->n_points; i++) {
    5590. 

  5590. 		svg_point_muladd(alpha, (SVG_Point *) &a->points[i], beta, (SVG_Point *) &b->points[i], (SVG_Point *) &c->points[i]);
    5591. 

  5591. 	}
    5592. 

  5592. 	c->flags |= GF_PATH_BBOX_DIRTY;
    5593. 

  5593. 	c->flags &= ~GF_PATH_FLATTENED;
    5594. 

  5594. 	return GF_OK;
    5595. 

  5595. }
    5596. 

  5596. #else
    5597. 

  5597. static GF_Err svg_path_muladd(Fixed alpha, SVG_PathData *a, Fixed beta, SVG_PathData *b, SVG_PathData *c)
    5598. 

  5598. {
    5599. 

  5599. 	u32 i, ccount, pcount;
    5600. 

  5600. 

  5601. 	ccount = gf_list_count(a->commands);
    5602. 

  5602. 	pcount = gf_list_count(a->points);
    5603. 

  5603. 

  5604. 	if (pcount != gf_list_count(b->points)) return GF_BAD_PARAM;
    5605. 

  5605. 

  5606. #if 0
    5607. 

  5607. 	if (ccount != gf_list_count(b->commands)) return GF_BAD_PARAM;
    5608. 

  5608. 	for (i = 0; i < ccount; i++) {
    5609. 

  5609. 		u8 *ac = gf_list_get(a->commands, i);
    5610. 

  5610. 		u8 *bc = gf_list_get(b->commands, i);
    5611. 

  5611. 		if (*ac != *bc) return GF_BAD_PARAM;
    5612. 

  5612. 	}
    5613. 

  5613. #endif
    5614. 

  5614. 

  5615. 	while (gf_list_count(c->commands)) {
    5616. 

  5616. 		u8 *command = (u8 *)gf_list_last(c->commands);
    5617. 

  5617. 		gf_free(command);
    5618. 

  5618. 		gf_list_rem_last(c->commands);
    5619. 

  5619. 	}
    5620. 

  5620. 	while (gf_list_count(c->points)) {
    5621. 

  5621. 		SVG_Point *pt = (SVG_Point *)gf_list_last(c->points);
    5622. 

  5622. 		gf_free(pt);
    5623. 

  5623. 		gf_list_rem_last(c->points);
    5624. 

  5624. 	}
    5625. 

  5625. 

  5626. 	for (i = 0; i < ccount; i++) {
    5627. 

  5627. 		u8 *nc = (u8 *)gf_malloc(sizeof(u8));
    5628. 

  5628. 		*nc = *(u8*)gf_list_get(a->commands, i);
    5629. 

  5629. 		gf_list_add(c->commands, nc);
    5630. 

  5630. 	}
    5631. 

  5631. 	for (i = 0; i < pcount; i++) {
    5632. 

  5632. 		SVG_Point *pta = (SVG_Point *)gf_list_get(a->points, i);
    5633. 

  5633. 		SVG_Point *ptb = (SVG_Point *)gf_list_get(b->points, i);
    5634. 

  5634. 		SVG_Point *ptc;
    5635. 

  5635. 		GF_SAFEALLOC(ptc, SVG_Point)
    5636. 

  5636. 		svg_point_muladd(alpha, pta, beta, ptb, ptc);
    5637. 

  5637. 		gf_list_add(c->points, ptc);
    5638. 

  5638. 	}
    5639. 

  5639. 	return GF_OK;
    5640. 

  5640. }
    5641. 

  5641. #endif
    5642. 

  5642. 

  5643. 

  5644. static GF_Err svg_dasharray_muladd(Fixed alpha, SVG_StrokeDashArray *a, Fixed beta, SVG_StrokeDashArray *b, SVG_StrokeDashArray *c)
    5645. 

  5645. {
    5646. 

  5646. 	u32 i;
    5647. 

  5647. 	if (a->type != b->type) return GF_BAD_PARAM;
    5648. 

  5648. 	if (a->array.count != b->array.count) return GF_BAD_PARAM;
    5649. 

  5649. 

  5650. 	c->type = a->type;
    5651. 

  5651. 	c->array.count = a->array.count;
    5652. 

  5652. 	c->array.vals = (Fixed *) gf_malloc(sizeof(Fixed)*c->array.count);
    5653. 

  5653. 	for (i = 0; i < c->array.count; i++) {
    5654. 

  5654. 		/* TODO: convert units if needed */
    5655. 

  5655.         c->array.units[i] = a->array.units[i];
    5656. 

  5656. 		c->array.vals[i] = gf_mulfix(alpha, a->array.vals[i]) + gf_mulfix(beta, b->array.vals[i]);
    5657. 

  5657. 	}
    5658. 

  5658. 	return GF_OK;
    5659. 

  5659. }
    5660. 

  5660. 

  5661. static GF_Err svg_dasharray_copy(SVG_StrokeDashArray *a, SVG_StrokeDashArray *b)
    5662. 

  5662. {
    5663. 

  5663. 	a->type = b->type;
    5664. 

  5664. 	a->array.count = b->array.count;
    5665. 

  5665. 	a->array.units = (u8*)gf_malloc(sizeof(u8)*a->array.count);
    5666. 

  5666. 	memcpy(a->array.units, b->array.units, sizeof(u8)*a->array.count);
    5667. 

  5667. 	a->array.vals = (Fixed*)gf_malloc(sizeof(Fixed)*a->array.count);
    5668. 

  5668. 	memcpy(a->array.vals, b->array.vals, sizeof(Fixed)*a->array.count);
    5669. 

  5669. 	return GF_OK;
    5670. 

  5670. }
    5671. 

  5671. 

  5672. static GF_Err svg_matrix_muladd(Fixed alpha, GF_Matrix2D *a, Fixed beta, GF_Matrix2D *b, GF_Matrix2D *c)
    5673. 

  5673. {
    5674. 

  5674. 	/*
    5675. 

  5675. 	if ((alpha == beta) && (alpha == FIX_ONE) ) {
    5676. 

  5676. 		GF_Matrix2D tmp;
    5677. 

  5677. 		gf_mx2d_copy(tmp, *b);
    5678. 

  5678. 		gf_mx2d_add_matrix(&tmp, a);
    5679. 

  5679. 		gf_mx2d_copy(*c, tmp);
    5680. 

  5680. 	} else */
    5681. 

  5681. 	if (alpha <= FIX_ONE) {
    5682. 

  5682. 		/* This case should happen only when using animateMotion and accumulation
    5683. 

  5683. 		   see animate-elem-202-t.svg
    5684. 

  5684. 		   we only add and multiply the translation component; */
    5685. 

  5685. 		/*
    5686. 

  5686. 		c->m[0] = gf_mulfix(alpha, a->m[0]) + gf_mulfix(beta, b->m[0]);
    5687. 

  5687. 		c->m[1] = gf_mulfix(alpha, a->m[1]) + gf_mulfix(beta, b->m[1]);
    5688. 

  5688. 		c->m[2] = gf_mulfix(alpha, a->m[2]) + gf_mulfix(beta, b->m[2]);
    5689. 

  5689. 		c->m[3] = gf_mulfix(alpha, a->m[3]) + gf_mulfix(beta, b->m[3]);
    5690. 

  5690. 		*/
    5691. 

  5691. 		c->m[0] = a->m[0];
    5692. 

  5692. 		c->m[1] = a->m[1];
    5693. 

  5693. 		c->m[2] = gf_mulfix(alpha, a->m[2]) + gf_mulfix(beta, b->m[2]);
    5694. 

  5694. 		c->m[3] = a->m[3];
    5695. 

  5695. 		c->m[4] = a->m[4];
    5696. 

  5696. 		c->m[5] = gf_mulfix(alpha, a->m[5]) + gf_mulfix(beta, b->m[5]);
    5697. 

  5697. 	} else {
    5698. 

  5698. 		GF_LOG(GF_LOG_ERROR, GF_LOG_INTERACT, ("[SVG Attributes] matrix operations not supported\n"));
    5699. 

  5699. 		return GF_BAD_PARAM;
    5700. 

  5700. 	}
    5701. 

  5701. 	return GF_OK;
    5702. 

  5702. }
    5703. 

  5703. 

  5704. static GF_Err laser_size_muladd(Fixed alpha, LASeR_Size *sza, Fixed beta, LASeR_Size *szb, LASeR_Size *szc)
    5705. 

  5705. {
    5706. 

  5706. 	szc->width  = gf_mulfix(alpha, sza->width)  + gf_mulfix(beta, szb->width);
    5707. 

  5707. 	szc->height = gf_mulfix(alpha, sza->height) + gf_mulfix(beta, szb->height);
    5708. 

  5708. 	return GF_OK;
    5709. 

  5709. }
    5710. 

  5710. 

  5711. /* c = alpha * a + beta * b */
    5712. 

  5712. GF_Err gf_svg_attributes_muladd(Fixed alpha, GF_FieldInfo *a,
    5713. 

  5713. 							 Fixed beta, GF_FieldInfo *b,
    5714. 

  5714. 							 GF_FieldInfo *c,
    5715. 

  5715. 							 Bool clamp)
    5716. 

  5716. {
    5717. 

  5717. 	if (!a->far_ptr || !b->far_ptr || !c->far_ptr) return GF_BAD_PARAM;
    5718. 

  5718. 

  5719. 	if (a->fieldType != b->fieldType) {
    5720. 

  5720. 		if (a->fieldType != SVG_Transform_datatype &&
    5721. 

  5721. 			a->fieldType != SVG_Transform_Scale_datatype &&
    5722. 

  5722. 			a->fieldType != SVG_Transform_Translate_datatype &&
    5723. 

  5723. 			a->fieldType != SVG_Transform_Rotate_datatype &&
    5724. 

  5724. 			a->fieldType != SVG_Transform_SkewX_datatype &&
    5725. 

  5725. 			a->fieldType != SVG_Transform_SkewY_datatype &&
    5726. 

  5726. 			a->fieldType != SVG_Motion_datatype)
    5727. 

  5727. 		return GF_BAD_PARAM;
    5728. 

  5728. 	}
    5729. 

  5729. 

  5730. 	/* by default a and c are of the same type, except for matrix related types */
    5731. 

  5731. 	c->fieldType = a->fieldType;
    5732. 

  5732. 

  5733. 	switch (a->fieldType) {
    5734. 

  5734. 

  5735. 	/* Numeric types */
    5736. 

  5736. 	case SVG_Color_datatype:
    5737. 

  5737. 		return svg_color_muladd(alpha, (SVG_Color*)a->far_ptr, beta, (SVG_Color*)b->far_ptr, (SVG_Color*)c->far_ptr, clamp);
    5738. 

  5738. 

  5739. 	case SVG_Paint_datatype:
    5740. 

  5740. 		{
    5741. 

  5741. 			SVG_Paint *pa = (SVG_Paint *)a->far_ptr;
    5742. 

  5742. 			SVG_Paint *pb = (SVG_Paint *)b->far_ptr;
    5743. 

  5743. 			SVG_Paint *pc = (SVG_Paint *)c->far_ptr;
    5744. 

  5744. 			if (pa->type != pb->type || pa->type != SVG_PAINT_COLOR || pb->type != SVG_PAINT_COLOR) {
    5745. 

  5745. 				GF_LOG(GF_LOG_ERROR, GF_LOG_INTERACT, ("[SVG Attributes] only color paints are additive\n"));
    5746. 

  5746. 				return GF_BAD_PARAM;
    5747. 

  5747. 			}
    5748. 

  5748. 			pc->type = SVG_PAINT_COLOR;
    5749. 

  5749. 			return svg_color_muladd(alpha, &pa->color, beta, &pb->color, &pc->color, clamp);
    5750. 

  5750. 		}
    5751. 

  5751. 

  5752. 	case SVG_Number_datatype:
    5753. 

  5753. 	case SVG_Length_datatype:
    5754. 

  5754. 	case SVG_Coordinate_datatype:
    5755. 

  5755. 	case SVG_FontSize_datatype:
    5756. 

  5756. 		return svg_number_muladd(alpha, (SVG_Number*)a->far_ptr, beta, (SVG_Number*)b->far_ptr, (SVG_Number*)c->far_ptr);
    5757. 

  5757. 

  5758. 	case SVG_ViewBox_datatype:
    5759. 

  5759. 		return svg_viewbox_muladd(alpha, (SVG_ViewBox*)a->far_ptr, beta, (SVG_ViewBox*)b->far_ptr, (SVG_ViewBox*)c->far_ptr);
    5760. 

  5760. 

  5761. 	case SVG_Points_datatype:
    5762. 

  5762. 		return svg_points_muladd(alpha, (GF_List **)a->far_ptr, beta, (GF_List **)b->far_ptr, (GF_List **)c->far_ptr);
    5763. 

  5763. 

  5764. 	case SVG_Numbers_datatype:
    5765. 

  5765. 	case SVG_Coordinates_datatype:
    5766. 

  5766. 		return svg_numbers_muladd(alpha, (GF_List **)a->far_ptr, beta, (GF_List **)b->far_ptr, (GF_List **)c->far_ptr);
    5767. 

  5767. 

  5768. 	case SVG_PathData_datatype:
    5769. 

  5769. 		return svg_path_muladd(alpha, (SVG_PathData*)a->far_ptr, beta, (SVG_PathData*)b->far_ptr, (SVG_PathData*)c->far_ptr);
    5770. 

  5770. 

  5771. 	case SVG_StrokeDashArray_datatype:
    5772. 

  5772. 		return svg_dasharray_muladd(alpha, (SVG_StrokeDashArray*)a->far_ptr, beta, (SVG_StrokeDashArray*)b->far_ptr, (SVG_StrokeDashArray*)c->far_ptr);
    5773. 

  5773. 

  5774. 	case SVG_Motion_datatype:
    5775. 

  5775. 		return svg_matrix_muladd(alpha, (GF_Matrix2D*)a->far_ptr, beta, (GF_Matrix2D*)b->far_ptr, (GF_Matrix2D*)c->far_ptr);
    5776. 

  5776. 

  5777. 	case SVG_Transform_datatype:
    5778. 

  5778. 		if (b->fieldType == SVG_Transform_datatype) {
    5779. 

  5779. 			SVG_Transform *ta = (SVG_Transform *)a->far_ptr;
    5780. 

  5780. 			SVG_Transform *tb = (SVG_Transform *)b->far_ptr;
    5781. 

  5781. 			SVG_Transform *tc = (SVG_Transform *)c->far_ptr;
    5782. 

  5782. 			if (ta->is_ref == tb->is_ref) {
    5783. 

  5783. 				return svg_matrix_muladd(alpha, &ta->mat, beta, &tb->mat, &tc->mat);
    5784. 

  5784. 			} else {
    5785. 

  5785. 				GF_LOG(GF_LOG_ERROR, GF_LOG_INTERACT, ("[SVG Attributes] matrix operations not supported\n"));
    5786. 

  5786. 				return GF_NOT_SUPPORTED;
    5787. 

  5787. 			}
    5788. 

  5788. 		} else {
    5789. 

  5789. 			/* a and c are matrices but b is not */
    5790. 

  5790. 			GF_Matrix2D tmp;
    5791. 

  5791. 			/*TOCHECK what is this test*/
    5792. 

  5792. /*
    5793. 

  5793. 			if (alpha != FIX_ONE) {
    5794. 

  5794. 				GF_LOG(GF_LOG_ERROR, GF_LOG_INTERACT, ("[SVG Attributes] matrix operations not supported\n"));
    5795. 

  5795. 				return GF_NOT_SUPPORTED;
    5796. 

  5796. 			}
    5797. 

  5797. */
    5798. 

  5798. 			gf_mx2d_init(tmp);
    5799. 

  5799. 			switch (b->fieldType) {
    5800. 

  5800. 			case SVG_Transform_Translate_datatype:
    5801. 

  5801. 				gf_mx2d_add_translation(&tmp, gf_mulfix(((SVG_Point *)b->far_ptr)->x, beta), gf_mulfix(((SVG_Point *)b->far_ptr)->y, beta));
    5802. 

  5802. 				break;
    5803. 

  5803. 			case SVG_Transform_Scale_datatype:
    5804. 

  5804. 				gf_mx2d_add_scale(&tmp, gf_mulfix(((SVG_Point *)b->far_ptr)->x, beta), gf_mulfix(((SVG_Point *)b->far_ptr)->y, beta));
    5805. 

  5805. 				break;
    5806. 

  5806. 			case SVG_Transform_Rotate_datatype:
    5807. 

  5807. 				gf_mx2d_add_rotation(&tmp, gf_mulfix(((SVG_Point_Angle *)b->far_ptr)->x, beta), gf_mulfix(((SVG_Point_Angle *)b->far_ptr)->y, beta), gf_mulfix(((SVG_Point_Angle *)b->far_ptr)->angle, beta));
    5808. 

  5808. 				break;
    5809. 

  5809. 			case SVG_Transform_SkewX_datatype:
    5810. 

  5810. 				gf_mx2d_add_skew_x(&tmp, gf_mulfix(*(Fixed*)b->far_ptr, beta));
    5811. 

  5811. 				break;
    5812. 

  5812. 			case SVG_Transform_SkewY_datatype:
    5813. 

  5813. 				gf_mx2d_add_skew_y(&tmp, gf_mulfix(*(Fixed*)b->far_ptr, beta));
    5814. 

  5814. 				break;
    5815. 

  5815. 			default:
    5816. 

  5816. 				GF_LOG(GF_LOG_ERROR, GF_LOG_INTERACT, ("[SVG Attributes] copy of attributes %s not supported\n", a->name));
    5817. 

  5817. 				return GF_NOT_SUPPORTED;
    5818. 

  5818. 			}
    5819. 

  5819. 			gf_mx2d_add_matrix(&tmp, &((SVG_Transform*)a->far_ptr)->mat);
    5820. 

  5820. 			gf_mx2d_copy(((SVG_Transform*)c->far_ptr)->mat, tmp);
    5821. 

  5821. 			return GF_OK;
    5822. 

  5822. 		}
    5823. 

  5823. 

  5824. 	case SVG_Transform_Translate_datatype:
    5825. 

  5825. 		if (b->fieldType == SVG_Transform_Translate_datatype) {
    5826. 

  5826. 			return svg_point_muladd(alpha, (SVG_Point*)a->far_ptr, beta, (SVG_Point*)b->far_ptr, (SVG_Point*)c->far_ptr);
    5827. 

  5827. 		} else {
    5828. 

  5828. 			GF_LOG(GF_LOG_ERROR, GF_LOG_INTERACT, ("[SVG Attributes] matrix operations not supported\n"));
    5829. 

  5829. 			return GF_NOT_SUPPORTED;
    5830. 

  5830. 		}
    5831. 

  5831. 

  5832. 	case SVG_Transform_Scale_datatype:
    5833. 

  5833. 		if (b->fieldType == SVG_Transform_Scale_datatype) {
    5834. 

  5834. 			if (alpha == FIX_ONE && beta == FIX_ONE) {
    5835. 

  5835. 				/* addition of matrices which represent scales is equivalent
    5836. 

  5836. 				   to multiplication of scale coefficients, we assume this only happens if
    5837. 

  5837. 				   alpha and beta are set to one */
    5838. 

  5838. 				((SVG_Point*)c->far_ptr)->x = gf_mulfix(((SVG_Point*)a->far_ptr)->x,((SVG_Point*)b->far_ptr)->x);
    5839. 

  5839. 				((SVG_Point*)c->far_ptr)->y = gf_mulfix(((SVG_Point*)a->far_ptr)->y,((SVG_Point*)b->far_ptr)->y);
    5840. 

  5840. 				return GF_OK;
    5841. 

  5841. 			} else {
    5842. 

  5842. 				return svg_point_muladd(alpha, (SVG_Point*)a->far_ptr, beta, (SVG_Point*)b->far_ptr, (SVG_Point*)c->far_ptr);
    5843. 

  5843. 			}
    5844. 

  5844. 		} else {
    5845. 

  5845. 			GF_LOG(GF_LOG_ERROR, GF_LOG_INTERACT, ("[SVG Attributes] matrix operations not supported\n"));
    5846. 

  5846. 			return GF_NOT_SUPPORTED;
    5847. 

  5847. 		}
    5848. 

  5848. 

  5849. 	case SVG_Transform_Rotate_datatype:
    5850. 

  5850. 		if (b->fieldType == SVG_Transform_Rotate_datatype) {
    5851. 

  5851. 			return svg_point_angle_muladd(alpha, (SVG_Point_Angle*)a->far_ptr, beta, (SVG_Point_Angle*)b->far_ptr, (SVG_Point_Angle*)c->far_ptr);
    5852. 

  5852. 		} else {
    5853. 

  5853. 			GF_LOG(GF_LOG_ERROR, GF_LOG_INTERACT, ("[SVG Attributes] matrix operations not supported\n"));
    5854. 

  5854. 			return GF_NOT_SUPPORTED;
    5855. 

  5855. 		}
    5856. 

  5856. 

  5857. 	case SVG_Transform_SkewX_datatype:
    5858. 

  5858. 		if (b->fieldType == SVG_Transform_SkewX_datatype) {
    5859. 

  5859. 			*(Fixed*)c->far_ptr = gf_mulfix(alpha, *(Fixed*)a->far_ptr) + gf_mulfix(beta, *(Fixed*)b->far_ptr);
    5860. 

  5860. 			return GF_OK;
    5861. 

  5861. 		} else {
    5862. 

  5862. 			GF_LOG(GF_LOG_ERROR, GF_LOG_INTERACT, ("[SVG Attributes] matrix operations not supported\n"));
    5863. 

  5863. 			return GF_NOT_SUPPORTED;
    5864. 

  5864. 		}
    5865. 

  5865. 

  5866. 	case SVG_Transform_SkewY_datatype:
    5867. 

  5867. 		if (b->fieldType == SVG_Transform_SkewY_datatype) {
    5868. 

  5868. 			*(Fixed*)c->far_ptr = gf_mulfix(alpha, *(Fixed*)a->far_ptr) + gf_mulfix(beta, *(Fixed*)b->far_ptr);
    5869. 

  5869. 			return GF_OK;
    5870. 

  5870. 		} else {
    5871. 

  5871. 			GF_LOG(GF_LOG_ERROR, GF_LOG_INTERACT, ("[SVG Attributes] matrix operations not supported\n"));
    5872. 

  5872. 			return GF_NOT_SUPPORTED;
    5873. 

  5873. 		}
    5874. 

  5874. 

  5875. 	case DOM_String_datatype:
    5876. 

  5876. 	{
    5877. 

  5877. 		u32 len;
    5878. 

  5878. 		char *res;
    5879. 

  5879. 		SVG_String *s_a = (SVG_String *)a->far_ptr;
    5880. 

  5880. 		SVG_String *s_b = (SVG_String *)b->far_ptr;
    5881. 

  5881. 		u32 len_a = (u32) strlen(*s_a);
    5882. 

  5882. 		u32 len_b = (u32) strlen(*s_b);
    5883. 

  5883. 		len_a = FIX2INT(alpha * len_a);
    5884. 

  5884. 		len_b = FIX2INT(beta * len_b);
    5885. 

  5885. 		len = len_a + len_b + 1;
    5886. 

  5886. 		res = (char*)gf_malloc(sizeof(char) * len);
    5887. 

  5887. 		memcpy(res, *s_a, len_a);
    5888. 

  5888. 		memcpy(res+len_a, *s_b, len_b);
    5889. 

  5889. 		res[len-1] = 0;
    5890. 

  5890. 		s_a = (SVG_String*)c->far_ptr;
    5891. 

  5891. 		if (*s_a) gf_free(*s_a);
    5892. 

  5892. 		*s_a = res;
    5893. 

  5893. 	}
    5894. 

  5894. 		break;
    5895. 

  5895. 	case LASeR_Size_datatype:
    5896. 

  5896. 		laser_size_muladd(alpha, (LASeR_Size*)a->far_ptr, beta, (LASeR_Size*)b->far_ptr, (LASeR_Size*)c->far_ptr);
    5897. 

  5897. 		break;
    5898. 

  5898. 

  5899. 	/* Keyword types */
    5900. 

  5900. 	case SVG_Boolean_datatype:
    5901. 

  5901. 	case SVG_FillRule_datatype:
    5902. 

  5902. 	case SVG_StrokeLineJoin_datatype:
    5903. 

  5903. 	case SVG_StrokeLineCap_datatype:
    5904. 

  5904. 	case SVG_FontStyle_datatype:
    5905. 

  5905. 	case SVG_FontWeight_datatype:
    5906. 

  5906. 	case SVG_FontVariant_datatype:
    5907. 

  5907. 	case SVG_TextAnchor_datatype:
    5908. 

  5908. 	case SVG_Display_datatype:
    5909. 

  5909. 	case SVG_Visibility_datatype:
    5910. 

  5910. 	case SVG_GradientUnit_datatype:
    5911. 

  5911. 	case SVG_PreserveAspectRatio_datatype:
    5912. 

  5912. 	case XML_Space_datatype:
    5913. 

  5913. 	case XMLEV_Propagate_datatype:
    5914. 

  5914. 	case XMLEV_DefaultAction_datatype:
    5915. 

  5915. 	case XMLEV_Phase_datatype:
    5916. 

  5916. 	case SMIL_SyncBehavior_datatype:
    5917. 

  5917. 	case SMIL_SyncTolerance_datatype:
    5918. 

  5918. 	case SMIL_AttributeType_datatype:
    5919. 

  5919. 	case SMIL_CalcMode_datatype:
    5920. 

  5920. 	case SMIL_Additive_datatype:
    5921. 

  5921. 	case SMIL_Accumulate_datatype:
    5922. 

  5922. 	case SMIL_Restart_datatype:
    5923. 

  5923. 	case SMIL_Fill_datatype:
    5924. 

  5924. 	case SVG_Overflow_datatype:
    5925. 

  5925. 	case SVG_ZoomAndPan_datatype:
    5926. 

  5926. 	case SVG_DisplayAlign_datatype:
    5927. 

  5927. 	case SVG_TextAlign_datatype:
    5928. 

  5928. 	case SVG_PointerEvents_datatype:
    5929. 

  5929. 	case SVG_RenderingHint_datatype:
    5930. 

  5930. 	case SVG_VectorEffect_datatype:
    5931. 

  5931. 	case SVG_PlaybackOrder_datatype:
    5932. 

  5932. 	case SVG_TimelineBegin_datatype:
    5933. 

  5933. 	case SVG_SpreadMethod_datatype:
    5934. 

  5934. 	case SVG_TransformType_datatype:
    5935. 

  5935. 

  5936. 	/* Unsupported types */
    5937. 

  5937. 	case SVG_ContentType_datatype:
    5938. 

  5938. 	case SVG_LanguageID_datatype:
    5939. 

  5939. 	case SVG_FontFamily_datatype:
    5940. 

  5940. 	case XMLRI_datatype:
    5941. 

  5941. 	case XMLRI_List_datatype:
    5942. 

  5942. 	case DOM_StringList_datatype:
    5943. 

  5943. 	case SVG_Clock_datatype:
    5944. 

  5944. 	case SVG_Focus_datatype:
    5945. 

  5945. 	case SVG_ID_datatype:
    5946. 

  5946. 	case SVG_GradientOffset_datatype:
    5947. 

  5947. 	case SMIL_KeyTimes_datatype:
    5948. 

  5948. 	case SMIL_KeyPoints_datatype:
    5949. 

  5949. 	case SMIL_KeySplines_datatype:
    5950. 

  5950. 	case SMIL_AnimateValue_datatype:
    5951. 

  5951. 	case SMIL_AnimateValues_datatype:
    5952. 

  5952. 	case SMIL_AttributeName_datatype:
    5953. 

  5953. 	case SMIL_Times_datatype:
    5954. 

  5954. 	case SMIL_Duration_datatype:
    5955. 

  5955. 	case SMIL_RepeatCount_datatype:
    5956. 

  5956. 	default:
    5957. 

  5957. 		GF_LOG(GF_LOG_WARNING, GF_LOG_INTERACT, ("[SVG Attributes] addition for attributes %s of type %s not supported\n", a->name, gf_svg_attribute_type_to_string(a->fieldType)));
    5958. 

  5958. 		return GF_NOT_SUPPORTED;
    5959. 

  5959. 	}
    5960. 

  5960. 	return GF_OK;
    5961. 

  5961. }
    5962. 

  5962. 

  5963. /* *a = *b, copy by value */
    5964. 

  5964. GF_EXPORT
    5965. 

  5965. GF_Err gf_svg_attributes_copy(GF_FieldInfo *a, GF_FieldInfo *b, Bool clamp)
    5966. 

  5966. {
    5967. 

  5967. 	if (!a->far_ptr || !b->far_ptr) return GF_BAD_PARAM;
    5968. 

  5968. 	switch (a->fieldType) {
    5969. 

  5969. 	/* Numeric types */
    5970. 

  5970. 	case SVG_Color_datatype:
    5971. 

  5971. 		*((SVG_Color *)a->far_ptr) = *((SVG_Color *)b->far_ptr);
    5972. 

  5972. 		if (clamp) svg_color_clamp((SVG_Color *)a->far_ptr);
    5973. 

  5973. 		break;
    5974. 

  5974. 

  5975. 	case SVG_Paint_datatype:
    5976. 

  5976. 		{
    5977. 

  5977. 			SVG_Paint *pa = (SVG_Paint *)a->far_ptr;
    5978. 

  5978. 			SVG_Paint *pb = (SVG_Paint *)b->far_ptr;
    5979. 

  5979. 			pa->type = pb->type;
    5980. 

  5980. 			if (pb->type == SVG_PAINT_URI) {
    5981. 

  5981. 				GF_FieldInfo tmp_a, tmp_b;
    5982. 

  5982. 				tmp_a.fieldType = tmp_b.fieldType = XMLRI_datatype;
    5983. 

  5983. 				tmp_a.far_ptr = &pa->iri;
    5984. 

  5984. 				tmp_b.far_ptr = &pb->iri;
    5985. 

  5985. 				gf_svg_attributes_copy(&tmp_a, &tmp_b, 0);
    5986. 

  5986. 			} else {
    5987. 

  5987. 				pa->color = pb->color;
    5988. 

  5988. 			}
    5989. 

  5989. 			return GF_OK;
    5990. 

  5990. 		}
    5991. 

  5991. 		break;
    5992. 

  5992. 

  5993. 	case SVG_Number_datatype:
    5994. 

  5994. 	case SVG_Length_datatype:
    5995. 

  5995. 	case SVG_Coordinate_datatype:
    5996. 

  5996. 	case SVG_FontSize_datatype:
    5997. 

  5997. 		*((SVG_Number *)a->far_ptr) = *((SVG_Number *)b->far_ptr);
    5998. 

  5998. 		break;
    5999. 

  5999. 

  6000. 	case SVG_ViewBox_datatype:
    6001. 

  6001. 		*((SVG_ViewBox *)a->far_ptr) = *((SVG_ViewBox *)b->far_ptr);
    6002. 

  6002. 		break;
    6003. 

  6003. 

  6004. 	case SVG_Points_datatype:
    6005. 

  6005. 		return svg_points_copy((GF_List**)a->far_ptr, (GF_List**)b->far_ptr);
    6006. 

  6006. 

  6007. 	case SVG_Numbers_datatype:
    6008. 

  6008. 	case SVG_Coordinates_datatype:
    6009. 

  6009. 		return svg_numbers_copy((GF_List**)a->far_ptr, (GF_List**)b->far_ptr);
    6010. 

  6010. 

  6011. 	case SVG_PathData_datatype:
    6012. 

  6012. 		return svg_path_copy((SVG_PathData*)a->far_ptr, (SVG_PathData*)b->far_ptr);
    6013. 

  6013. 

  6014. 	case SVG_StrokeDashArray_datatype:
    6015. 

  6015. 		return svg_dasharray_copy((SVG_StrokeDashArray*)a->far_ptr, (SVG_StrokeDashArray*)b->far_ptr);
    6016. 

  6016. 

  6017. 	case SVG_Motion_datatype:
    6018. 

  6018. 		gf_mx2d_copy(*(GF_Matrix2D *)a->far_ptr, *(GF_Matrix2D *)b->far_ptr);
    6019. 

  6019. 		return GF_OK;
    6020. 

  6020. 

  6021. 	case SVG_Transform_datatype:
    6022. 

  6022. 		switch (b->fieldType) {
    6023. 

  6023. 		case SVG_Transform_Translate_datatype:
    6024. 

  6024. 			gf_mx2d_init(((SVG_Transform *)a->far_ptr)->mat);
    6025. 

  6025. 			gf_mx2d_add_translation(&((SVG_Transform *)a->far_ptr)->mat, ((SVG_Point*)b->far_ptr)->x, ((SVG_Point*)b->far_ptr)->y);
    6026. 

  6026. 			break;
    6027. 

  6027. 		case SVG_Transform_Scale_datatype:
    6028. 

  6028. 			gf_mx2d_init(((SVG_Transform *)a->far_ptr)->mat);
    6029. 

  6029. 			gf_mx2d_add_scale(&((SVG_Transform *)a->far_ptr)->mat, ((SVG_Point*)b->far_ptr)->x, ((SVG_Point*)b->far_ptr)->y);
    6030. 

  6030. 			break;
    6031. 

  6031. 		case SVG_Transform_Rotate_datatype:
    6032. 

  6032. 			gf_mx2d_init(((SVG_Transform *)a->far_ptr)->mat);
    6033. 

  6033. 			gf_mx2d_add_rotation(&((SVG_Transform *)a->far_ptr)->mat, ((SVG_Point_Angle*)b->far_ptr)->x, ((SVG_Point_Angle*)b->far_ptr)->y, ((SVG_Point_Angle*)b->far_ptr)->angle);
    6034. 

  6034. 			break;
    6035. 

  6035. 		case SVG_Transform_SkewX_datatype:
    6036. 

  6036. 			gf_mx2d_init(((SVG_Transform *)a->far_ptr)->mat);
    6037. 

  6037. 			gf_mx2d_add_skew_x(&((SVG_Transform *)a->far_ptr)->mat, *(Fixed *)b->far_ptr);
    6038. 

  6038. 			break;
    6039. 

  6039. 		case SVG_Transform_SkewY_datatype:
    6040. 

  6040. 			gf_mx2d_init(((SVG_Transform *)a->far_ptr)->mat);
    6041. 

  6041. 			gf_mx2d_add_skew_y(&((SVG_Transform *)a->far_ptr)->mat, *(Fixed *)b->far_ptr);
    6042. 

  6042. 			break;
    6043. 

  6043. 		case SVG_Transform_datatype:
    6044. 

  6044. 			gf_mx2d_copy(((SVG_Transform *)a->far_ptr)->mat, ((SVG_Transform *)b->far_ptr)->mat);
    6045. 

  6045. 			break;
    6046. 

  6046. 		default:
    6047. 

  6047. 			GF_LOG(GF_LOG_ERROR, GF_LOG_INTERACT, ("[SVG Attributes] forbidden type of transform\n"));
    6048. 

  6048. 			return GF_NOT_SUPPORTED;
    6049. 

  6049. 		}
    6050. 

  6050. 		return GF_OK;
    6051. 

  6051. 

  6052. 	/* Keyword types */
    6053. 

  6053. 	case SVG_Boolean_datatype:
    6054. 

  6054. 	case SVG_FillRule_datatype:
    6055. 

  6055. 	case SVG_StrokeLineJoin_datatype:
    6056. 

  6056. 	case SVG_StrokeLineCap_datatype:
    6057. 

  6057. 	case SVG_FontStyle_datatype:
    6058. 

  6058. 	case SVG_FontWeight_datatype:
    6059. 

  6059. 	case SVG_FontVariant_datatype:
    6060. 

  6060. 	case SVG_TextAnchor_datatype:
    6061. 

  6061. 	case SVG_Display_datatype:
    6062. 

  6062. 	case SVG_Visibility_datatype:
    6063. 

  6063. 	case SVG_GradientUnit_datatype:
    6064. 

  6064. 	case SVG_PreserveAspectRatio_datatype:
    6065. 

  6065. 	case XML_Space_datatype:
    6066. 

  6066. 	case XMLEV_Propagate_datatype:
    6067. 

  6067. 	case XMLEV_DefaultAction_datatype:
    6068. 

  6068. 	case XMLEV_Phase_datatype:
    6069. 

  6069. 	case SMIL_SyncBehavior_datatype:
    6070. 

  6070. 	case SMIL_AttributeType_datatype:
    6071. 

  6071. 	case SMIL_CalcMode_datatype:
    6072. 

  6072. 	case SMIL_Additive_datatype:
    6073. 

  6073. 	case SMIL_Accumulate_datatype:
    6074. 

  6074. 	case SMIL_Restart_datatype:
    6075. 

  6075. 	case SMIL_Fill_datatype:
    6076. 

  6076. 	case SVG_Overflow_datatype:
    6077. 

  6077. 	case SVG_ZoomAndPan_datatype:
    6078. 

  6078. 	case SVG_DisplayAlign_datatype:
    6079. 

  6079. 	case SVG_TextAlign_datatype:
    6080. 

  6080. 	case SVG_PointerEvents_datatype:
    6081. 

  6081. 	case SVG_RenderingHint_datatype:
    6082. 

  6082. 	case SVG_VectorEffect_datatype:
    6083. 

  6083. 	case SVG_PlaybackOrder_datatype:
    6084. 

  6084. 	case SVG_TimelineBegin_datatype:
    6085. 

  6085. 	case SVG_TransformType_datatype:
    6086. 

  6086. 	case SVG_Focusable_datatype:
    6087. 

  6087. 	case SVG_FocusHighlight_datatype:
    6088. 

  6088. 		*(u8 *)a->far_ptr = *(u8 *)b->far_ptr;
    6089. 

  6089. 		return GF_OK;
    6090. 

  6090. 

  6091. 	case SMIL_SyncTolerance_datatype:
    6092. 

  6092. 		*(SMIL_SyncTolerance*)a->far_ptr = *(SMIL_SyncTolerance*)b->far_ptr;
    6093. 

  6093. 		return GF_OK;
    6094. 

  6094. 	/* Other types */
    6095. 

  6095. 	case SVG_ID_datatype:
    6096. 

  6096. 	case SVG_LanguageID_datatype:
    6097. 

  6097. 	case SVG_ContentType_datatype:
    6098. 

  6098. 	case DOM_String_datatype:
    6099. 

  6099. 		if (* (SVG_String *)a->far_ptr) gf_free(* (SVG_String *)a->far_ptr);
    6100. 

  6100. 			* (SVG_String *)a->far_ptr = *(SVG_String *)b->far_ptr ? gf_strdup(*(SVG_String *)b->far_ptr) : NULL;
    6101. 

  6101. 		return GF_OK;
    6102. 

  6102. 

  6103. 	case SVG_FontFamily_datatype:
    6104. 

  6104. 		((SVG_FontFamily *)a->far_ptr)->type = ((SVG_FontFamily *)b->far_ptr)->type;
    6105. 

  6105. 		if ( ((SVG_FontFamily *)a->far_ptr)->value) gf_free( ((SVG_FontFamily *)a->far_ptr)->value );
    6106. 

  6106. 		((SVG_FontFamily *)a->far_ptr)->value = (((SVG_FontFamily *)b->far_ptr)->value ? gf_strdup(((SVG_FontFamily *)b->far_ptr)->value) : NULL );
    6107. 

  6107. 		return GF_OK;
    6108. 

  6108. 

  6109. 	case XMLRI_datatype:
    6110. 

  6110. 	case XML_IDREF_datatype:
    6111. 

  6111. 		((XMLRI *)a->far_ptr)->type = ((XMLRI *)b->far_ptr)->type;
    6112. 

  6112. 		if (((XMLRI *)a->far_ptr)->string) gf_free(((XMLRI *)a->far_ptr)->string);
    6113. 

  6113. 		if (((XMLRI *)b->far_ptr)->string) {
    6114. 

  6114. 			((XMLRI *)a->far_ptr)->string = gf_strdup(((XMLRI *)b->far_ptr)->string);
    6115. 

  6115. 		} else {
    6116. 

  6116. 			((XMLRI *)a->far_ptr)->string = gf_strdup("");
    6117. 

  6117. 		}
    6118. 

  6118. 		((XMLRI *)a->far_ptr)->target = ((XMLRI *)b->far_ptr)->target;
    6119. 

  6119. 		if (((XMLRI *)a->far_ptr)->type == XMLRI_ELEMENTID) {
    6120. 

  6120. 			GF_Node *n = (GF_Node *) ((XMLRI *)b->far_ptr)->target;
    6121. 

  6121. 			/*TODO Check if assigning IRI from # scenegraph can happen*/
    6122. 

  6122. 			if (n) gf_node_register_iri(gf_node_get_graph(n), (XMLRI*)a->far_ptr);
    6123. 

  6123. 		}
    6124. 

  6124. 		return GF_OK;
    6125. 

  6125. 

  6126. 	case SVG_Focus_datatype:
    6127. 

  6127. 	{
    6128. 

  6128. 		((SVG_Focus *)a->far_ptr)->type = ((SVG_Focus *)b->far_ptr)->type;
    6129. 

  6129. 		if ( ((SVG_Focus *)b->far_ptr)->target.string)
    6130. 

  6130. 			((SVG_Focus *)a->far_ptr)->target.string = gf_strdup( ((SVG_Focus *)b->far_ptr)->target.string);
    6131. 

  6131. 	}
    6132. 

  6132. 		return GF_OK;
    6133. 

  6133. 

  6134. 	case SMIL_Times_datatype:
    6135. 

  6135. 	{
    6136. 

  6136. 		u32 i, count;
    6137. 

  6137. 		GF_List *dst = *(GF_List **)a->far_ptr;
    6138. 

  6138. 		GF_List *src = *(GF_List **)b->far_ptr;
    6139. 

  6139. 		while (gf_list_count(dst)) {
    6140. 

  6140. 			SMIL_Time *t = gf_list_get(dst, 0);
    6141. 

  6141. 			gf_list_rem(dst, 0);
    6142. 

  6142. 			gf_free(t);
    6143. 

  6143. 		}
    6144. 

  6144. 		count = gf_list_count(src);
    6145. 

  6145. 		for (i=0;i<count;i++) {
    6146. 

  6146. 			SMIL_Time *t2;
    6147. 

  6147. 			SMIL_Time *t = gf_list_get(src, i);
    6148. 

  6148. 			t2 = (SMIL_Time*)gf_malloc(sizeof(SMIL_Time));
    6149. 

  6149. 			memcpy(t2, t, sizeof(SMIL_Time));
    6150. 

  6150. 			gf_list_add(dst, t2);
    6151. 

  6151. 		}
    6152. 

  6152. 	}
    6153. 

  6153. 		return GF_OK;
    6154. 

  6154. 	case SMIL_AttributeName_datatype:
    6155. 

  6155. 	{
    6156. 

  6156. 		SMIL_AttributeName *saa = (SMIL_AttributeName *)a->far_ptr;
    6157. 

  6157. 		SMIL_AttributeName *sab = (SMIL_AttributeName *)b->far_ptr;
    6158. 

  6158. 		saa->tag = sab->tag;
    6159. 

  6159. 		saa->type = sab->type;
    6160. 

  6160. 		saa->name = sab->name ? gf_strdup(sab->name) : NULL;
    6161. 

  6161. 	}
    6162. 

  6162. 		break;
    6163. 

  6163. 	case SMIL_Duration_datatype:
    6164. 

  6164. 	{
    6165. 

  6165. 		SMIL_Duration *da = (SMIL_Duration*)a->far_ptr;
    6166. 

  6166. 		SMIL_Duration *db = (SMIL_Duration*)b->far_ptr;
    6167. 

  6167. 		da->type = db->type;
    6168. 

  6168. 		da->clock_value = db->clock_value;
    6169. 

  6169. 	}
    6170. 

  6170. 		break;
    6171. 

  6171. 	case SMIL_AnimateValue_datatype:
    6172. 

  6172. 	{
    6173. 

  6173. 		SMIL_AnimateValue *sa = (SMIL_AnimateValue*)a->far_ptr;
    6174. 

  6174. 		SMIL_AnimateValue *sb = (SMIL_AnimateValue*)b->far_ptr;
    6175. 

  6175. 		sa->type = sb->type;
    6176. 

  6176. 		if (sb->value) {
    6177. 

  6177. 			GF_FieldInfo ava, avb;
    6178. 

  6178. 			sa->value = gf_svg_create_attribute_value(sa->type);
    6179. 

  6179. 			ava.fieldIndex = avb.fieldIndex = 0;
    6180. 

  6180. 			ava.fieldType = avb.fieldType = sb->type;
    6181. 

  6181. 			ava.far_ptr = sa->value;
    6182. 

  6182. 			avb.far_ptr = sb->value;
    6183. 

  6183. 			gf_svg_attributes_copy(&ava, &avb, 0);
    6184. 

  6184. 		}
    6185. 

  6185. 	}
    6186. 

  6186. 		break;
    6187. 

  6187. 

  6188. 	/* Unsupported types */
    6189. 

  6189. 	case XMLRI_List_datatype:
    6190. 

  6190. 	case DOM_StringList_datatype:
    6191. 

  6191. 	case SVG_GradientOffset_datatype:
    6192. 

  6192. 	case SVG_Clock_datatype:
    6193. 

  6193. 	case SMIL_KeyTimes_datatype:
    6194. 

  6194. 	case SMIL_KeyPoints_datatype:
    6195. 

  6195. 	case SMIL_KeySplines_datatype:
    6196. 

  6196. 	case SMIL_AnimateValues_datatype:
    6197. 

  6197. 	case SMIL_RepeatCount_datatype:
    6198. 

  6198. 	default:
    6199. 

  6199. 		GF_LOG(GF_LOG_WARNING, GF_LOG_INTERACT, ("[SVG Attributes] copy of attributes %s of type %s not supported\n", a->name, gf_svg_attribute_type_to_string(a->fieldType)));
    6200. 

  6200. 		return GF_OK;
    6201. 

  6201. 	}
    6202. 

  6202. 	return GF_OK;
    6203. 

  6203. }
    6204. 

  6204. 

  6205. /* c = a + b */
    6206. 

  6206. GF_Err gf_svg_attributes_add(GF_FieldInfo *a, GF_FieldInfo *b, GF_FieldInfo *c, Bool clamp)
    6207. 

  6207. {
    6208. 

  6208. 	return gf_svg_attributes_muladd(FIX_ONE, a, FIX_ONE, b, c, clamp);
    6209. 

  6209. }
    6210. 

  6210. 

  6211. Bool gf_svg_attribute_is_interpolatable(u32 type)
    6212. 

  6212. {
    6213. 

  6213. 	switch (type) {
    6214. 

  6214. 	/* additive types which can really be interpolated */
    6215. 

  6215. 	case SVG_Color_datatype:
    6216. 

  6216. 	case SVG_Paint_datatype:
    6217. 

  6217. 	case SVG_Number_datatype:
    6218. 

  6218. 	case SVG_Length_datatype:
    6219. 

  6219. 	case SVG_Coordinate_datatype:
    6220. 

  6220. 	case SVG_FontSize_datatype:
    6221. 

  6221. 	case SVG_ViewBox_datatype:
    6222. 

  6222. 	case SVG_Points_datatype:
    6223. 

  6223. 	case SVG_Numbers_datatype:
    6224. 

  6224. 	case SVG_Coordinates_datatype:
    6225. 

  6225. 	case SVG_PathData_datatype:
    6226. 

  6226. 	case SVG_Motion_datatype:
    6227. 

  6227. 	case SVG_Transform_datatype:
    6228. 

  6228. 	case SVG_Transform_Translate_datatype:
    6229. 

  6229. 	case SVG_Transform_Scale_datatype:
    6230. 

  6230. 	case SVG_Transform_Rotate_datatype:
    6231. 

  6231. 	case SVG_Transform_SkewX_datatype:
    6232. 

  6232. 	case SVG_Transform_SkewY_datatype:
    6233. 

  6233. 	case LASeR_Size_datatype:
    6234. 

  6234. 		return 1;
    6235. 

  6235. 	}
    6236. 

  6236. 	return 0;
    6237. 

  6237. }
    6238. 

  6238. 

  6239. GF_Err gf_svg_attributes_interpolate(GF_FieldInfo *a, GF_FieldInfo *b, GF_FieldInfo *c, Fixed coef, Bool clamp)
    6240. 

  6240. {
    6241. 

  6241. 	if (!a->far_ptr || !b->far_ptr || !c->far_ptr) return GF_BAD_PARAM;
    6242. 

  6242. 

  6243. 	c->fieldType = a->fieldType;
    6244. 

  6244. 

  6245. 	switch (a->fieldType) {
    6246. 

  6246. 

  6247. 	/* additive types which can really be interpolated */
    6248. 

  6248. 	case SVG_Color_datatype:
    6249. 

  6249. 	case SVG_Paint_datatype:
    6250. 

  6250. 	case SVG_Number_datatype:
    6251. 

  6251. 	case SVG_Length_datatype:
    6252. 

  6252. 	case SVG_Coordinate_datatype:
    6253. 

  6253. 	case SVG_FontSize_datatype:
    6254. 

  6254. 	case SVG_ViewBox_datatype:
    6255. 

  6255. 	case SVG_Points_datatype:
    6256. 

  6256. 	case SVG_Numbers_datatype:
    6257. 

  6257. 	case SVG_Coordinates_datatype:
    6258. 

  6258. 	case SVG_PathData_datatype:
    6259. 

  6259. 	case SVG_Motion_datatype:
    6260. 

  6260. 	case SVG_Transform_datatype:
    6261. 

  6261. 	case SVG_Transform_Translate_datatype:
    6262. 

  6262. 	case SVG_Transform_Scale_datatype:
    6263. 

  6263. 	case SVG_Transform_Rotate_datatype:
    6264. 

  6264. 	case SVG_Transform_SkewX_datatype:
    6265. 

  6265. 	case SVG_Transform_SkewY_datatype:
    6266. 

  6266. 	case LASeR_Size_datatype:
    6267. 

  6267. 		return gf_svg_attributes_muladd(FIX_ONE-coef, a, coef, b, c, clamp);
    6268. 

  6268. 

  6269. 	/* discrete types: interpolation is the selection of one of the 2 values
    6270. 

  6270. 		using the coeff and a the 0.5 threshold */
    6271. 

  6271. 	/* Keyword types */
    6272. 

  6272. 	case SVG_Boolean_datatype:
    6273. 

  6273. 	case SVG_FillRule_datatype:
    6274. 

  6274. 	case SVG_StrokeLineJoin_datatype:
    6275. 

  6275. 	case SVG_StrokeLineCap_datatype:
    6276. 

  6276. 	case SVG_FontStyle_datatype:
    6277. 

  6277. 	case SVG_FontWeight_datatype:
    6278. 

  6278. 	case SVG_FontVariant_datatype:
    6279. 

  6279. 	case SVG_TextAnchor_datatype:
    6280. 

  6280. 	case SVG_Display_datatype:
    6281. 

  6281. 	case SVG_Visibility_datatype:
    6282. 

  6282. 	case SVG_GradientUnit_datatype:
    6283. 

  6283. 	case SVG_PreserveAspectRatio_datatype:
    6284. 

  6284. 	case SVG_TransformType_datatype:
    6285. 

  6285. 	case XML_Space_datatype:
    6286. 

  6286. 	case XMLEV_Propagate_datatype:
    6287. 

  6287. 	case XMLEV_DefaultAction_datatype:
    6288. 

  6288. 	case XMLEV_Phase_datatype:
    6289. 

  6289. 	case SMIL_SyncBehavior_datatype:
    6290. 

  6290. 	case SMIL_SyncTolerance_datatype:
    6291. 

  6291. 	case SMIL_AttributeType_datatype:
    6292. 

  6292. 	case SMIL_CalcMode_datatype:
    6293. 

  6293. 	case SMIL_Additive_datatype:
    6294. 

  6294. 	case SMIL_Accumulate_datatype:
    6295. 

  6295. 	case SMIL_Restart_datatype:
    6296. 

  6296. 	case SMIL_Fill_datatype:
    6297. 

  6297. 	case SVG_Overflow_datatype:
    6298. 

  6298. 	case SVG_ZoomAndPan_datatype:
    6299. 

  6299. 	case SVG_DisplayAlign_datatype:
    6300. 

  6300. 	case SVG_TextAlign_datatype:
    6301. 

  6301. 	case SVG_PointerEvents_datatype:
    6302. 

  6302. 	case SVG_RenderingHint_datatype:
    6303. 

  6303. 	case SVG_VectorEffect_datatype:
    6304. 

  6304. 	case SVG_PlaybackOrder_datatype:
    6305. 

  6305. 	case SVG_TimelineBegin_datatype:
    6306. 

  6306. 

  6307. 	/* Other non keyword types but which can still be discretely interpolated */
    6308. 

  6308. 	case DOM_String_datatype:
    6309. 

  6309. 	case SVG_ContentType_datatype:
    6310. 

  6310. 	case SVG_LanguageID_datatype:
    6311. 

  6311. 	case SVG_FontFamily_datatype:
    6312. 

  6312. 	case XMLRI_datatype:
    6313. 

  6313. 	case XMLRI_List_datatype:
    6314. 

  6314. 	case DOM_StringList_datatype:
    6315. 

  6315. 	case SVG_Clock_datatype:
    6316. 

  6316. 	case SVG_ID_datatype:
    6317. 

  6317. 	case SVG_GradientOffset_datatype:
    6318. 

  6318. 	case LASeR_Choice_datatype:
    6319. 

  6319. 		if (coef < FIX_ONE/2) {
    6320. 

  6320. 			gf_svg_attributes_copy(c, a, clamp);
    6321. 

  6321. 		} else {
    6322. 

  6322. 			gf_svg_attributes_copy(c, b, clamp);
    6323. 

  6323. 		}
    6324. 

  6324. 		return GF_OK;
    6325. 

  6325. 

  6326. 	/* Unsupported types */
    6327. 

  6327. 	case SMIL_KeyTimes_datatype:
    6328. 

  6328. 	case SMIL_KeyPoints_datatype:
    6329. 

  6329. 	case SMIL_KeySplines_datatype:
    6330. 

  6330. 	case SMIL_AnimateValue_datatype:
    6331. 

  6331. 	case SMIL_AnimateValues_datatype:
    6332. 

  6332. 	case SMIL_AttributeName_datatype:
    6333. 

  6333. 	case SMIL_Times_datatype:
    6334. 

  6334. 	case SMIL_Duration_datatype:
    6335. 

  6335. 	case SMIL_RepeatCount_datatype:
    6336. 

  6336. 	default:
    6337. 

  6337. 		GF_LOG(GF_LOG_WARNING, GF_LOG_INTERACT, ("[SVG Attributes] interpolation for attributes %s of type %s not supported\n", a->name, gf_svg_attribute_type_to_string(a->fieldType)));
    6338. 

  6338. 		return GF_OK;
    6339. 

  6339. 	}
    6340. 

  6340. 	return GF_OK;
    6341. 

  6341. 

  6342. }
    6343. 

  6343. 

  6344. Bool gf_svg_is_current_color(GF_FieldInfo *a)
    6345. 

  6345. {
    6346. 

  6346. 	switch (a->fieldType) {
    6347. 

  6347. 	case SVG_Color_datatype:
    6348. 

  6348. 		return (((SVG_Color *)a->far_ptr)->type == SVG_COLOR_CURRENTCOLOR);
    6349. 

  6349. 		break;
    6350. 

  6350. 	case SVG_Paint_datatype:
    6351. 

  6351. 		if ( ((SVG_Paint *)a->far_ptr)->type == SVG_PAINT_COLOR) {
    6352. 

  6352. 			return (((SVG_Paint *)a->far_ptr)->color.type == SVG_COLOR_CURRENTCOLOR);
    6353. 

  6353. 		} else {
    6354. 

  6354. 			return 0;
    6355. 

  6355. 		}
    6356. 

  6356. 		break;
    6357. 

  6357. 	}
    6358. 

  6358. 	return 0;
    6359. 

  6359. }
    6360. 

  6360. 

  6361. 

  6362. 

  6363. char *gf_svg_attribute_type_to_string(u32 att_type)
    6364. 

  6364. {
    6365. 

  6365. 	switch (att_type) {
    6366. 

  6366. 	case SVG_FillRule_datatype:			return "FillRule";
    6367. 

  6367. 	case SVG_StrokeLineJoin_datatype:	return "StrokeLineJoin";
    6368. 

  6368. 	case SVG_StrokeLineCap_datatype:	return "StrokeLineCap";
    6369. 

  6369. 	case SVG_FontStyle_datatype:		return "FontStyle";
    6370. 

  6370. 	case SVG_FontWeight_datatype:		return "FontWeight";
    6371. 

  6371. 	case SVG_FontVariant_datatype:		return "FontVariant";
    6372. 

  6372. 	case SVG_TextAnchor_datatype:		return "TextAnchor";
    6373. 

  6373. 	case SVG_TransformType_datatype:	return "TransformType";
    6374. 

  6374. 	case SVG_Display_datatype:			return "Display";
    6375. 

  6375. 	case SVG_Visibility_datatype:		return "Visibility";
    6376. 

  6376. 	case SVG_Overflow_datatype:			return "Overflow";
    6377. 

  6377. 	case SVG_ZoomAndPan_datatype:		return "ZoomAndPan";
    6378. 

  6378. 	case SVG_DisplayAlign_datatype:		return "DisplayAlign";
    6379. 

  6379. 	case SVG_PointerEvents_datatype:	return "PointerEvents";
    6380. 

  6380. 	case SVG_RenderingHint_datatype:	return "RenderingHint";
    6381. 

  6381. 	case SVG_VectorEffect_datatype:		return "VectorEffect";
    6382. 

  6382. 	case SVG_PlaybackOrder_datatype:	return "PlaybackOrder";
    6383. 

  6383. 	case SVG_TimelineBegin_datatype:	return "TimelineBegin";
    6384. 

  6384. 	case XML_Space_datatype:			return "XML_Space";
    6385. 

  6385. 	case XMLEV_Propagate_datatype:		return "XMLEV_Propagate";
    6386. 

  6386. 	case XMLEV_DefaultAction_datatype:	return "XMLEV_DefaultAction";
    6387. 

  6387. 	case XMLEV_Phase_datatype:			return "XMLEV_Phase";
    6388. 

  6388. 	case SMIL_SyncBehavior_datatype:	return "SMIL_SyncBehavior";
    6389. 

  6389. 	case SMIL_SyncTolerance_datatype:	return "SMIL_SyncTolerance";
    6390. 

  6390. 	case SMIL_AttributeType_datatype:	return "SMIL_AttributeType";
    6391. 

  6391. 	case SMIL_CalcMode_datatype:		return "SMIL_CalcMode";
    6392. 

  6392. 	case SMIL_Additive_datatype:		return "SMIL_Additive";
    6393. 

  6393. 	case SMIL_Accumulate_datatype:		return "SMIL_Accumulate";
    6394. 

  6394. 	case SMIL_Restart_datatype:			return "SMIL_Restart";
    6395. 

  6395. 	case SMIL_Fill_datatype:			return "SMIL_Fill";
    6396. 

  6396. 	case SVG_GradientUnit_datatype:		return "GradientUnit";
    6397. 

  6397. 	case SVG_InitialVisibility_datatype:return "InitialVisibility";
    6398. 

  6398. 	case SVG_FocusHighlight_datatype:	return "FocusHighlight";
    6399. 

  6399. 	case SVG_Overlay_datatype:			return "Overlay";
    6400. 

  6400. 	case SVG_TransformBehavior_datatype:return "TransformBehavior";
    6401. 

  6401. 	case SVG_SpreadMethod_datatype:		return "SpreadMethod";
    6402. 

  6402. 	case SVG_TextAlign_datatype:		return "TextAlign";
    6403. 

  6403. 	case SVG_Number_datatype:			return "Number";
    6404. 

  6404. 	case SVG_FontSize_datatype:			return "FontSize";
    6405. 

  6405. 	case SVG_Length_datatype:			return "Length";
    6406. 

  6406. 	case SVG_Coordinate_datatype:		return "Coordinate";
    6407. 

  6407. 	case SVG_Rotate_datatype:			return "Rotate";
    6408. 

  6408. 	case SVG_Numbers_datatype:			return "Numbers";
    6409. 

  6409. 	case SVG_Points_datatype:			return "Points";
    6410. 

  6410. 	case SVG_Coordinates_datatype:		return "Coordinates";
    6411. 

  6411. 	case DOM_StringList_datatype:		return "StringList";
    6412. 

  6412. 	case XMLRI_List_datatype:			return "ListOfIRI";
    6413. 

  6413. 	case SMIL_KeyTimes_datatype:		return "SMIL_KeyTimes";
    6414. 

  6414. 	case SMIL_KeySplines_datatype:		return "SMIL_KeySplines";
    6415. 

  6415. 	case SMIL_KeyPoints_datatype:		return "SMIL_KeyPoints";
    6416. 

  6416. 	case SMIL_Times_datatype:			return "SMIL_Times";
    6417. 

  6417. 	case SMIL_AnimateValue_datatype:	return "SMIL_AnimateValue";
    6418. 

  6418. 	case SMIL_AnimateValues_datatype:	return "SMIL_AnimateValues";
    6419. 

  6419. 	case SMIL_Duration_datatype:		return "SMIL_Duration";
    6420. 

  6420. 	case SMIL_RepeatCount_datatype:		return "SMIL_RepeatCount";
    6421. 

  6421. 	case SMIL_AttributeName_datatype:	return "SMIL_AttributeName";
    6422. 

  6422. 	case SVG_Boolean_datatype:			return "Boolean";
    6423. 

  6423. 	case SVG_Color_datatype:			return "Color";
    6424. 

  6424. 	case SVG_Paint_datatype:			return "Paint";
    6425. 

  6425. 	case SVG_PathData_datatype:			return "PathData";
    6426. 

  6426. 	case SVG_FontFamily_datatype:		return "FontFamily";
    6427. 

  6427. 	case SVG_ID_datatype:				return "ID";
    6428. 

  6428. 	case XMLRI_datatype:				return "IRI";
    6429. 

  6429. 	case XML_IDREF_datatype:			return "IDREF";
    6430. 

  6430. 	case SVG_StrokeDashArray_datatype:	return "StrokeDashArray";
    6431. 

  6431. 	case SVG_PreserveAspectRatio_datatype:return "PreserveAspectRatio";
    6432. 

  6432. 	case SVG_ViewBox_datatype:			return "ViewBox";
    6433. 

  6433. 	case SVG_GradientOffset_datatype:	return "GradientOffset";
    6434. 

  6434. 	case SVG_Focus_datatype	:			return "Focus";
    6435. 

  6435. 	case SVG_Clock_datatype	:			return "Clock";
    6436. 

  6436. 	case DOM_String_datatype	:		return "String";
    6437. 

  6437. 	case SVG_ContentType_datatype:		return "ContentType";
    6438. 

  6438. 	case SVG_LanguageID_datatype:		return "LanguageID";
    6439. 

  6439. 	case XMLEV_Event_datatype:			return "XMLEV_Event";
    6440. 

  6440. 	case SVG_Motion_datatype:			return "Motion";
    6441. 

  6441. 	case SVG_Transform_datatype:		return "Transform";
    6442. 

  6442. 	case SVG_Transform_Translate_datatype:return "Translate";
    6443. 

  6443. 	case SVG_Transform_Scale_datatype:	return "Scale";
    6444. 

  6444. 	case SVG_Transform_SkewX_datatype:	return "SkewX";
    6445. 

  6445. 	case SVG_Transform_SkewY_datatype:	return "SkewY";
    6446. 

  6446. 	case SVG_Transform_Rotate_datatype:	return "Rotate";
    6447. 

  6447. 	case LASeR_Choice_datatype:			return "LASeR_Choice";
    6448. 

  6448. 	case LASeR_Size_datatype:			return "LASeR_Size";
    6449. 

  6449. 	default:							return "UnknownType";
    6450. 

  6450. 	}
    6451. 

  6451. }
    6452. 

  6452. 

  6453. 

  6454. #endif /*GPAC_DISABLE_SVG*/
    6455. 

  6455.